Convert issues to specific github issue format

ai/memory-bank/tasks/TASK_1_CCD_GITHUB_ISSUE.md

@@ -0,0 +1,23 @@
+# Title
+Continuous Collision Detection (CCD) Implementation
+
+## Labels
+enhancement, physics
+
+## Body
+**Description**: Implement Continuous Collision Detection to prevent "tunneling" at high velocities. This involves calculating time of impact (TOI) between moving bodies.
+
+**Acceptance Criteria**:
+- 0% tunneling observed at velocities up to 1000m/s.
+- CCD pipeline integrates with the existing collision detection system.
+- Performance impact remains within acceptable bounds for high-speed simulations.
+
+**Assigned Agency Role**:
+Continuous Collision Detection (CCD) Implementation needs to be resolved/issued/tested by the Physics Engineer
+
+**Files to Create/Edit**:
+- src/physics/ccd.rs
+- src/physics/mod.rs
+- src/physics/world.rs
+
+**Reference**: Tier 1 Projects - Continuous Collision Detection (CCD)

ai/memory-bank/tasks/TASK_2_DOD_GITHUB_ISSUE.md

@@ -0,0 +1,23 @@
+# Title
+Data-Oriented Design (DOD) & ECS Refactoring
+
+## Labels
+architecture, refactoring
+
+## Body
+**Description**: Refactor core engine structures to support Data-Oriented Design, making it compatible with modern ECS architectures like Bevy and Flecs.
+
+**Acceptance Criteria**:
+- Memory layout is optimized for cache coherency.
+- API allows integration with a standard ECS in under 2 hours.
+- Core systems (e.g., rigid body updates) operate on flat arrays or similar DOD structures.
+
+**Assigned Agency Role**:
+Data-Oriented Design (DOD) & ECS Refactoring needs to be resolved/issued/tested by the Architecture Lead
+
+**Files to Create/Edit**:
+- src/physics/rigid_body.rs
+- src/physics/world.rs
+- src/physics/components.rs
+
+**Reference**: Tier 1 Projects - Data-Oriented Design (DOD) & ECS Compatibility

ai/memory-bank/tasks/TASK_3_SIMD_GITHUB_ISSUE.md

@@ -0,0 +1,24 @@
+# Title
+Multithreading and SIMD Vectorization
+
+## Labels
+performance, optimization
+
+## Body
+**Description**: Integrate `rayon` for task-based parallelism and `wide` for vectorizing math operations in the physics pipeline. Refactor parallel iteration over large mutable SoA arrays in `World::step` to chain `.par_iter_mut().zip(...)` instead of passing tuples.
+
+**Acceptance Criteria**:
+- Engine scales linearly up to 16 threads on supported hardware.
+- Core math operations (vector additions, dot products, cross products) utilize SIMD instructions.
+- Thread synchronization does not introduce unresolvable latency.
+- Iterating multiple mutable SoA arrays in `rayon` must chain `.par_iter_mut().zip(...)`.
+
+**Assigned Agency Role**:
+Multithreading and SIMD Vectorization needs to be resolved/issued/tested by the Systems Engineer
+
+**Files to Create/Edit**:
+- Cargo.toml
+- src/geometry/vector.rs
+- src/physics/world.rs
+
+**Reference**: Tier 1 Projects - Multithreading and SIMD Vectorization

ai/memory-bank/tasks/TASK_4_DETERMINISM_GITHUB_ISSUE.md

@@ -0,0 +1,23 @@
+# Title
+Cross-Platform Determinism Setup
+
+## Labels
+determinism, ci
+
+## Body
+**Description**: Implement strict floating-point math control and deterministic solver execution across multiple architectures using `libm`.
+
+**Acceptance Criteria**:
+- Simulation yields identical results across different CPU architectures.
+- CI testing pipeline includes deterministic behavior checks.
+- Fallback mechanisms for non-deterministic math functions are implemented.
+
+**Assigned Agency Role**:
+Cross-Platform Determinism Setup needs to be resolved/issued/tested by the Systems Engineer
+
+**Files to Create/Edit**:
+- src/physics/math.rs
+- src/physics/constants.rs
+- Tests related to cross-platform execution.
+
+**Reference**: Tier 2 Projects - Cross-Platform Determinism

ai/memory-bank/tasks/TASK_5_GPU_GITHUB_ISSUE.md

@@ -0,0 +1,24 @@
+# Title
+GPU Acceleration (Compute Shaders) Integration
+
+## Labels
+gpu, wgpu
+
+## Body
+**Description**: Future-proof the engine by integrating `wgpu` (~v0.19) for GPU-accelerated compute shaders, initially targeting massive scale simulations like soft-bodies or fluids. `Vector3d` sent via `bytemuck` must use `#[repr(C)]` with `Pod` and `Zeroable` derives. In WGSL, use a flat `array<f32>` (indexing by 3) instead of `array<vec3<f32>>`.
+
+**Acceptance Criteria**:
+- Basic WGPU context is established and integrated into the build.
+- A prototype compute shader runs and passes data back to the CPU physics pipeline.
+- CPU pipeline remains stable during GPU execution with no 16-byte memory alignment crashes.
+- WGSL shaders must avoid 16-byte alignment crashes by using flat `array<f32>` and Rust structs must use `#[repr(C)]`, `Pod`, and `Zeroable`.
+
+**Assigned Agency Role**:
+GPU Acceleration (Compute Shaders) Integration needs to be resolved/issued/tested by the Graphics Engineer
+
+**Files to Create/Edit**:
+- Cargo.toml
+- src/physics/gpu.rs
+- shaders/compute.wgsl
+
+**Reference**: Tier 2 Projects - GPU Acceleration (Compute Shaders)