Decisions and Impulses

# Version 1.5

## Major Refactor

- Reorganized core runtime responsibilities to reduce overlapping controller ownership.
- Centralized persistent controller ticking through `DAI_ClientTick`.
- Tightened automation lifecycle handling for Play, Stop, world changes, and session resets.
- Added explicit automation generation ownership to prevent stale gameplay sessions from surviving resets.
- Added hard runtime cleanup for movement, look, targeting, navigation, combat, use, interaction, building, breaking, and item collection.
- Added explicit `DAI_ActionStatus.reset()` support for clean lifecycle boundaries.
- Added queue-head inspection and safer queue binding utilities.
- Replaced queue-wide asynchronous wait binding with chain-safe head binding.
- Removed late-binding behavior that could attach old waits to unrelated navigation generations.

## Autonomous Gameplay

- Reworked `Play Survival` to start through a dedicated automation lifecycle action.
- Made repeated Play requests idempotent to prevent duplicate self-replicating gameplay loops.
- Improved Stop behavior so autonomous state is fully invalidated instead of only clearing the visible action queue.
- Prevented automation state from leaking between worlds or client sessions.
- Improved gameplay progression flow through the new vanilla gameplay architecture.
- Removed the obsolete `ai_survival` gameplay implementation.
- Removed the older `survival_loop` / `survival_cycle` architecture.
- Removed legacy references back into the deprecated survival system.
- Cleaned unused, empty, unreachable, and superseded gameplay definitions.

## Navigation

- Fixed reversed strafe projection in `DAI_PathController`.
- Standardized positive strafe as Minecraft-left across autonomous navigation.
- Improved world-space to local-space movement projection.
- Reduced controller-specific movement inconsistencies.
- Updated item collection to use corrected world-space movement instead of blindly holding forward.
- Improved approach generation ownership and asynchronous wait handling.
- Prevented exploration-owned paths from continuing after exploration is reset.
- Improved path/controller lifecycle cleanup across Stop and world changes.
- Added path-following camera tracking so the player now turns toward the current steering point while travelling.
- Kept movement projection synchronized with the same pending yaw used by the camera.
- Preserved shallow travel pitch while navigating.
- Reduced direct camera ownership across navigation systems.
- Centralized physical player rotation through `DAI_LookController`.

## Targeting & Approach

- Improved target ownership between approach, alignment, mining, and interaction chains.
- Preserved the exact successfully approached block for follow-up actions.
- Improved approach generation isolation so stale waits cannot cancel newer approaches.
- Added safer failure-memory behavior for unreachable targets.
- Prevented world-specific failed-target memory from leaking between worlds.
- Improved route progress tracking and path-node advancement.
- Added detailed approach telemetry for position, target, steering node, world direction, calculated movement, and controller status.
- Improved obstruction handling and destructive fallback safety.
- Prevented distant fallback obstructions from freezing navigation.
- Improved target visibility and final block alignment behavior.

## Camera & Look Control

- Removed direct player rotation writes from `DAI_ApproachController`.
- Removed direct player rotation writes from `DAI_PathController`.
- Removed direct player rotation writes from `DAI_CombatController`.
- Removed direct camera snapping from item collection.
- Made `DAI_LookController` the single physical camera-rotation owner.
- Added `DAI_LookController.reset()` to synchronize stored DAI look state with the player's actual camera.
- Prevented stale autonomous yaw/pitch from being replayed after Stop or session changes.
- Fixed session resets that previously forced stored look state to absolute `0 / 0`.
- Added smooth steering-point camera tracking during approach path traversal.
- Added head yaw and body yaw to debug telemetry.

## Item Collection

- Reworked item collection movement to use camera-independent world-space path projection.
- Added explicit item collection lifecycle state.
- Added `isActive()` and `reset()` support.
- Ensured item collection movement/path state is cancelled by automation Stop.
- Ensured item collection state is cleared when leaving or changing worlds.

## Action Queue & Async Execution

- Added `bindHeadSlot(...)` for chain-safe asynchronous action ownership.
- Retained `bindFirstSlot(...)` only for generic queue editing compatibility.
- Added `peek()` for safe queue-head inspection.
- Tightened approach/wait sequencing.
- Rejected malformed unbound `wait_for_approach` actions instead of attaching them to whichever approach is active.
- Reordered client action dispatch so request-style controllers can consume newly queued work during the same tick.
- Improved asynchronous status isolation between controller operations.

## Runtime & Session Management

- Centralized controller advancement order.
- Moved Path and Explore ticking out of `DAI_ClientRuntime` and into `DAI_ClientTick`.
- Improved same-tick ordering between queue execution, approach updates, and look application.
- Added full session cleanup for persistent navigation and item-collection state.
- Cleared exploration history when leaving a world.
- Cleared failed-target coordinate memory when leaving a world.
- Invalidated automation lifecycle state on disconnect/world change.
- Prevented new worlds from inheriting stale active automation state.

## Conditions & Progression

- Identified and corrected inconsistent specific-item inventory condition handling.
- Standardized item-condition data usage with datapack `parameter` fields.
- Improved gameplay phase gating reliability.
- Reduced progression stalls caused by missing/incorrect condition values.

## Crafting

- Improved crafting progression integration with the gameplay loop.
- Removed misleading duplicate `craft_planks` definition that only handled oak.
- Retained species-specific plank recipes through the generic available-planks sequence.
- Cleaned obsolete and unreachable crafting objectives from the active gameplay datapack.
- Added additional runtime visibility into crafting retries and failures.

## Datapack Refactor

- Reduced the datapack from roughly 740 JSON definitions to roughly 650 active definitions.
- Removed the full deprecated `ai_survival` branch.
- Removed obsolete survival loop definitions.
- Removed empty Nether, Stronghold, and End progression placeholders.
- Removed unreachable gameplay advancement batches and routines.
- Removed unused delay-only advancement routers.
- Removed never-executable automation placeholders.
- Removed redundant aliases where they were not part of the public menu interface.
- Removed empty action-menu categories after invalid entries were eliminated.
- Removed menu buttons pointing to missing action definitions.
- Preserved intentional semantic aliases where both public menu actions remain valid.
- Updated surviving legacy references to the current gameplay architecture.
- Validated the cleaned datapack with:
  - 0 JSON parse errors
  - 0 missing action references
  - 0 action ID collisions
  - 0 deprecated `ai_survival` references
  - 0 empty sequence containers
  - 0 never-condition placeholders
  - 0 empty action menus

## Debugging

- Added centralized `DAI_Debug` runtime telemetry.
- Added configurable-ready debug enable state, currently hardcoded enabled during development.
- Added automatic debug snapshots every 20 ticks.
- Debug snapshots now include:
  - player position and block position
  - velocity and grounded state
  - yaw, pitch, head yaw, and body yaw
  - crosshair hit target
  - movement and look input
  - action status
  - queue size, delay, head, and queued actions
  - selected and interaction targets
  - approach activity and generation
  - break-controller state
  - world dimension and game time
- Added detailed approach steering logs for rapid navigation debugging.

## Reliability Fixes

- Fixed path movement using the opposite strafe direction.
- Fixed stale autonomous camera state across lifecycle changes.
- Fixed multiple camera writers competing with each other.
- Fixed duplicate gameplay-loop startup risk.
- Fixed exploration paths surviving their parent controller.
- Fixed item collection surviving automation resets.
- Fixed world-coordinate memories leaking between worlds.
- Fixed lifecycle target clearing from incorrectly overwriting neutral action status.
- Fixed unbound asynchronous waits attaching to unrelated controller generations.
- Improved runtime determinism by consolidating tick ordering and ownership.

## Internal Cleanup

- Audited all Java source files for direct rotation ownership.
- Reduced physical camera writes to `DAI_LookController` only.
- Audited controller reset behavior across autonomous subsystems.
- Audited Java/datapack action references for stale and missing definitions.
- Removed redundant and deprecated datapack content.
- Established a cleaner baseline for future controller splitting and sub-500-line source organization.