From 88e8957cbaed4342a3de1faa4bc5a8bc2805e45f Mon Sep 17 00:00:00 2001
From: Jeffrey Phillips Freeman <the@jeffreyfreeman.me>
Date: Sat, 14 Feb 2026 18:40:37 -0500
Subject: [PATCH] Docs: Updated implementation plan

---
 implementation_plan.md | 791 ++++++++++++++++++++++-------------------
 1 file changed, 429 insertions(+), 362 deletions(-)

diff --git a/implementation_plan.md b/implementation_plan.md
index f048f614b..1273173ba 100644
--- a/implementation_plan.md
+++ b/implementation_plan.md
@@ -33,11 +33,12 @@
 
 - Keep `docs/specification.md` as the single source of truth; this plan is sequencing only and stays intentionally minimal.
 - Local mode is the only execution target through M6; server mode is stub-only (interfaces raising `NotImplementedError`) with no server implementation.
-- Actions (YAML) instantiate Plans (ULID) that move through Strategize → Execute → Apply; decision trees, corrections, and phase semantics live in the spec.
-- Registry-first: ResourceType/Resource/Tool/Validation/Skill/Actor/Provider registries are authoritative; namespaced names for actions/projects/tools/skills/actors/automation profiles; ULIDs for plans/decisions/resources/attachments.
+- Actions (YAML) are templates; `plan use` instantiates a Plan (ULID) that transitions Action → Strategize → Execute → Apply. Action is non-processing, Strategize/Execute may revert to Strategize, Apply ends in `applied`/`constrained`/`errored`/`cancelled` states; decision trees and corrections persist per spec.
+- Identity rules: actions/projects/tools/skills/actors/automation profiles use namespaced names; plans/decisions/resources/validation attachments use ULIDs; top-level plans may carry names, subplans are ULID-only.
+- Registry-first: ResourceType/Resource/Tool/Validation/Skill/Actor/Provider registries are authoritative.
 - Projects are namespaced scopes linking resources; resources are physical/virtual in a DAG; resource types define parent/child constraints, auto-discovery rules, sandbox strategy, and handler metadata.
 - YAML configs (actions/actors/tools/skills/validations/resource types/automation profiles) follow spec schemas with env-var interpolation; validate at load time.
-- Tools are the only mutation path; tool lifecycle + resource binding captures ChangeSet entries; validations are tool subtypes attached to resources and gate Apply.
+- Tools are the only mutation path; tool lifecycle (discover/activate/execute/deactivate) + resource binding captures ChangeSet entries; validations are tool subtypes attached to resources with optional project/plan scope and required/informational gating.
 - ACMS v1 (UKO + CRP + Context Assembly Pipeline) is the M6 target; details remain in the spec.
 
 ### Core Architectural Requirements
@@ -827,6 +828,7 @@ The following work from the previous implementation has been completed and will
 - Created `features/tool_builtins.feature` (32 scenarios), Robot smoke test (7 tests), ASV benchmarks.
 - Verification: lint 0, typecheck 0, 2630 scenarios passed, 97% total coverage. Tool builtins 97-100% coverage.
 - Branch: `feature/m1-tool-builtins` (based on `feature/m1-tool-runtime-core`)
+- 2026-02-14: Commit traceability sweep found no matching git log entries for skill schema/examples, skill CLI, provider actors, MCP config/adapter, actor compiler, or skill registry persistence; Section 2B traceability tasks remain open.
 ---
 
 ## Roadmap
@@ -974,26 +976,26 @@ CLEVERAGENTS_TEST_MODE=true
 
 ### 2026-02-14 (Day 6 since kickoff on 2026-02-09)
 - Timeline reference: Day 7/M1 = 2026-02-15, Day 10/M2 = 2026-02-18, Day 14/M3 = 2026-02-22, Day 21/M4 = 2026-03-01, Day 25/M5 = 2026-03-05, Day 30/M6 = 2026-03-10.
-- Summary (Team | Status | Risk | Notes): Behind ~5-7d | HIGH | Domain models + resource tables + sandbox strategies landed; critical path still blocked by lifecycle persistence wiring, CLI rebaseline, tool runtime, and ChangeSet/apply pipeline.
+- Summary (Team | Status | Risk | Notes): Behind ~5-7d | HIGH | Tool runtime + file tools + sandbox strategies landed; resource registry tables done; M1 blocked by plan phase rebaseline, persistence wiring, resource/project CLI, and apply pipeline/validation gate.
 - Milestone forecast (Target -> ETA | Delta | Risk):
-  - M1 (2026-02-15) -> ETA 2026-02-20 | +5d | HIGH
-  - M2 (2026-02-18) -> ETA 2026-02-24 | +6d | HIGH
-  - M3 (2026-02-22) -> ETA 2026-03-02 | +8d | HIGH
-  - M4 (2026-03-01) -> ETA 2026-03-09 | +8d | MED-HIGH
-  - M5 (2026-03-05) -> ETA 2026-03-13 | +8d | MED-HIGH
-  - M6 (2026-03-10) -> ETA 2026-03-16 | +6d | MED-HIGH
+  - M1 (2026-02-15) -> ETA 2026-02-21 | +6d | HIGH
+  - M2 (2026-02-18) -> ETA 2026-02-25 | +7d | HIGH
+  - M3 (2026-02-22) -> ETA 2026-03-03 | +9d | HIGH
+  - M4 (2026-03-01) -> ETA 2026-03-10 | +9d | MED-HIGH
+  - M5 (2026-03-05) -> ETA 2026-03-13 | +8d | MEDIUM
+  - M6 (2026-03-10) -> ETA 2026-03-14 | +4d | MED-HIGH
 - Track forecast (Track | Status | ETA | Risk | Blocking):
-  - Track A (Plan lifecycle + persistence) | behind ~5-7d | ETA 2026-02-20 | HIGH | LifecyclePlanRepository + UoW wiring + CLI rebaseline
-  - Track B (Projects/resources + sandbox) | behind ~4-6d | ETA 2026-02-22 | HIGH | resource type loader + resource/project repos + CLI; sandbox strategies done
-  - Track C (Actors/tools/skills/validations) | behind ~6-8d | ETA 2026-03-02 | HIGH | tool runtime + registry + actor YAML compiler
-  - Track D (Change tracking + apply pipeline) | behind ~6-8d | ETA 2026-02-24 | HIGH | ChangeSet model + apply gating + validation stubs
+  - Track A (Plan lifecycle + persistence) | behind ~5-7d | ETA 2026-02-21 | HIGH | plan phase rebaseline + persistence wiring
+  - Track B (Projects/resources + sandbox) | behind ~5-7d | ETA 2026-02-21 | HIGH | resource type model + project/resource repos + CLI
+  - Track C (Actors/tools/skills/validations) | behind ~7-9d | ETA 2026-03-03 | HIGH | tool registry persistence + actor YAML compiler + validation attachments
+  - Track D (Change tracking + apply pipeline) | behind ~5-7d | ETA 2026-02-22 | HIGH | ChangeSet + apply pipeline + execute/apply wiring
   - Track Q (Quality automation) | ahead | ETA 2026-02-15 | LOW | maintenance only
   - Track T (Testing) | at risk (Rui out) | ETA 2026-02-27+ | HIGH | QA load on Brent + feature owners
 - Developer forecast (Name | Availability | Load | Risk | Focus):
-  - Jeff | available | critical-path overloaded | HIGH | lifecycle persistence + tool runtime + CLI rebaseline
-  - Luis | available | high | MED-HIGH | repositories + apply pipeline + persistence wiring
-  - Hamza | available | med-high | MEDIUM | resource type schema + project context + RDF groundwork
-  - Aditya | available | medium | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs
+  - Jeff | available | critical-path overloaded | HIGH | plan phase rebaseline + persistence + resource/project CLI + execute/apply wiring
+  - Luis | available | high | MED-HIGH | repositories + apply pipeline + service wiring
+  - Hamza | available | med-high | MEDIUM | resource types + project DB + RDF groundwork
+  - Aditya | available | medium | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs + MCP configs
   - Brent | available | high (QA load) | MED-HIGH | test coverage + integration stability
   - Rui | unavailable 2026-02-13 to 2026-02-27 | zero | HIGH | test backlog resumes after 2026-02-27
   - Mike/Brian | standby | low | LOW | none
@@ -1194,7 +1196,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil
   - [X] Tests (ASV) [Brent]: Add `benchmarks/precommit_config_bench.py` to benchmark config parsing and hook list extraction.
   - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
   - [X] Git [Brent]: `git add .`
-  - [X] Commit [Brent]: `git commit -m "feat(qa): add pre-commit baseline hooks"`.
+  - [X] Git [Brent]: `git commit -m "feat(qa): add pre-commit baseline hooks"`.
   - [X] Forgejo PR [Brent]: Open PR from `feature/q0-min-precommit` to `master`, wait for CI + review, merge in UI (no CLI merge)
   - [X] Git [Brent]: `git checkout master`
   - [X] Git [Brent]: `git branch -d feature/q0-min-precommit`
@@ -1214,7 +1216,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil
   - [X] Tests (ASV) [Brent]: Add `benchmarks/ci_yaml_parse_bench.py` to benchmark workflow parsing and key lookup. (benchmarks/ci_yaml_parse_bench.py)
   - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). (1673 scenarios passed, 0 failed)
   - [X] Git [Brent]: `git add .` (only after coverage check passes)
-  - [X] Commit [Brent]: `git commit -m "feat(ci): add nox-based PR validation workflow"`.
+  - [X] Git [Brent]: `git commit -m "feat(ci): add nox-based PR validation workflow"`.
   - [X] Forgejo PR [Brent]: Open PR from `feature/q0-min-ci` to `master`, wait for CI + review, merge in UI (no CLI merge)
   - [X] Git [Brent]: `git checkout master`
   - [X] Git [Brent]: `git branch -d feature/q0-min-ci`
@@ -1301,14 +1303,14 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
 
 ### Section 2B: Commit Traceability Fixups [IMMEDIATE]
 
-- [ ] Traceability [Aditya]: Checked `git log --all` on 2026-02-14; no matching commit found for "docs(skill): add skill YAML schema and examples" — keep "Done: commit not found" and reopen if the branch/commit appears.
-- [ ] Traceability [Aditya]: Checked `git log --all` on 2026-02-14; no matching commit found for "feat(cli): add skill commands" — keep "Done: commit not found" and reopen if the branch/commit appears.
+- [ ] Traceability [Aditya]: Find the actual commit message used for "docs(skill): add skill YAML schema and examples" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
+- [ ] Traceability [Aditya]: Find the actual commit message used for "feat(cli): add skill commands" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
 - [X] Traceability [Aditya]: Found commit "docs(actor): update schema.py module docstring" (2026-02-09T20:23:33+05:30); updated C3.schema Done/commit message to match.
-- [ ] Traceability [Aditya]: Checked `git log --all` on 2026-02-14; no matching commit found for "feat(actor): add built-in provider actors" — keep "Done: commit not found" and reopen if the branch/commit appears.
-- [ ] Traceability [Aditya]: Checked `git log --all` on 2026-02-14; no matching commit found for "docs(tool): add MCP config examples" — keep "Done: commit not found" and reopen if the branch/commit appears.
-- [ ] Traceability [Jeff]: Checked `git log --all` on 2026-02-14; no matching commit found for "feat(actor): compile actor YAML to runtime graphs" — keep "Done: commit not found" and reopen if the branch/commit appears.
-- [ ] Traceability [Jeff]: Checked `git log --all` on 2026-02-14; no matching commit found for "feat(tool): add MCP adapter runtime" — keep "Done: commit not found" and reopen if the branch/commit appears.
-- [ ] Traceability [Luis]: Checked `git log --all` on 2026-02-14; no matching commit found for "feat(skill): add skill registry persistence" — keep "Done: commit not found" and reopen if the branch/commit appears.
+- [ ] Traceability [Aditya]: Find the actual commit message used for "feat(actor): add built-in provider actors" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
+- [ ] Traceability [Aditya]: Find the actual commit message used for "docs(tool): add MCP config examples" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
+- [ ] Traceability [Jeff]: Find the actual commit message used for "feat(actor): compile actor YAML to runtime graphs" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
+- [ ] Traceability [Jeff]: Find the actual commit message used for "feat(tool): add MCP adapter runtime" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
+- [ ] Traceability [Luis]: Find the actual commit message used for "feat(skill): add skill registry persistence" in `git log --all`, then update the completed COMMIT entry to replace "Done: commit not found" with the correct `Done: Day <n>, <date> <time>` and align the commit message text.
 - [X] Traceability [Luis]: Found commit "feat(core): add v3 lifecycle models, automation levels, subplan support, and security hardening" (2026-02-10T17:16:10+00:00); updated E1.domain Done/commit message to match.
 
 ### Section 3: Plan Lifecycle [WORKSTREAM A - Luis Lead]
@@ -1433,6 +1435,31 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - ASV benchmarks: 3 suites (validation, file-load, serialization) in `benchmarks/action_schema_bench.py`.
   - All nox sessions pass: lint ✓, typecheck (0 errors) ✓, unit_tests (2222 scenarios) ✓, integration_tests (208 passed) ✓, benchmark ✓, security_scan ✓, coverage (98%) ✓.
 
+  **Parallel Group A2c: Plan Phase + Apply State Rebaseline (M1-critical)**
+    **PARALLEL SUBTRACK A2c.alpha [Jeff]**: Plan phase/state alignment + CLI output updates
+    **SEQUENTIAL MERGE NOTE**: A2c.alpha must land before A5 persistence wiring and D0 apply integration.
+- [ ] **COMMIT (Owner: Jeff | Group: A2c.alpha | Branch: feature/m1-plan-phase-rebaseline | Planned: Day 7 | Expected: Day 8) - Commit message: "feat(domain): rebaseline plan phases and apply states"**
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git pull origin master`
+  - [ ] Git [Jeff]: `git checkout -b feature/m1-plan-phase-rebaseline`
+  - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Jeff]: Update `PlanPhase` to include `ACTION` and remove `APPLIED` as a phase; keep phases strictly `action/strategize/execute/apply` per spec.
+  - [ ] Code [Jeff]: Expand `processing_state` (or introduce `apply_state` mapping) to represent Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`) and keep non-Apply states (`queued`, `processing`, `complete`) for Strategize/Execute.
+  - [ ] Code [Jeff]: Update `Plan` model validators to allow namespaced names for top-level plans and ULID-only identifiers for subplans; enforce ULID-only for subplans in hierarchy validators.
+  - [ ] Code [Jeff]: Update `Plan.as_cli_dict()` + CLI formatting to show Action phase, apply terminal outcome (explicit field), and phase/processing_state alignment.
+  - [ ] Code [Jeff]: Update `PlanLifecycleService` to create plans in Action phase, transition to Strategize on `plan use`, and set Apply terminal outcomes on `plan apply` (including `constrained` for spec-defined reversion cases).
+  - [ ] Docs [Jeff]: Update `docs/reference/plan_model.md` and `docs/reference/plan_lifecycle_service.md` with Action phase semantics, apply terminal outcomes, and reversion rules (Execute/Apply → Strategize).
+  - [ ] Tests (Behave) [Jeff]: Add/adjust scenarios for Action phase creation, Strategize entry, Apply terminal outcomes, and reversion preconditions.
+  - [ ] Tests (Robot) [Jeff]: Update lifecycle Robot suites to assert Action phase visibility and Apply terminal outcome fields in status output.
+  - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_phase_bench.py` for phase transition validation overhead.
+  - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Jeff]: `git add .`
+  - [ ] Git [Jeff]: `git commit -m "feat(domain): rebaseline plan phases and apply states"`
+  - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-phase-rebaseline` to `master` with description "Rebaseline plan phases and apply terminal states to spec, with CLI output updates and tests.".
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git branch -d feature/m1-plan-phase-rebaseline`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+
 - [X] **Stage A3: Plan State Machine** (Day 1-2) - COMPLETED 2026-02-05
   - [X] Code: Implement plan lifecycle state machine
     - [X] Create `PlanLifecycleService` with phase transition methods
@@ -1465,7 +1492,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
     **PARALLEL SUBTRACK A4b.outputs [Jeff]**: Output fields + format parity for action/plan CLI
     **PARALLEL SUBTRACK A4b.tests [Brent]**: Behave + Robot CLI coverage after outputs lock
     **SEQUENTIAL MERGE NOTE**: A4b.action → A4b.plan → A4b.outputs; A4b.tests runs after A4b.outputs.
-- [X] **COMMIT (Owner: Jeff | Group: A4b.action | Branch: feature/m1-action-cli | Planned: Day 6 | Expected: Day 8) - Commit message: "feat(cli): align action commands to spec"**
+- [X] **COMMIT (Owner: Jeff | Group: A4b.action | Branch: feature/m1-action-cli | Done: Day 6, February 14, 2026 06:27:41 +0000) - Commit message: "feat(cli): align action commands to spec"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m1-action-cli`
@@ -1486,7 +1513,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Git [Jeff]: `git branch -d feature/m1-action-cli`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [X] **COMMIT (Owner: Jeff | Group: A4b.plan | Branch: feature/m1-plan-cli | Planned: Day 7 | Expected: Day 9) - Commit message: "feat(cli): align plan use/list/status flags"**
+- [X] **COMMIT (Owner: Jeff | Group: A4b.plan | Branch: feature/m1-plan-cli | Done: Day 6, February 14, 2026 14:21:00 +0000) - Commit message: "feat(cli): align plan use/list/status flags"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m1-plan-cli`
@@ -1506,7 +1533,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Git [Jeff]: `git branch -d feature/m1-plan-cli`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [X] **COMMIT (Owner: Jeff | Group: A4b.outputs | Branch: feature/m1-cli-formats | Done: Day 6, February 14, 2026) - Commit message: "feat(cli): stabilize action/plan output formats"**
+- [X] **COMMIT (Owner: Jeff | Group: A4b.outputs | Branch: feature/m1-cli-formats | Done: Day 6, February 14, 2026 15:22:47 +0000) - Commit message: "feat(cli): stabilize action/plan output formats"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m1-cli-formats`
@@ -1531,8 +1558,10 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Brent]: `git checkout -b feature/m1-cli-tests`
   - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
   - [ ] Tests (Behave) [Brent]: Add CLI coverage for action create/list/show/archive and plan use/list/status/execute/apply/cancel (success + error paths).
+  - [ ] Tests (Behave) [Brent]: Add scenarios for plan use with multi-project args, automation profile overrides, invariants, and actor overrides.
+  - [ ] Tests (Behave) [Brent]: Add scenarios that assert Action phase visibility and Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`) in `plan status` output.
   - [ ] Tests (Behave) [Brent]: Add negative cases for missing config, invalid args, invalid project names, and unknown actions/resources.
-  - [ ] Tests (Robot) [Brent]: Add end-to-end Robot suite for action → plan → execute → apply on a local repo.
+  - [ ] Tests (Robot) [Brent]: Add end-to-end Robot suite for action → plan → execute → apply on a local repo (sandbox + ChangeSet capture verified).
   - [ ] Docs [Brent]: Update `docs/development/testing.md` with CLI suites + fixtures.
   - [ ] Tests (ASV) [Brent]: Add `benchmarks/plan_cli_smoke_bench.py` for CLI argument parsing overhead.
   - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
@@ -1544,12 +1573,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group A5: Plan Persistence (M1-critical)**
+  **PARALLEL SUBTRACK A5.beta [Hamza]**: DB rebaseline for Action phase + Apply terminal states
   **PARALLEL SUBTRACK A5.delta [Luis]**: Lifecycle plan repository + filters
   **PARALLEL SUBTRACK A5.epsilon [Luis]**: UnitOfWork wiring for lifecycle repositories
   **PARALLEL SUBTRACK A5.zeta [Jeff]**: PlanLifecycleService persistence integration
   **PARALLEL SUBTRACK A5.eta [Jeff]**: Legacy plan persistence cleanup
   **PARALLEL CONTINUOUS [Brent]**: Persistence coverage baked into each commit
-  **SEQUENTIAL NOTE**: A5.delta → A5.epsilon → A5.zeta; A5.eta runs after A5.zeta.
+  **SEQUENTIAL NOTE**: A5.beta → A5.delta → A5.epsilon → A5.zeta; A5.eta runs after A5.zeta.
   **LEGACY (completed, superseded by rebaseline)**:
 - [X] **COMMIT (Owner: Jeff | Group: A5.alpha | Branch: feature/m1-db-actions | Done: Day 5, February 13, 2026 17:10:56 +0000) - Commit message: "feat(db): add spec-aligned action and plan tables with migrations, ORM models, and benchmarks"** - LEGACY (superseded by rebaseline)
   - [X] Git [Jeff]: `git checkout master`
@@ -1604,90 +1634,112 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git branch -d feature/m1-db-actions`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report` -- TOTAL 97%.
-- [ ] **COMMIT (Owner: Luis | Group: A5.delta | Branch: feature/m1-plan-repo | Planned: Day 6 | Expected: Day 8) - Commit message: "feat(repo): add lifecycle plan repository"**
-    - [ ] Git [Luis]: `git checkout master`
-    - [ ] Git [Luis]: `git pull origin master`
-    - [ ] Git [Luis]: `git checkout -b feature/m1-plan-repo`
-    - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-    - [ ] Code [Luis]: Implement `LifecyclePlanRepository` backed by `LifecyclePlanModel` (create/get/update/delete) with ordered child persistence for project links, arguments, and invariants.
-    - [ ] Code [Luis]: Add list filters for phase, processing_state, action_name, project_name, and namespace (match CLI flags); ensure deterministic ordering.
-    - [ ] Code [Luis]: Raise explicit errors for duplicate plan_id, missing plan, and invalid phase/state updates.
-    - [ ] Docs [Luis]: Document plan repository contract + filters in `docs/reference/repositories.md`.
-    - [ ] Tests (Behave) [Luis]: Add scenarios for create/get/list/update, filter behavior, and child row ordering.
-    - [ ] Tests (Robot) [Luis]: Add Robot smoke test for repository CRUD via service layer.
-    - [ ] Tests (ASV) [Luis]: Add `benchmarks/plan_repository_bench.py` for list/query performance.
-    - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
-    - [ ] Git [Luis]: `git add .`
-    - [ ] Git [Luis]: `git commit -m "feat(repo): add lifecycle plan repository"`
-    - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-plan-repo` to `master` with description "Add lifecycle plan repository with filters and ordered child persistence.".
-    - [ ] Git [Luis]: `git checkout master`
-    - [ ] Git [Luis]: `git branch -d feature/m1-plan-repo`
-    - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Hamza | Group: A5.beta | Branch: feature/m1-db-plan-phase-rebaseline | Planned: Day 7 | Expected: Day 9) - Commit message: "feat(db): rebaseline plan phase/state enums for Action and Apply terminal states"**
+  - [ ] Git [Hamza]: `git checkout master`
+  - [ ] Git [Hamza]: `git pull origin master`
+  - [ ] Git [Hamza]: `git checkout -b feature/m1-db-plan-phase-rebaseline`
+  - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Hamza]: Add Alembic migration that updates `v3_plans` phase/state constraints to include `action` phase and Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`), and removes `applied` as a phase.
+  - [ ] Code [Hamza]: Rebuild `v3_plans` table safely for SQLite (create temp table → copy → drop → rename) to update CHECK constraints and defaults without data loss.
+  - [ ] Code [Hamza]: Update ORM `LifecyclePlanModel` to accept Action phase + Apply terminal states; ensure serialization/deserialization maps updated enums.
+  - [ ] Code [Hamza]: Mark `automation_level` column as legacy (no new writes); keep nullable for backward compatibility until removal in A6.legacy cleanup.
+  - [ ] Docs [Hamza]: Update `docs/reference/database_schema.md` with the new phase/state constraints and legacy automation_level note.
+  - [ ] Tests (Behave) [Hamza]: Add migration scenarios asserting phase/state constraints accept Action + Apply terminal values and reject legacy `applied` phase.
+  - [ ] Tests (Robot) [Hamza]: Add Robot migration smoke test that inserts a plan row with `phase=action` and `processing_state=queued`.
+  - [ ] Tests (ASV) [Hamza]: Add `benchmarks/plan_phase_migration_bench.py` for migration runtime baseline.
+  - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Hamza]: `git add .`
+  - [ ] Git [Hamza]: `git commit -m "feat(db): rebaseline plan phase/state enums for Action and Apply terminal states"`
+  - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-db-plan-phase-rebaseline` to `master` with description "Rebaseline plan phase/state constraints for Action phase and Apply terminal outcomes, with migration + tests.".
+  - [ ] Git [Hamza]: `git checkout master`
+  - [ ] Git [Hamza]: `git branch -d feature/m1-db-plan-phase-rebaseline`
+  - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: A5.delta | Branch: feature/m1-plan-repo | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(repo): add lifecycle plan repository"**
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git pull origin master`
+  - [ ] Git [Luis]: `git checkout -b feature/m1-plan-repo`
+  - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Luis]: Implement `LifecyclePlanRepository` backed by `LifecyclePlanModel` (create/get/update/delete) with ordered child persistence for project links, arguments, and invariants.
+  - [ ] Code [Luis]: Persist Action phase + Apply terminal states (`applied`, `constrained`, `errored`, `cancelled`) in phase/state filters and serialization.
+  - [ ] Code [Luis]: Add list filters for phase, processing_state, action_name, project_name, and namespace (match CLI flags); ensure deterministic ordering.
+  - [ ] Code [Luis]: Raise explicit errors for duplicate plan_id, missing plan, and invalid phase/state updates.
+  - [ ] Docs [Luis]: Document plan repository contract + filters in `docs/reference/repositories.md`.
+  - [ ] Tests (Behave) [Luis]: Add scenarios for create/get/list/update, filter behavior, and child row ordering.
+  - [ ] Tests (Robot) [Luis]: Add Robot smoke test for repository CRUD via service layer.
+  - [ ] Tests (ASV) [Luis]: Add `benchmarks/plan_repository_bench.py` for list/query performance.
+  - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Luis]: `git add .`
+  - [ ] Git [Luis]: `git commit -m "feat(repo): add lifecycle plan repository"`
+  - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-plan-repo` to `master` with description "Add lifecycle plan repository with filters and ordered child persistence.".
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git branch -d feature/m1-plan-repo`
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: A5.epsilon | Branch: feature/m1-uow-lifecycle | Planned: Day 7 | Expected: Day 9) - Commit message: "feat(uow): wire lifecycle repositories"**
-    - [ ] Git [Luis]: `git checkout master`
-    - [ ] Git [Luis]: `git pull origin master`
-    - [ ] Git [Luis]: `git checkout -b feature/m1-uow-lifecycle`
-    - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-    - [ ] Code [Luis]: Update `UnitOfWork` to expose `actions` + `lifecycle_plans` repositories and remove legacy plan repository accessors.
-    - [ ] Code [Luis]: Update `UnitOfWorkContext` to include new repos and remove legacy plan/change repositories from default access.
-    - [ ] Docs [Luis]: Update `docs/reference/repositories.md` with UoW lifecycle usage patterns.
-    - [ ] Tests (Behave) [Luis]: Add scenarios verifying UoW exposes action + lifecycle plan repositories.
-    - [ ] Tests (Robot) [Luis]: Add Robot smoke test that creates an action + plan via UoW.
-    - [ ] Tests (ASV) [Luis]: Add `benchmarks/uow_lifecycle_bench.py` for UoW overhead baseline.
-    - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
-    - [ ] Git [Luis]: `git add .`
-    - [ ] Git [Luis]: `git commit -m "feat(uow): wire lifecycle repositories"`
-    - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-uow-lifecycle` to `master` with description "Wire lifecycle repositories into UnitOfWork and remove legacy plan repo access.".
-    - [ ] Git [Luis]: `git checkout master`
-    - [ ] Git [Luis]: `git branch -d feature/m1-uow-lifecycle`
-    - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: A5.epsilon | Branch: feature/m1-uow-lifecycle | Planned: Day 9 | Expected: Day 11) - Commit message: "feat(uow): wire lifecycle repositories"**
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git pull origin master`
+  - [ ] Git [Luis]: `git checkout -b feature/m1-uow-lifecycle`
+  - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Luis]: Update `UnitOfWork` to expose `actions` + `lifecycle_plans` repositories and remove legacy plan repository accessors.
+  - [ ] Code [Luis]: Update `UnitOfWorkContext` to include new repos and remove legacy plan/change repositories from default access.
+  - [ ] Docs [Luis]: Update `docs/reference/repositories.md` with UoW lifecycle usage patterns.
+  - [ ] Tests (Behave) [Luis]: Add scenarios verifying UoW exposes action + lifecycle plan repositories.
+  - [ ] Tests (Robot) [Luis]: Add Robot smoke test that creates an action + plan via UoW.
+  - [ ] Tests (ASV) [Luis]: Add `benchmarks/uow_lifecycle_bench.py` for UoW overhead baseline.
+  - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Luis]: `git add .`
+  - [ ] Git [Luis]: `git commit -m "feat(uow): wire lifecycle repositories"`
+  - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-uow-lifecycle` to `master` with description "Wire lifecycle repositories into UnitOfWork and remove legacy plan repo access.".
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git branch -d feature/m1-uow-lifecycle`
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: A5.zeta | Branch: feature/m1-lifecycle-persist | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(service): persist plan lifecycle via repositories"**
-    - [ ] Git [Jeff]: `git checkout master`
-    - [ ] Git [Jeff]: `git pull origin master`
-    - [ ] Git [Jeff]: `git checkout -b feature/m1-lifecycle-persist`
-    - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-    - [ ] Code [Jeff]: Update `PlanLifecycleService` to use ActionRepository + LifecyclePlanRepository (remove in-memory maps).
-    - [ ] Code [Jeff]: Persist plan creation + phase transitions (strategize → execute → apply → applied) with timestamps and processing_state updates.
-    - [ ] Code [Jeff]: Persist rendered description/definition_of_done and ordered arguments/invariants at plan creation.
-    - [ ] Docs [Jeff]: Update `docs/reference/plan_lifecycle_service.md` with persistence-only flow and error mapping.
-    - [ ] Tests (Behave) [Jeff]: Add scenarios for persisted transitions, duplicate action name rejection, and missing action errors.
-    - [ ] Tests (Robot) [Jeff]: Add end-to-end test that restarts the app and reloads plan state from DB.
-    - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_lifecycle_persistence_bench.py` for lifecycle persistence overhead.
-    - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
-    - [ ] Git [Jeff]: `git add .`
-    - [ ] Git [Jeff]: `git commit -m "feat(service): persist plan lifecycle via repositories"`
-    - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-lifecycle-persist` to `master` with description "Persist plan lifecycle via repositories and remove in-memory storage.".
-    - [ ] Git [Jeff]: `git checkout master`
-    - [ ] Git [Jeff]: `git branch -d feature/m1-lifecycle-persist`
-    - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: A5.zeta | Branch: feature/m1-lifecycle-persist | Planned: Day 10 | Expected: Day 12) - Commit message: "feat(service): persist plan lifecycle via repositories"**
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git pull origin master`
+  - [ ] Git [Jeff]: `git checkout -b feature/m1-lifecycle-persist`
+  - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Jeff]: Update `PlanLifecycleService` to use ActionRepository + LifecyclePlanRepository (remove in-memory maps).
+  - [ ] Code [Jeff]: Persist plan creation + phase transitions (Action → Strategize → Execute → Apply) with timestamps and apply terminal state updates.
+  - [ ] Code [Jeff]: Persist rendered description/definition_of_done and ordered arguments/invariants at plan creation.
+  - [ ] Docs [Jeff]: Update `docs/reference/plan_lifecycle_service.md` with persistence-only flow and error mapping.
+  - [ ] Tests (Behave) [Jeff]: Add scenarios for persisted transitions, duplicate action name rejection, and missing action errors.
+  - [ ] Tests (Robot) [Jeff]: Add end-to-end test that restarts the app and reloads plan state from DB.
+  - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_lifecycle_persistence_bench.py` for lifecycle persistence overhead.
+  - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Jeff]: `git add .`
+  - [ ] Git [Jeff]: `git commit -m "feat(service): persist plan lifecycle via repositories"`
+  - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-lifecycle-persist` to `master` with description "Persist plan lifecycle via repositories and remove in-memory storage.".
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git branch -d feature/m1-lifecycle-persist`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: A5.eta | Branch: feature/m1-remove-legacy-planstore | Planned: Day 9 | Expected: Day 12) - Commit message: "refactor(plan): remove legacy plan persistence"**
-    - [ ] Git [Jeff]: `git checkout master`
-    - [ ] Git [Jeff]: `git pull origin master`
-    - [ ] Git [Jeff]: `git checkout -b feature/m1-remove-legacy-planstore`
-    - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-    - [ ] Code [Jeff]: Remove legacy `PlanService`, `PlanRepository`, and `plan_legacy.py` usage from services/CLI.
-    - [ ] Code [Jeff]: Remove legacy change persistence paths (`ChangeRepository`, old `Change` model) from plan CLI flows.
-    - [ ] Docs [Jeff]: Update `docs/reference/plan_cli.md` and `docs/reference/plan_lifecycle_service.md` to remove legacy mentions.
-    - [ ] Tests (Behave) [Jeff]: Add scenarios that ensure legacy CLI paths are rejected with explicit errors.
-    - [ ] Tests (Robot) [Jeff]: Add Robot smoke test ensuring legacy plan commands are not reachable.
-    - [ ] Tests (ASV) [Jeff]: Add `benchmarks/legacy_removal_bench.py` for minimal overhead regression guard.
-    - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
-    - [ ] Git [Jeff]: `git add .`
-    - [ ] Git [Jeff]: `git commit -m "refactor(plan): remove legacy plan persistence"`
-    - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-remove-legacy-planstore` to `master` with description "Remove legacy plan persistence paths and enforce lifecycle-only workflows.".
-    - [ ] Git [Jeff]: `git checkout master`
-    - [ ] Git [Jeff]: `git branch -d feature/m1-remove-legacy-planstore`
-    - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: A5.eta | Branch: feature/m1-remove-legacy-planstore | Planned: Day 11 | Expected: Day 13) - Commit message: "refactor(plan): remove legacy plan persistence"**
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git pull origin master`
+  - [ ] Git [Jeff]: `git checkout -b feature/m1-remove-legacy-planstore`
+  - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Jeff]: Remove legacy `PlanService`, `PlanRepository`, and `plan_legacy.py` usage from services/CLI.
+  - [ ] Code [Jeff]: Remove legacy change persistence paths (`ChangeRepository`, old `Change` model) from plan CLI flows.
+  - [ ] Docs [Jeff]: Update `docs/reference/plan_cli.md` and `docs/reference/plan_lifecycle_service.md` to remove legacy mentions.
+  - [ ] Tests (Behave) [Jeff]: Add scenarios that ensure legacy CLI paths are rejected with explicit errors.
+  - [ ] Tests (Robot) [Jeff]: Add Robot smoke test ensuring legacy plan commands are not reachable.
+  - [ ] Tests (ASV) [Jeff]: Add `benchmarks/legacy_removal_bench.py` for minimal overhead regression guard.
+  - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
+  - [ ] Git [Jeff]: `git add .`
+  - [ ] Git [Jeff]: `git commit -m "refactor(plan): remove legacy plan persistence"`
+  - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-remove-legacy-planstore` to `master` with description "Remove legacy plan persistence paths and enforce lifecycle-only workflows.".
+  - [ ] Git [Jeff]: `git checkout master`
+  - [ ] Git [Jeff]: `git branch -d feature/m1-remove-legacy-planstore`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Brent | Group: A5.tests | Branch: feature/m1-persistence-tests | Planned: Day 8 | Expected: Day 10) - Commit message: "test(persistence): add plan/action persistence suites"**
+- [ ] **COMMIT (Owner: Brent | Group: A5.tests | Branch: feature/m1-persistence-tests | Planned: Day 11 | Expected: Day 13) - Commit message: "test(persistence): add plan/action persistence suites"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m1-persistence-tests`
   - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
   - [ ] Tests (Behave) [Brent]: Add plan persistence scenarios (create, phase/state transitions, list filters, plan tree links).
+  - [ ] Tests (Behave) [Brent]: Add scenarios for Action phase persistence and Apply terminal state storage (`applied`, `constrained`, `errored`, `cancelled`).
   - [ ] Tests (Behave) [Brent]: Add action persistence scenarios (create/list/archive, arguments/invariants ordering).
   - [ ] Tests (Behave) [Brent]: Add cross-restart scenarios verifying plan status persists across process restarts.
   - [ ] Tests (Robot) [Brent]: Add plan persistence E2E (full lifecycle, restart persistence, concurrent CLI access).
@@ -1754,36 +1806,31 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK A6.service [Luis]**: Profile resolution + precedence
   **PARALLEL SUBTRACK A6.cli [Jeff]**: CLI commands for profiles
   **SEQUENTIAL MERGE NOTE**: A6.core must land before A6.service/cli; A6.service must land before gating integration in Section 6.
-- [ ] **COMMIT (Owner: Jeff | Group: A6.core | Branch: feature/m4-automation-profiles-core) - Commit message: "feat(domain): add automation profile model and built-ins"**
+- [ ] **COMMIT (Owner: Jeff | Group: A6.core | Branch: feature/m4-automation-profiles-core | Planned: Day 22 | Expected: Day 24) - Commit message: "feat(domain): add automation profile model and built-ins"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-automation-profiles-core`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [X] Code [Luis]: Add `AutomationLevel` enum (manual/review/full) in plan domain model. (completed by Luis as foundation)
-  - [X] Code [Luis]: Add config setting + env var (`CLEVERAGENTS_AUTOMATION_LEVEL`) with precedence plan > session > global. (completed by Luis)
   - [ ] Code [Jeff]: Add `AutomationProfile` model with threshold fields per spec (phase transitions, decision autonomy, self-repair, child plan spawning, safety requirements) and validate 0.0-1.0 ranges.
   - [ ] Code [Jeff]: Add built-in profiles (`manual`, `review`, `supervised`, `cautious`, `trusted`, `auto`, `ci`, `full-auto`) with exact threshold values per spec and stable names.
   - [ ] Code [Jeff]: Add YAML schema for automation profiles under `docs/schema/automation_profile.schema.yaml` and loader helper with env interpolation.
   - [ ] Code [Jeff]: Add `examples/profiles/` built-in profile YAMLs (one per profile) with schema version guard.
   - [ ] Docs [Jeff]: Add `docs/reference/automation_profiles.md` describing built-ins, threshold semantics, and resolution precedence.
-  - [X] Tests (Behave) [Luis]: Add scenarios for default and override precedence (24 scenarios in `features/automation_levels.feature`).
   - [ ] Tests (Behave) [Jeff]: Add scenarios for profile validation, built-in defaults, and invalid threshold ranges.
   - [ ] Tests (Robot) [Jeff]: Add Robot test that loads each built-in profile and prints summary.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/automation_profile_bench.py` for profile validation.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .`
   - [ ] Git [Jeff]: `git commit -m "feat(domain): add automation profile model and built-ins"`
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-profiles-core` to `master` with description "Add automation profile domain model, built-ins, schema, and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-automation-profiles-core`
-- [ ] **COMMIT (Owner: Luis | Group: A6.service | Branch: feature/m4-automation-profiles-service) - Commit message: "feat(service): resolve automation profiles with precedence"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: A6.service | Branch: feature/m4-automation-profiles-service | Planned: Day 23 | Expected: Day 25) - Commit message: "feat(service): resolve automation profiles with precedence"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-automation-profiles-service`
   - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [X] Code [Luis]: Add `automation_level` handling to `use_action()` and auto transition logic for execute/apply. (completed by Luis)
-  - [X] Code [Luis]: Add pause/resume behavior for review-before-apply mode. (completed by Luis)
   - [ ] Code [Luis]: Add `AutomationProfileService` to resolve profiles with precedence (plan > action > project > global) and emit explicit errors for missing profiles.
   - [ ] Code [Luis]: Add persistence table `automation_profiles` (namespaced name PK) and repository with list/show/update and schema_version guard.
   - [ ] Code [Luis]: Add config key `core.automation_profile` and env var override for global default; keep `automation_level` as legacy mapping until removal.
@@ -1793,18 +1840,17 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add Robot config smoke test for global profile override.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/automation_profile_resolution_bench.py` for resolution latency.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .`
   - [ ] Git [Luis]: `git commit -m "feat(service): resolve automation profiles with precedence"`
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-automation-profiles-service` to `master` with description "Add automation profile resolution service, persistence, and config precedence with tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m4-automation-profiles-service`
-- [ ] **COMMIT (Owner: Jeff | Group: A6.cli | Branch: feature/m4-automation-profiles-cli) - Commit message: "feat(cli): add automation-profile commands"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: A6.cli | Branch: feature/m4-automation-profiles-cli | Planned: Day 24 | Expected: Day 26) - Commit message: "feat(cli): add automation-profile commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-automation-profiles-cli`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [X] Code [Luis]: Add `--automation-level` to `plan use` and add `plan set-automation-level` command. (completed by Luis)
   - [ ] Code [Jeff]: Implement `agents automation-profile add/remove/list/show` commands with YAML config input and schema version guard.
   - [ ] Code [Jeff]: Add `--update` behavior with clear conflict errors; preserve original created_at on update.
   - [ ] Code [Jeff]: Ensure `automation-profile list` supports `--namespace` and regex filters with deterministic ordering.
@@ -1817,16 +1863,35 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add Robot CLI tests for automation-profile commands (add/show/remove + format outputs).
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/automation_profile_cli_bench.py` for CLI parsing.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .`
   - [ ] Git [Jeff]: `git commit -m "feat(cli): add automation-profile commands"`
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-profiles-cli` to `master` with description "Add automation-profile CLI commands, output formats, and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-automation-profiles-cli`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: A6.legacy | Branch: feature/m4-automation-legacy-cleanup | Planned: Day 25 | Expected: Day 27) - Commit message: "refactor(automation): remove automation_level legacy fields"**
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git pull origin master`
+  - [ ] Git [Luis]: `git checkout -b feature/m4-automation-legacy-cleanup`
+  - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Luis]: Remove `automation_level` from Plan domain model, settings, and CLI flags; keep `automation_profile` as the only automation control.
+  - [ ] Code [Luis]: Add migration to drop `automation_level` column + CHECK constraint from `v3_plans` (SQLite rebuild), with downgrade restoring legacy column.
+  - [ ] Code [Luis]: Remove legacy mapping logic in `PlanLifecycleService` (no `automation_level` fallback).
+  - [ ] Docs [Luis]: Update config + CLI references to remove automation_level mentions and document profile-only flow.
+  - [ ] Tests (Behave) [Luis]: Add scenarios ensuring legacy automation_level inputs are rejected with explicit errors.
+  - [ ] Tests (Robot) [Luis]: Add Robot CLI test verifying `plan use --automation-level` is rejected post-removal.
+  - [ ] Tests (ASV) [Luis]: Add `benchmarks/automation_legacy_cleanup_bench.py` for migration runtime baseline.
+  - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
+  - [ ] Git [Luis]: `git add .`
+  - [ ] Git [Luis]: `git commit -m "refactor(automation): remove automation_level legacy fields"`
+  - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-automation-legacy-cleanup` to `master` with description "Remove automation_level legacy fields in favor of automation profiles with migrations + tests.".
+  - [ ] Git [Luis]: `git checkout master`
+  - [ ] Git [Luis]: `git branch -d feature/m4-automation-legacy-cleanup`
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group A4c: Plan Diagnostics & Artifacts [Jeff]** (post-M1; depends on C5.diff + C9.execute)
   **SEQUENTIAL NOTE**: A4c should not start until ChangeSet diff artifacts are stable (C5.diff) and plan execution writes plan metadata (C9.execute/C9.apply).
-- [ ] **COMMIT (Owner: Jeff | Group: A4c.plan-diff | Branch: feature/m4-plan-diagnostics) - Commit message: "feat(cli): add plan diff command"**
+- [ ] **COMMIT (Owner: Jeff | Group: A4c.plan-diff | Branch: feature/m4-plan-diagnostics | Planned: Day 21 | Expected: Day 25) - Commit message: "feat(cli): add plan diff command"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-plan-diagnostics`
@@ -1839,13 +1904,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add Robot CLI test running `plan diff` after an execute/apply dry run.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_diff_cli_bench.py` for diff rendering overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .`
   - [ ] Git [Jeff]: `git commit -m "feat(cli): add plan diff command"`
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-plan-diagnostics` to `master` with description "Add plan diff CLI command with ChangeSet rendering and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-plan-diagnostics`
-- [ ] **COMMIT (Owner: Jeff | Group: A4c.artifacts | Branch: feature/m4-plan-diagnostics) - Commit message: "feat(cli): add plan artifacts and prompt commands"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: A4c.artifacts | Branch: feature/m4-plan-diagnostics | Planned: Day 22 | Expected: Day 26) - Commit message: "feat(cli): add plan artifacts and prompt commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-plan-diagnostics`
@@ -1858,12 +1923,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add Robot CLI tests covering artifacts and prompt commands.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_artifacts_cli_bench.py` for listing overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .`
   - [ ] Git [Jeff]: `git commit -m "feat(cli): add plan artifacts and prompt commands"`
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-plan-diagnostics` to `master` with description "Add plan artifacts + prompt CLI commands with persistence and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-plan-diagnostics`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group A7: Session Management [Jeff + Luis + Brent]** (M3; post-M1; depends on actor registry + plan lifecycle)
   **PARALLEL SUBTRACK A7.domain [Jeff]**: Session domain models + service contracts
@@ -1884,13 +1949,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/session_model_bench.py` for validation throughput.
   - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, 39 new scenarios pass.
   - [X] Git [Jeff]: `git add .`
-  - [X] Commit [Jeff]: `git commit -m "feat(session): add session domain models and contracts"`
+  - [X] Git [Jeff]: `git commit -m "feat(session): add session domain models and contracts"`
   - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-session-domain` to `master` with description "Add session domain models + service contracts with docs and tests."
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git branch -d feature/m3-session-domain`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (session.py 98%).
 
-- [ ] **COMMIT (Owner: Brent | Group: A7.domain.tests | Branch: feature/m3-session-domain-robot | Planned: Day 9 | Expected: Day 10) - Commit message: "test(session): add robot session model smoke tests"**
+- [ ] **COMMIT (Owner: Brent | Group: A7.domain.tests | Branch: feature/m3-session-domain-robot | Planned: Day 13 | Expected: Day 16) - Commit message: "test(session): add robot session model smoke tests"**
   - [ ] Meta [Brent]: Only mark this commit complete after every subtask is done and `git commit -m "test(session): add robot session model smoke tests"` has executed.
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
@@ -1908,7 +1973,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git branch -d feature/m3-session-domain-robot`
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-- [ ] **COMMIT (Owner: Luis | Group: A7.persistence | Branch: feature/m3-session-persistence) - Commit message: "feat(session): add session persistence and repositories"**
+- [ ] **COMMIT (Owner: Luis | Group: A7.persistence | Branch: feature/m3-session-persistence | Planned: Day 14 | Expected: Day 18) - Commit message: "feat(session): add session persistence and repositories"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-session-persistence`
@@ -1922,13 +1987,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add `robot/session_persistence.robot` integration smoke tests.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/session_persistence_bench.py` for write/read throughput.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .`
   - [ ] Git [Luis]: `git commit -m "feat(session): add session persistence and repositories"`
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-session-persistence` to `master` with description "Add session persistence tables + repositories + service wiring with tests."
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m3-session-persistence`
-- [ ] **COMMIT (Owner: Brent | Group: A7.cli | Branch: feature/m3-session-cli) - Commit message: "feat(cli): add session commands"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Brent | Group: A7.cli | Branch: feature/m3-session-cli | Planned: Day 15 | Expected: Day 19) - Commit message: "feat(cli): add session commands"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m3-session-cli`
@@ -1942,15 +2007,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Brent]: Add `robot/session_cli.robot` end-to-end session flows with export/import round-trip.
   - [ ] Tests (ASV) [Brent]: Add `benchmarks/session_cli_bench.py` for command parsing overhead.
   - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Brent]: `git add .`
   - [ ] Git [Brent]: `git commit -m "feat(cli): add session commands"`
   - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-session-cli` to `master` with description "Add session CLI commands with Behave/Robot coverage and docs updates."
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git branch -d feature/m3-session-cli`
+  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group A8: Config CLI [Brent]** (M3; post-M1; depends on Settings)
-- [ ] **COMMIT (Owner: Brent | Group: A8.cli | Branch: feature/m3-config-cli) - Commit message: "feat(cli): add config get/set/list commands"**
+- [ ] **COMMIT (Owner: Brent | Group: A8.cli | Branch: feature/m3-config-cli | Planned: Day 16 | Expected: Day 20) - Commit message: "feat(cli): add config get/set/list commands"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m3-config-cli`
@@ -1964,17 +2029,17 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Brent]: Add `robot/config_cli.robot` smoke tests for config list output.
   - [ ] Tests (ASV) [Brent]: Add `benchmarks/config_cli_bench.py` for CLI parsing.
   - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Brent]: `git add .`
   - [ ] Git [Brent]: `git commit -m "feat(cli): add config get/set/list commands"`
   - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-config-cli` to `master` with description "Add config get/set/list CLI commands with tests and docs updates."
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git branch -d feature/m3-config-cli`
+  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **M1 SUCCESS CRITERIA (Day 7 MVP - source code only)**:
 - Action created from YAML config and persisted (namespaced name, description, arguments, strategy/execution actors).
 - Project created and linked to a local `git-checkout` resource (worktree sandbox enabled).
-- Plan use → strategize → execute → apply completes end-to-end on a local git repo with sandbox isolation.
+- Plan use creates Action phase then Strategize/Execute/Apply completes end-to-end on a local git repo with sandbox isolation; Apply ends in `applied`.
 - Tool-based change tracking produces a ChangeSet and apply merges to the original working tree only after validations pass.
 - `nox` passes with coverage >=97% on the MVP end-to-end path.
 
@@ -2004,7 +2069,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK B0.sandbox [Hamza]**: git_worktree + copy_on_write sandbox strategies (completed)
   **SEQUENTIAL MERGE NOTE**: B0.type-model → B0.builtins → B0.repo.* → B0.services → B0.cli.*. B0.db.resources is done; B0.db.projects must land before B0.repo.projects.
 
-- [ ] **COMMIT (Owner: Hamza | Group: B0.type-model | Branch: feature/m1-resource-type-schema | Planned: Day 6 | Expected: Day 8) - Commit message: "feat(resource): add resource type model + schema loader"**
+- [ ] **COMMIT (Owner: Hamza | Group: B0.type-model | Branch: feature/m1-resource-type-schema | Planned: Day 7 | Expected: Day 10) - Commit message: "feat(resource): add resource type model + schema loader"**
   - [ ] Meta [Hamza]: Only mark this commit complete after every subtask is done and `git commit -m "feat(resource): add resource type model + schema loader"` has executed.
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
@@ -2012,7 +2077,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
   - [ ] Code [Hamza]: Create `src/cleveragents/domain/models/core/resource_type.py` with `ResourceTypeName`, `ResourceTypeArgument`, `ResourceTypeSpec`, `ResourceKind` enum (physical/virtual), and `SandboxStrategy` enum (git_worktree/copy_on_write/transaction_rollback/snapshot/none).
   - [ ] Code [Hamza]: Define `ResourceTypeArgument` fields per spec (`name`, `type`, `required`, `description`, `default`, `validation_pattern`) and validate `name` to map to CLI `--<name>`.
-  - [ ] Code [Hamza]: Add `ResourceTypeSpec` fields per spec: `user_addable`, `cli_args`, `child_types`, `parent_types`, `auto_discovery`, `equivalence` (virtual only), `handler`, and `sandbox_strategy`.
+  - [ ] Code [Hamza]: Add `ResourceTypeSpec` fields per spec: `user_addable`, `cli_args`, `child_types`, `parent_types`, `auto_discovery`, `equivalence` (virtual only), `handler`, `sandbox_strategy`, and `capabilities` (read/write/sandbox/checkpoint).
   - [ ] Code [Hamza]: Enforce namespaced name rules for custom types; allow unnamespaced built-ins (e.g., `git-checkout`, `fs-directory`) via a dedicated `built_in` flag.
   - [ ] Code [Hamza]: Add `docs/schema/resource_type.schema.yaml` mirroring the spec JSON schema (fields, enums, required list, `cliArg`/`childType` defs, and conditional `equivalence` requirement for virtual types).
   - [ ] Code [Hamza]: Add resource type YAML loader in `src/cleveragents/resource/schema.py` with `${ENV_VAR}` interpolation, schema version guardrails, and explicit error messages for invalid names, constraints, and `cli_args` definitions.
@@ -2031,12 +2096,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 
-- [ ] **COMMIT (Owner: Hamza | Group: B0.builtins | Branch: feature/m1-resource-builtins | Planned: Day 6 | Expected: Day 7) - Commit message: "feat(resource): add git-checkout resource type"**
+- [ ] **COMMIT (Owner: Hamza | Group: B0.builtins | Branch: feature/m1-resource-builtins | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(resource): add git-checkout and fs-directory resource types"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m1-resource-builtins`
   - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Hamza]: Add built-in resource type configs for `git-checkout` and `fs-directory` (schema_version, args, sandbox_strategy).
+  - [ ] Code [Hamza]: Add built-in resource type YAMLs under `examples/resource-types/` for `git-checkout` and `fs-directory` (schema_version, args, sandbox_strategy).
   - [ ] Code [Hamza]: Mark both as unnamespaced built-ins; `git-checkout` uses `git_worktree` and `--path/--branch`, `fs-directory` uses `copy_on_write` and `--path`.
   - [ ] Docs [Hamza]: Add `docs/reference/resource_types_builtin.md` with git-checkout + fs-directory flags and examples.
   - [ ] Tests (Behave) [Hamza]: Add scenarios asserting built-in YAMLs validate against the schema.
@@ -2044,13 +2109,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_builtin_bench.py` for built-in YAML load cost.
   - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
   - [ ] Git [Hamza]: `git add .`
-  - [ ] Git [Hamza]: `git commit -m "feat(resource): add git-checkout resource type"`
-  - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-resource-builtins` to `master` with description "Add built-in git-checkout resource type config + docs/tests.".
+  - [ ] Git [Hamza]: `git commit -m "feat(resource): add git-checkout and fs-directory resource types"`
+  - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-resource-builtins` to `master` with description "Add built-in git-checkout and fs-directory resource type configs with docs/tests.".
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git branch -d feature/m1-resource-builtins`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: B0.db.projects | Branch: feature/m1-project-db | Planned: Day 7 | Expected: Day 9) - Commit message: "feat(db): add projects and project links tables"**
+- [ ] **COMMIT (Owner: Hamza | Group: B0.db.projects | Branch: feature/m1-project-db | Planned: Day 8 | Expected: Day 11) - Commit message: "feat(db): add projects and project links tables"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m1-project-db`
@@ -2095,7 +2160,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-resource-core-db` to `master` with description "Add resource registry tables, indexes, and migration tests.".
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. (models.py 94% with combined tests, overall suite maintains 97%)
 
-- [ ] **COMMIT (Owner: Brent | Group: B0.db.resources.tests | Branch: feature/m1-resource-db-robot-tests | Planned: Day 10 | Expected: Day 12) - Commit message: "test(db): add resource registry robot smoke test"**
+- [ ] **COMMIT (Owner: Brent | Group: B0.db.resources.tests | Branch: feature/m1-resource-db-robot-tests | Planned: Day 11 | Expected: Day 13) - Commit message: "test(db): add resource registry robot smoke test"**
   - [ ] Meta [Brent]: Only mark this commit complete after every subtask is done and `git commit -m "test(db): add resource registry robot smoke test"` has executed.
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
@@ -2114,7 +2179,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Brent]: `git branch -d feature/m1-resource-db-robot-tests`
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: B0.repo.resources | Branch: feature/m1-resource-repos | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(repo): add resource repositories"**
+- [ ] **COMMIT (Owner: Luis | Group: B0.repo.resources | Branch: feature/m1-resource-repos | Planned: Day 9 | Expected: Day 12) - Commit message: "feat(repo): add resource repositories"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m1-resource-repos`
@@ -2134,7 +2199,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m1-resource-repos`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: B0.repo.projects | Branch: feature/m1-project-repos | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(repo): add project repositories"**
+- [ ] **COMMIT (Owner: Luis | Group: B0.repo.projects | Branch: feature/m1-project-repos | Planned: Day 9 | Expected: Day 12) - Commit message: "feat(repo): add project repositories"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m1-project-repos`
@@ -2153,14 +2218,14 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m1-project-repos`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: B0.services | Branch: feature/m1-resource-project-services | Planned: Day 9 | Expected: Day 11) - Commit message: "feat(service): wire resource registry and project services"**
+- [ ] **COMMIT (Owner: Luis | Group: B0.services | Branch: feature/m1-resource-project-services | Planned: Day 10 | Expected: Day 13) - Commit message: "feat(service): wire resource registry and project services"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m1-resource-project-services`
   - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
   - [ ] Code [Luis]: Add `ResourceRegistryService` with register/list/show for built-in and custom resource types.
   - [ ] Code [Luis]: Add startup bootstrap that registers built-in resource type YAMLs if missing (idempotent).
-  - [ ] Code [Luis]: Rework `ProjectService` to use namespaced names and link/unlink resources via repositories (no path-based model).
+  - [ ] Code [Luis]: Rework `ProjectService` to use namespaced names, store project invariants + invariant_actor, and link/unlink resources via repositories (no path-based model).
   - [ ] Code [Luis]: Update DI container wiring for resource/project services and repositories.
   - [ ] Docs [Luis]: Update `docs/reference/project_model.md` with linking rules and name resolution.
   - [ ] Tests (Behave) [Luis]: Add scenarios for resource bootstrap registration and project link/unlink flows.
@@ -2174,17 +2239,18 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m1-resource-project-services`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: B0.cli.resources | Branch: feature/m1-resource-cli | Planned: Day 9 | Expected: Day 11) - Commit message: "feat(cli): add resource commands (core)"**
+- [ ] **COMMIT (Owner: Jeff | Group: B0.cli.resources | Branch: feature/m1-resource-cli | Planned: Day 10 | Expected: Day 13) - Commit message: "feat(cli): add resource commands (core)"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m1-resource-cli`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Jeff]: Implement `agents resource type list/show` for built-in types with `--format json/yaml` output.
+  - [ ] Code [Jeff]: Implement `agents resource type add --config <file> [--update]` and `agents resource type remove [--yes] <name>` for custom types (built-ins remain read-only).
+  - [ ] Code [Jeff]: Implement `agents resource type list/show` for built-in + custom types with `--format json/yaml` output.
   - [ ] Code [Jeff]: Implement `agents resource add git-checkout <name> --path <path> [--branch <branch>] [--update]` with type validation.
   - [ ] Code [Jeff]: Implement `agents resource list` and `agents resource show` with namespaced name/ULID resolution.
   - [ ] Code [Jeff]: Implement `agents resource remove [--yes] <resource>` with FK guardrails.
-  - [ ] Docs [Jeff]: Update CLI reference with resource type and resource add/list/show examples.
-  - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for resource add/list/show/remove and invalid type errors.
+  - [ ] Docs [Jeff]: Update CLI reference with resource type add/remove/list/show and resource add/list/show examples.
+  - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for resource type add/remove/list/show, resource add/list/show/remove, and invalid type errors.
   - [ ] Tests (Robot) [Jeff]: Add Robot CLI test that adds a git-checkout resource and shows it.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/resource_cli_bench.py` for CLI parsing overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes.
@@ -2195,12 +2261,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m1-resource-cli`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: B0.cli.projects | Branch: feature/m1-project-cli | Planned: Day 9 | Expected: Day 11) - Commit message: "feat(cli): add project commands (core)"**
+- [ ] **COMMIT (Owner: Jeff | Group: B0.cli.projects | Branch: feature/m1-project-cli | Planned: Day 10 | Expected: Day 13) - Commit message: "feat(cli): add project commands (core)"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m1-project-cli`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Jeff]: Implement `agents project create <name> [--description <text>] [--resource <resource>]...` with namespaced name validation.
+  - [ ] Code [Jeff]: Implement `agents project create <name> [--description <text>] [--resource <resource>]... [--invariant <text>]... [--invariant-actor <actor>]` with namespaced name validation.
   - [ ] Code [Jeff]: Implement `agents project link-resource [--read-only] <project> <resource>` with alias support.
   - [ ] Code [Jeff]: Implement `agents project unlink-resource [--yes] <project> <resource>` with clear not-found errors.
   - [ ] Code [Jeff]: Implement `agents project list` and `agents project show` with linked resources and basic metadata.
@@ -2235,12 +2301,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK B1.cli [Jeff]**: resource tree/inspect + link-child/unlink-child CLI
   **SEQUENTIAL MERGE NOTE**: B1.types → B1.dag → B1.cli.
 
-- [ ] **COMMIT (Owner: Hamza | Group: B1.types | Branch: feature/m2-resource-types | Planned: Day 11 | Expected: Day 13) - Commit message: "feat(resource): add fs-mount and fs-directory types"**
+- [ ] **COMMIT (Owner: Hamza | Group: B1.types | Branch: feature/m2-resource-types | Planned: Day 11 | Expected: Day 15) - Commit message: "feat(resource): add fs-mount and fs-directory types"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-types`
   - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Hamza]: Add `resources/types/fs-mount.yaml`, `fs-directory.yaml`, and `fs-file.yaml` with parent/child constraints.
+  - [ ] Code [Hamza]: Add `examples/resource-types/fs-mount.yaml`, `fs-directory.yaml`, and `fs-file.yaml` with parent/child constraints.
   - [ ] Code [Hamza]: Add `auto_discover` rules for git-checkout → fs-directory/fs-file and fs-mount → fs-directory/fs-file.
   - [ ] Docs [Hamza]: Update built-in resource type reference with fs-mount and discovery rules.
   - [ ] Tests (Behave) [Hamza]: Add scenarios validating fs-mount/fs-directory YAML against schema.
@@ -2254,7 +2320,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Hamza]: `git branch -d feature/m2-resource-types`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: B1.dag | Branch: feature/m2-resource-dag | Planned: Day 12 | Expected: Day 14) - Commit message: "feat(resource): add DAG linking and discovery"**
+- [ ] **COMMIT (Owner: Luis | Group: B1.dag | Branch: feature/m2-resource-dag | Planned: Day 12 | Expected: Day 16) - Commit message: "feat(resource): add DAG linking and discovery"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m2-resource-dag`
@@ -2273,7 +2339,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m2-resource-dag`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: B1.cli | Branch: feature/m2-resource-cli-extensions | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(cli): add resource tree and inspect commands"**
+- [ ] **COMMIT (Owner: Jeff | Group: B1.cli | Branch: feature/m2-resource-cli-extensions | Planned: Day 13 | Expected: Day 17) - Commit message: "feat(cli): add resource tree and inspect commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m2-resource-cli-extensions`
@@ -2298,7 +2364,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK B2.cli [Jeff]**: `project context` CLI scaffolding
   **SEQUENTIAL MERGE NOTE**: B2.model lands before B2.cli; ACMS execution wiring is in Section 8.
 
-- [ ] **COMMIT (Owner: Luis | Group: B2.model | Branch: feature/m3-project-context-model | Planned: Day 14 | Expected: Day 16) - Commit message: "feat(project): add context policy model"**
+- [ ] **COMMIT (Owner: Luis | Group: B2.model | Branch: feature/m3-project-context-model | Planned: Day 14 | Expected: Day 18) - Commit message: "feat(project): add context policy model"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-project-context-model`
@@ -2317,7 +2383,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m3-project-context-model`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: B2.cli | Branch: feature/m3-project-context-cli | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(cli): add project context commands"**
+- [ ] **COMMIT (Owner: Jeff | Group: B2.cli | Branch: feature/m3-project-context-cli | Planned: Day 15 | Expected: Day 19) - Commit message: "feat(cli): add project context commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-project-context-cli`
@@ -2359,7 +2425,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK C0.files [Jeff]**: Built-in file tools wired to ChangeSet capture
   **SEQUENTIAL MERGE NOTE**: C0.runtime must land before C0.files; both must land before D0 ChangeSet/apply integration is complete.
 
-- [X] **COMMIT (Owner: Jeff | Group: C0.runtime | Branch: feature/m1-tool-runtime-core | Planned: Day 7 | Expected: Day 10) - Commit message: "feat(tool): add tool runtime core"**
+- [X] **COMMIT (Owner: Jeff | Group: C0.runtime | Branch: feature/m1-tool-runtime-core | Done: Day 6, February 14, 2026 06:18:35 +0000) - Commit message: "feat(tool): add tool runtime core"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m1-tool-runtime-core`
@@ -2379,7 +2445,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Git [Jeff]: `git branch -d feature/m1-tool-runtime-core`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [X] **COMMIT (Owner: Jeff | Group: C0.files | Branch: feature/m1-tool-builtins | Done: Day 6, February 14, 2026) - Commit message: "feat(tool): add built-in file tools"**
+- [X] **COMMIT (Owner: Jeff | Group: C0.files | Branch: feature/m1-tool-builtins | Done: Day 6, February 14, 2026 07:25:08 +0000) - Commit message: "feat(tool): add built-in file tools"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m1-tool-builtins`
@@ -2428,11 +2494,11 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_model_bench.py` for schema validation throughput (model + YAML loader). (3 benchmark suites)
   - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, unit_tests 2293 scenarios passed (0 failures), integration_tests 208 passed (0 failures).
   - [X] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [X] Commit [Jeff]: `git commit -m "feat(tool): add tool and validation domain models"`.
+  - [X] Git [Jeff]: `git commit -m "feat(tool): add tool and validation domain models"`.
   - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-domain` to `master` with description "Add tool + validation domain models, schema loaders, and tests.".
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage is 97% overall (tool.py 99% coverage).
 
-- [ ] **COMMIT (Owner: Brent | Group: C1.tool.domain.tests | Branch: feature/m3-tool-domain-robot | Planned: Day 10 | Expected: Day 11) - Commit message: "test(tool): add robot tool model smoke tests"**
+- [ ] **COMMIT (Owner: Brent | Group: C1.tool.domain.tests | Branch: feature/m3-tool-domain-robot | Planned: Day 10 | Expected: Day 14) - Commit message: "test(tool): add robot tool model smoke tests"**
   - [ ] Meta [Brent]: Only mark this commit complete after every subtask is done and `git commit -m "test(tool): add robot tool model smoke tests"` has executed.
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
@@ -2451,7 +2517,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Brent]: `git branch -d feature/m3-tool-domain-robot`
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: C1.tool.registry | Branch: feature/m3-tool-registry | Planned: Day 14 | Expected: Day 17) - Commit message: "feat(tool): add tool registry persistence"**
+- [ ] **COMMIT (Owner: Luis | Group: C1.tool.registry | Branch: feature/m3-tool-registry | Planned: Day 14 | Expected: Day 20) - Commit message: "feat(tool): add tool registry persistence"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-tool-registry`
@@ -2470,7 +2536,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m3-tool-registry`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: C1.tool.binding | Branch: feature/m3-tool-binding | Planned: Day 15 | Expected: Day 18) - Commit message: "feat(tool): add resource binding resolution"**
+- [ ] **COMMIT (Owner: Jeff | Group: C1.tool.binding | Branch: feature/m3-tool-binding | Planned: Day 15 | Expected: Day 21) - Commit message: "feat(tool): add resource binding resolution"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-binding`
@@ -2488,7 +2554,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m3-tool-binding`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: C1.tool.cli | Branch: feature/m3-tool-cli | Planned: Day 16 | Expected: Day 19) - Commit message: "feat(cli): add tool and validation commands"**
+- [ ] **COMMIT (Owner: Jeff | Group: C1.tool.cli | Branch: feature/m3-tool-cli | Planned: Day 16 | Expected: Day 22) - Commit message: "feat(cli): add tool and validation commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-cli`
@@ -2544,13 +2610,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/skill_resolution_bench.py` for resolver performance.
   - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, unit_tests 2335 scenarios passed (0 failures).
   - [X] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [X] Commit [Jeff]: `git commit -m "feat(skill): add skill domain model and resolver"`.
+  - [X] Git [Jeff]: `git commit -m "feat(skill): add skill domain model and resolver"`.
   - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-domain` to `master` with description "Add skill domain model, resolver, and tests.".
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git branch -d feature/m3-skill-domain`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (skill.py 98%).
 
-- [ ] **COMMIT (Owner: Brent | Group: C0.skill.domain.tests | Branch: feature/m3-skill-domain-robot | Planned: Day 10 | Expected: Day 11) - Commit message: "test(skill): add robot skill resolver smoke tests"**
+- [ ] **COMMIT (Owner: Brent | Group: C0.skill.domain.tests | Branch: feature/m3-skill-domain-robot | Planned: Day 10 | Expected: Day 14) - Commit message: "test(skill): add robot skill resolver smoke tests"**
   - [ ] Meta [Brent]: Only mark this commit complete after every subtask is done and `git commit -m "test(skill): add robot skill resolver smoke tests"` has executed.
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
@@ -2647,7 +2713,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Git [Jeff]: `git branch -d feature/m3-actor-compiler`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: C3.registry | Branch: feature/m3-actor-registry | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(actor): align actor registry persistence"**
+- [ ] **COMMIT (Owner: Luis | Group: C3.registry | Branch: feature/m3-actor-registry | Planned: Day 15 | Expected: Day 20) - Commit message: "feat(actor): align actor registry persistence"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-actor-registry`
@@ -2665,7 +2731,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m3-actor-registry`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: C3.cli | Branch: feature/m3-actor-cli | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(cli): align actor commands to YAML"**
+- [ ] **COMMIT (Owner: Jeff | Group: C3.cli | Branch: feature/m3-actor-cli | Planned: Day 16 | Expected: Day 21) - Commit message: "feat(cli): align actor commands to YAML"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-cli`
@@ -2744,7 +2810,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
 
 
 **Parallel Group C5: Tool Lifecycle Runtime [Jeff]** (M2; depends on C0.runtime + C1.tool.domain)
-- [X] **COMMIT (Owner: Jeff | Group: C5.lifecycle | Branch: feature/m2-tool-runtime | Planned: Day 11 | Expected: Day 13) - Commit message: "feat(tool): add tool lifecycle runtime"**
+- [X] **COMMIT (Owner: Jeff | Group: C5.lifecycle | Branch: feature/m2-tool-runtime | Done: Day 6, February 14, 2026 17:09:19 +0000) - Commit message: "feat(tool): add tool lifecycle runtime"**
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git pull origin master`
   - [X] Git [Jeff]: `git checkout -b feature/m2-tool-runtime`
@@ -2762,16 +2828,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [X] Tests (Robot) [Jeff]: Add `robot/tool_lifecycle.robot` runtime smoke tests.
   - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_lifecycle_bench.py` for lifecycle overhead.
   - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [X] Git [Jeff]: `git add .` (only after nox passes)
-  - [X] Commit [Jeff]: `git commit -m "feat(tool): add tool lifecycle runtime"`.
+  - [X] Git [Jeff]: `git commit -m "feat(tool): add tool lifecycle runtime"`.
   - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-tool-runtime` to `master` with description "Add tool lifecycle runtime, context, and tests.".
   - [X] Git [Jeff]: `git checkout master`
   - [X] Git [Jeff]: `git branch -d feature/m2-tool-runtime`
   - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C1: Actor Schema & Examples [Aditya + Jeff]** (start Day 5; C2 depends on this)
-- [ ] **COMMIT (Owner: Aditya | Group: C1.schema | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Expected: Day 14) - Commit message: "feat(actor): add actor yaml schema models"**
+- [ ] **COMMIT (Owner: Aditya | Group: C1.schema | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Expected: Day 17) - Commit message: "feat(actor): add actor yaml schema models"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m3-actor-schema-examples`
@@ -2788,13 +2853,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Aditya]: Add `robot/actor_schema.robot` YAML load smoke test.
   - [ ] Tests (ASV) [Aditya]: Add `benchmarks/actor_schema_bench.py` for YAML validation cost.
   - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Aditya]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Aditya]: `git commit -m "feat(actor): add actor yaml schema models"`.
+  - [ ] Git [Aditya]: `git commit -m "feat(actor): add actor yaml schema models"`.
   - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-actor-schema-examples` to `master` with description "Add actor YAML schema models, validation rules, and tests.".
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git branch -d feature/m3-actor-schema-examples`
-- [ ] **COMMIT (Owner: Aditya | Group: C1.examples | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Expected: Day 15) - Commit message: "docs(actor): add actor yaml examples"**
+  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Aditya | Group: C1.examples | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Expected: Day 18) - Commit message: "docs(actor): add actor yaml examples"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m3-actor-schema-examples`
@@ -2806,17 +2871,17 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Aditya]: Add `robot/actor_examples.robot` to load each example.
   - [ ] Tests (ASV) [Aditya]: Add `benchmarks/actor_examples_load_bench.py` for YAML load throughput.
   - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Aditya]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Aditya]: `git commit -m "docs(actor): add actor yaml examples"`.
+  - [ ] Git [Aditya]: `git commit -m "docs(actor): add actor yaml examples"`.
   - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-actor-schema-examples` to `master` with description "Add actor YAML examples and validation tests.".
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git branch -d feature/m3-actor-schema-examples`
+  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C2: Actor Loading & Compilation [Aditya + Jeff]** (depends on C1)
   **PARALLEL SUBTRACK C2.legacy [Jeff]**: Remove v2 actor config compatibility (after C1.schema)
   **SEQUENTIAL NOTE**: C2.legacy must land before C2.loader/C2.compiler to avoid dual-format support.
-- [ ] **COMMIT (Owner: Aditya | Group: C2.loader | Branch: feature/m3-actor-loader | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(actor): add actor registry and loader"**
+- [ ] **COMMIT (Owner: Aditya | Group: C2.loader | Branch: feature/m3-actor-loader | Planned: Day 13 | Expected: Day 18) - Commit message: "feat(actor): add actor registry and loader"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m3-actor-loader`
@@ -2831,13 +2896,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Aditya]: Add `robot/actor_loading.robot` for loader smoke tests.
   - [ ] Tests (ASV) [Aditya]: Add `benchmarks/actor_loading_bench.py` for registry load performance.
   - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Aditya]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Aditya]: `git commit -m "feat(actor): add actor registry and loader"`.
+  - [ ] Git [Aditya]: `git commit -m "feat(actor): add actor registry and loader"`.
   - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-actor-loader` to `master` with description "Add actor registry/loader, discovery rules, and tests.".
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git branch -d feature/m3-actor-loader`
-- [ ] **COMMIT (Owner: Jeff | Group: C2.compiler | Branch: feature/m3-actor-compiler | Planned: Day 14 | Expected: Day 16) - Commit message: "feat(actor): compile actor configs to LangGraph"**
+  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C2.compiler | Branch: feature/m3-actor-compiler | Planned: Day 14 | Expected: Day 19) - Commit message: "feat(actor): compile actor configs to LangGraph"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-compiler`
@@ -2852,13 +2917,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/actor_compilation.robot` smoke test compiling all examples.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_compilation_bench.py` for compilation speed.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(actor): compile actor configs to LangGraph"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(actor): compile actor configs to LangGraph"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-compiler` to `master` with description "Compile actor configs to LangGraph with tool wiring and diagnostics.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-actor-compiler`
-- [ ] **COMMIT (Owner: Jeff | Group: C2.refs | Branch: feature/m3-actor-refs | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(actor): resolve actor references and subgraphs"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C2.refs | Branch: feature/m3-actor-refs | Planned: Day 15 | Expected: Day 20) - Commit message: "feat(actor): resolve actor references and subgraphs"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-refs`
@@ -2872,14 +2937,14 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/actor_reference_resolution.robot` for subgraph wiring.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_reference_bench.py` for reference resolution performance.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(actor): resolve actor references and subgraphs"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(actor): resolve actor references and subgraphs"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-refs` to `master` with description "Resolve actor references/subgraphs with diagnostics and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-actor-refs`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: C2.legacy | Branch: feature/m3-actor-legacy-cleanup | Planned: Day 16 | Expected: Day 18) - Commit message: "refactor(actor): drop v2 actor config compatibility"**
+- [ ] **COMMIT (Owner: Jeff | Group: C2.legacy | Branch: feature/m3-actor-legacy-cleanup | Planned: Day 16 | Expected: Day 21) - Commit message: "refactor(actor): drop v2 actor config compatibility"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-legacy-cleanup`
@@ -2892,15 +2957,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add Robot tests that attempt to load v2 configs and assert failure.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_schema_reject_bench.py` for validation overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "refactor(actor): drop v2 actor config compatibility"`.
+  - [ ] Git [Jeff]: `git commit -m "refactor(actor): drop v2 actor config compatibility"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-legacy-cleanup` to `master` with description "Drop v2 actor config compatibility and update docs/tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-actor-legacy-cleanup`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C2.context: Actor Context Commands [Jeff]** (depends on C2.loader; post-M2)
-- [ ] **COMMIT (Owner: Jeff | Group: C2.context | Branch: feature/m3-actor-context | Planned: Day 17 | Expected: Day 19) - Commit message: "feat(cli): add actor context commands"**
+- [ ] **COMMIT (Owner: Jeff | Group: C2.context | Branch: feature/m3-actor-context | Planned: Day 17 | Expected: Day 22) - Commit message: "feat(cli): add actor context commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-context`
@@ -2915,15 +2980,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/actor_context_cli.robot` for context command smoke tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_context_cli_bench.py` for command overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(cli): add actor context commands"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(cli): add actor context commands"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-context` to `master` with description "Add actor context CLI commands and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-actor-context`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C3: Skill Protocol & Context [Jeff]** (critical path; depends on C1)
-- [ ] **COMMIT (Owner: Jeff | Group: C3.protocol | Branch: feature/m3-skill-protocol | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(skill): add skill protocol and metadata"**
+- [ ] **COMMIT (Owner: Jeff | Group: C3.protocol | Branch: feature/m3-skill-protocol | Planned: Day 16 | Expected: Day 21) - Commit message: "feat(skill): add skill protocol and metadata"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-protocol`
@@ -2938,13 +3003,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/skill_protocol.robot` smoke tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/skill_protocol_bench.py` for validation throughput.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(skill): add skill protocol and metadata"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(skill): add skill protocol and metadata"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add skill protocol, metadata models, and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-skill-protocol`
-- [ ] **COMMIT (Owner: Jeff | Group: C3.context | Branch: feature/m3-skill-protocol | Planned: Day 17 | Expected: Day 19) - Commit message: "feat(skill): add skill context and registry"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C3.context | Branch: feature/m3-skill-protocol | Planned: Day 17 | Expected: Day 22) - Commit message: "feat(skill): add skill context and registry"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-protocol`
@@ -2959,13 +3024,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/skill_context.robot` for registry smoke tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/skill_context_bench.py` for registry resolution overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(skill): add skill context and registry"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(skill): add skill context and registry"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add skill context, registry, and change tracking hooks.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-skill-protocol`
-- [ ] **COMMIT (Owner: Jeff | Group: C3.inline | Branch: feature/m3-skill-protocol | Planned: Day 17 | Expected: Day 19) - Commit message: "feat(skill): add inline tool executor"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C3.inline | Branch: feature/m3-skill-protocol | Planned: Day 17 | Expected: Day 22) - Commit message: "feat(skill): add inline tool executor"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-protocol`
@@ -2979,15 +3044,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/skill_inline.robot` for inline tool smoke tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/inline_tool_bench.py` for execution overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(skill): add inline tool executor"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(skill): add inline tool executor"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add inline tool executor with safety constraints and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-skill-protocol`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C4: Built-in Skills [Jeff + Luis]** (depends on C3)
-- [ ] **COMMIT (Owner: Jeff | Group: C4.file | Branch: feature/m3-skill-file-search | Planned: Day 18 | Expected: Day 20) - Commit message: "feat(skill): add file operation skills"**
+- [ ] **COMMIT (Owner: Jeff | Group: C4.file | Branch: feature/m3-skill-file-search | Planned: Day 18 | Expected: Day 23) - Commit message: "feat(skill): add file operation skills"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-file-search`
@@ -3005,13 +3070,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/skill_file_ops.robot` for file ops integration.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/file_tool_bench.py` for read/write throughput.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(skill): add file operation skills"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(skill): add file operation skills"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-file-search` to `master` with description "Add file operation skills with sandboxed guards and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-skill-file-search`
-- [ ] **COMMIT (Owner: Jeff | Group: C4.search | Branch: feature/m3-skill-file-search | Planned: Day 18 | Expected: Day 20) - Commit message: "feat(skill): add directory and search skills"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C4.search | Branch: feature/m3-skill-file-search | Planned: Day 18 | Expected: Day 23) - Commit message: "feat(skill): add directory and search skills"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-file-search`
@@ -3028,13 +3093,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/skill_search.robot` for search integration.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/search_tool_bench.py` for search performance.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(skill): add directory and search skills"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(skill): add directory and search skills"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-file-search` to `master` with description "Add directory/search skills with deterministic output and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-skill-file-search`
-- [ ] **COMMIT (Owner: Luis | Group: C4.git | Branch: feature/m3-skill-git | Planned: Day 19 | Expected: Day 21) - Commit message: "feat(skill): add git operation skills"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: C4.git | Branch: feature/m3-skill-git | Planned: Day 19 | Expected: Day 24) - Commit message: "feat(skill): add git operation skills"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-skill-git`
@@ -3051,15 +3116,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add `robot/skill_git.robot` for git tool integration.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/git_tool_bench.py` for diff/log performance.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(skill): add git operation skills"`.
+  - [ ] Git [Luis]: `git commit -m "feat(skill): add git operation skills"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-skill-git` to `master` with description "Add read-only git operation skills with safety guards and tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m3-skill-git`
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C5: Tool Routing & Change Tracking [Luis + Jeff]** (depends on C3/C4)
-- [ ] **COMMIT (Owner: Luis | Group: C5.model | Branch: feature/m3-change-model | Planned: Day 19 | Expected: Day 22) - Commit message: "feat(change): add ChangeSet models and invocation tracker"**
+- [ ] **COMMIT (Owner: Luis | Group: C5.model | Branch: feature/m3-change-model | Planned: Day 19 | Expected: Day 25) - Commit message: "feat(change): add ChangeSet models and invocation tracker"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-change-model`
@@ -3077,13 +3142,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add `robot/change_tracking.robot` for tracker smoke tests.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/change_tracking_bench.py` for invocation tracking overhead.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(change): add ChangeSet models and invocation tracker"`.
+  - [ ] Git [Luis]: `git commit -m "feat(change): add ChangeSet models and invocation tracker"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-change-model` to `master` with description "Add ChangeSet models, invocation tracking, and tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m3-change-model`
-- [ ] **COMMIT (Owner: Jeff | Group: C5.router | Branch: feature/m3-tool-router | Planned: Day 20 | Expected: Day 22) - Commit message: "feat(change): add tool router for providers"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C5.router | Branch: feature/m3-tool-router | Planned: Day 20 | Expected: Day 25) - Commit message: "feat(change): add tool router for providers"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-router`
@@ -3102,13 +3167,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/tool_router.robot` for routing smoke tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/tool_router_bench.py` for routing performance.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(change): add tool router for providers"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(change): add tool router for providers"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-router` to `master` with description "Add tool router for providers with schema mapping and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-tool-router`
-- [ ] **COMMIT (Owner: Luis | Group: C5.diff | Branch: feature/m3-diff-review | Planned: Day 20 | Expected: Day 23) - Commit message: "feat(change): add diff review artifacts"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: C5.diff | Branch: feature/m3-diff-review | Planned: Day 20 | Expected: Day 26) - Commit message: "feat(change): add diff review artifacts"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-diff-review`
@@ -3126,15 +3191,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add `robot/diff_review.robot` for review artifacts.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/diff_review_bench.py` for diff building performance.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(change): add diff review artifacts"`.
+  - [ ] Git [Luis]: `git commit -m "feat(change): add diff review artifacts"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-diff-review` to `master` with description "Add diff review artifacts and CLI-ready serializers with tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m3-diff-review`
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C6: Validation Pipeline [Luis + Jeff]** (depends on C5 and validation attachment config)
-- [ ] **COMMIT (Owner: Luis | Group: C6.pipeline | Branch: feature/m3-validation-pipeline | Planned: Day 21 | Expected: Day 23) - Commit message: "feat(validation): add validation pipeline and results model"**
+- [ ] **COMMIT (Owner: Luis | Group: C6.pipeline | Branch: feature/m3-validation-pipeline | Planned: Day 21 | Expected: Day 26) - Commit message: "feat(validation): add validation pipeline and results model"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-validation-pipeline`
@@ -3155,13 +3220,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add `robot/validation_pipeline.robot` for pipeline smoke tests.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/validation_pipeline_bench.py` for pipeline runtime.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(validation): add validation pipeline and results model"`.
+  - [ ] Git [Luis]: `git commit -m "feat(validation): add validation pipeline and results model"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-validation-pipeline` to `master` with description "Add validation pipeline and results model with ordering/timeout rules and tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m3-validation-pipeline`
-- [ ] **COMMIT (Owner: Jeff | Group: C6.wraps | Branch: feature/m3-validation-wraps | Planned: Day 21 | Expected: Day 24) - Commit message: "feat(validation): support wrapped tools and transforms"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C6.wraps | Branch: feature/m3-validation-wraps | Planned: Day 21 | Expected: Day 27) - Commit message: "feat(validation): support wrapped tools and transforms"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-wraps`
@@ -3180,13 +3245,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/validation_wraps.robot` for wrapped validation end-to-end.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/validation_wraps_bench.py` for transform overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(validation): support wrapped tools and transforms"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(validation): support wrapped tools and transforms"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-validation-wraps` to `master` with description "Support validation wraps/transform execution with safety guards and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-validation-wraps`
-- [ ] **COMMIT (Owner: Jeff | Group: C6.gating | Branch: feature/m3-validation-gating | Planned: Day 22 | Expected: Day 24) - Commit message: "feat(validation): integrate validation with apply gating"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C6.gating | Branch: feature/m3-validation-gating | Planned: Day 22 | Expected: Day 27) - Commit message: "feat(validation): integrate validation with apply gating"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-gating`
@@ -3204,15 +3269,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/validation_gating.robot` for end-to-end gating.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/validation_gating_bench.py` for gating overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(validation): integrate validation with apply gating"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(validation): integrate validation with apply gating"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-validation-gating` to `master` with description "Integrate validation gating into apply workflow with CLI summaries and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-validation-gating`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C7: MCP Adapter [Aditya]** (depends on C0.runtime + C1.tool.registry)
-- [ ] **COMMIT (Owner: Aditya | Group: C7.mcp | Branch: feature/m3-mcp-adapter | Planned: Day 18 | Expected: Day 20) - Commit message: "feat(skill): add MCP adapter for external tools"**
+- [ ] **COMMIT (Owner: Aditya | Group: C7.mcp | Branch: feature/m3-mcp-adapter | Planned: Day 18 | Expected: Day 23) - Commit message: "feat(skill): add MCP adapter for external tools"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m3-mcp-adapter`
@@ -3234,15 +3299,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Aditya]: Add `robot/skill_mcp.robot` for MCP adapter smoke test.
   - [ ] Tests (ASV) [Aditya]: Add `benchmarks/mcp_adapter_bench.py` for tool invocation latency.
   - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Aditya]: `git add .` (only after nox passes)
-  - [ ] Commit [Aditya]: `git commit -m "feat(skill): add MCP adapter for external tools"`.
+  - [ ] Git [Aditya]: `git commit -m "feat(skill): add MCP adapter for external tools"`.
   - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-mcp-adapter` to `master` with description "Add MCP adapter for external tools with allowlist and tests.".
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git branch -d feature/m3-mcp-adapter`
+  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C8: Built-in Provider Actors [Aditya]** (depends on C1.schema + C2.loader)
-- [ ] **COMMIT (Owner: Aditya | Group: C8.providers | Branch: feature/m3-provider-actors | Planned: Day 18 | Expected: Day 20) - Commit message: "feat(actor): add built-in provider actors"**
+- [ ] **COMMIT (Owner: Aditya | Group: C8.providers | Branch: feature/m3-provider-actors | Planned: Day 18 | Expected: Day 23) - Commit message: "feat(actor): add built-in provider actors"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m3-provider-actors`
@@ -3259,19 +3324,20 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Aditya]: Add `robot/provider_actors.robot` for registry visibility.
   - [ ] Tests (ASV) [Aditya]: Add `benchmarks/provider_actor_load_bench.py` for registry load cost.
   - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Aditya]: `git add .` (only after nox passes)
-  - [ ] Commit [Aditya]: `git commit -m "feat(actor): add built-in provider actors"`.
+  - [ ] Git [Aditya]: `git commit -m "feat(actor): add built-in provider actors"`.
   - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-provider-actors` to `master` with description "Add built-in provider actor configs with defaults and tests.".
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git branch -d feature/m3-provider-actors`
+  - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group C9: Plan-Actor Integration [Jeff + Luis]** (depends on C2/C5/C6)
-- [ ] **COMMIT (Owner: Jeff | Group: C9.execute | Branch: feature/m3-plan-execute | Planned: Day 22 | Expected: Day 25) - Commit message: "feat(plan): execute strategize and execute phases via actors"**
+- [ ] **COMMIT (Owner: Jeff | Group: C9.execute | Branch: feature/m3-plan-execute | Planned: Day 22 | Expected: Day 28) - Commit message: "feat(plan): execute strategize and execute phases via actors"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-plan-execute`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Jeff]: Add local-only Strategize/Execute stub actors for M1 (no LLM) that can be swapped for compiled actors in C9; keep interface compatible with actor registry.
   - [ ] Code [Jeff]: Connect PlanLifecycleService to actor execution for Strategize and Execute phases.
   - [ ] Code [Jeff]: Ensure Strategize is read-only and records decisions without modifying resources.
   - [ ] Code [Jeff]: Ensure Execute uses sandbox resources and tool calls routed through Tool Router + ChangeSet.
@@ -3288,13 +3354,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/plan_actor_integration.robot` for end-to-end actor execution.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_actor_integration_bench.py` for execution overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(plan): execute strategize and execute phases via actors"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(plan): execute strategize and execute phases via actors"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-plan-execute` to `master` with description "Integrate actor execution for strategize/execute phases with change tracking.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-plan-execute`
-- [ ] **COMMIT (Owner: Jeff | Group: C9.apply | Branch: feature/m3-plan-apply | Planned: Day 23 | Expected: Day 26) - Commit message: "feat(plan): integrate change review and apply flow"**
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: C9.apply | Branch: feature/m3-plan-apply | Planned: Day 23 | Expected: Day 29) - Commit message: "feat(plan): integrate change review and apply flow"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-plan-apply`
@@ -3312,12 +3378,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add `robot/plan_review_apply.robot` for review-before-apply path.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_apply_bench.py` for apply throughput.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(plan): integrate change review and apply flow"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(plan): integrate change review and apply flow"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-plan-apply` to `master` with description "Integrate change review and apply flow with validation gating and tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m3-plan-apply`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **M3 SUCCESS CRITERIA**:
 - Actor YAML schema validated; examples load and compile to LangGraph.
@@ -3341,15 +3407,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D0.tests [Brent]**: ChangeSet/apply test coverage
   **SEQUENTIAL MERGE NOTE**: D0.alpha must land before D0.beta; D0.tests runs after both.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D0.alpha | Branch: feature/m1-changeset-core | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(execute): add changeset model and change capture"**
+- [ ] **COMMIT (Owner: Jeff | Group: D0.alpha | Branch: feature/m1-changeset-core | Planned: Day 9 | Expected: Day 12) - Commit message: "feat(execute): add changeset model and change capture"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m1-changeset-core`
   - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Jeff]: Add spec-aligned `ChangeSet` domain model with ULID ids, plan_id ULID, resource_id, tool_name, operation, path, before/after content, and timestamps.
-  - [ ] Code [Jeff]: Replace legacy `domain/models/core/change.py` usage in new code paths (retain file for legacy path removal in A5.legacy).
-  - [ ] Code [Jeff]: Add change capture hooks in built-in file tools to record changes into the active ChangeSet (per-plan, per-resource).
-  - [ ] Code [Jeff]: Add `ChangeSetStore` interface and in-memory implementation for M1 (persistence deferred to D1).
+  - [ ] Code [Jeff]: Rebase `tool/builtins/changeset.py` into a spec-aligned ChangeSet domain model (ULID ids, plan_id, resource_id, tool_name, operation, path, before/after hashes, timestamps) and re-export via `domain/models/core` if needed.
+  - [ ] Code [Jeff]: Update ChangeSetCapture to record `resource_id` + `tool_name` and attach timestamps per entry; keep write-only tools only.
+  - [ ] Code [Jeff]: Add execution-scoped ChangeSetStore interface with in-memory implementation for M1; support `start(plan_id)`, `record(entry)`, `get(plan_id)`, `summarize(plan_id)`.
+  - [ ] Code [Jeff]: Wire built-in file tools to pass `resource_id` and `sandbox_root` so ChangeSet entries resolve correctly in multi-resource plans.
   - [ ] Docs [Jeff]: Add `docs/reference/changeset_model.md` with entry examples and ULID field descriptions.
   - [ ] Tests (Behave) [Jeff]: Add scenarios for create/modify/delete/move capture and summary counts.
   - [ ] Tests (Robot) [Jeff]: Add Robot test that runs a file tool and verifies ChangeSet output.
@@ -3362,14 +3428,14 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m1-changeset-core`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: D0.beta | Branch: feature/m1-apply-pipeline | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(apply): add validation-gated apply pipeline"**
+- [ ] **COMMIT (Owner: Luis | Group: D0.beta | Branch: feature/m1-apply-pipeline | Planned: Day 9 | Expected: Day 12) - Commit message: "feat(apply): add validation-gated apply pipeline"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m1-apply-pipeline`
   - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Luis]: Implement Apply pipeline that merges ChangeSet into the real resource only when required validations pass.
-  - [ ] Code [Luis]: Add `ApplyService` and integrate with PlanLifecycleService `apply_plan()` flow (persist summary + timestamps).
-  - [ ] Code [Luis]: Add minimal validation gate stub (`ValidationResult.passed`) and block Apply on failures.
+  - [ ] Code [Luis]: Implement Apply pipeline that merges ChangeSet into the real resource only when required validations pass; set plan apply outcome to `applied` or `constrained` accordingly.
+  - [ ] Code [Luis]: Add `ApplyService` and integrate with PlanLifecycleService `apply_plan()` flow (persist summary + timestamps + apply outcome).
+  - [ ] Code [Luis]: Add minimal validation gate stub (`ValidationResult.passed`) and block Apply on failures with `constrained` state and actionable error message.
   - [ ] Docs [Luis]: Add `docs/reference/apply_pipeline.md` with flow diagram and failure cases.
   - [ ] Tests (Behave) [Luis]: Add scenarios for apply success, validation failure, and idempotent re-apply blocking.
   - [ ] Tests (Robot) [Luis]: Add Robot test that applies a ChangeSet and verifies disk changes.
@@ -3382,7 +3448,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m1-apply-pipeline`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Brent | Group: D0.tests | Branch: feature/m1-apply-tests | Planned: Day 9 | Expected: Day 11) - Commit message: "test(apply): cover changeset and apply pipeline"**
+- [ ] **COMMIT (Owner: Brent | Group: D0.tests | Branch: feature/m1-apply-tests | Planned: Day 10 | Expected: Day 13) - Commit message: "test(apply): cover changeset and apply pipeline"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m1-apply-tests`
@@ -3405,7 +3471,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D0b.apply [Jeff]**: Review/diff CLI + apply integration
   **SEQUENTIAL MERGE NOTE**: D0b.execute must land before D0b.apply.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D0b.execute | Branch: feature/m1-plan-execute | Planned: Day 10 | Expected: Day 12) - Commit message: "feat(plan): execute strategize and execute via actors"**
+- [ ] **COMMIT (Owner: Jeff | Group: D0b.execute | Branch: feature/m1-plan-execute | Planned: Day 11 | Expected: Day 15) - Commit message: "feat(plan): execute strategize and execute via actors"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m1-plan-execute`
@@ -3424,7 +3490,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m1-plan-execute`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D0b.apply | Branch: feature/m2-plan-apply-review | Planned: Day 12 | Expected: Day 14) - Commit message: "feat(plan): add diff review and apply integration"**
+- [ ] **COMMIT (Owner: Jeff | Group: D0b.apply | Branch: feature/m2-plan-apply-review | Planned: Day 12 | Expected: Day 17) - Commit message: "feat(plan): add diff review and apply integration"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m2-plan-apply-review`
@@ -3448,7 +3514,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D1.cli [Jeff]**: Validation summary output in plan status
   **SEQUENTIAL MERGE NOTE**: D1.apply lands before D1.cli.
 
-- [ ] **COMMIT (Owner: Luis | Group: D1.apply | Branch: feature/m3-validation-apply | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(apply): run validation attachments"**
+- [ ] **COMMIT (Owner: Luis | Group: D1.apply | Branch: feature/m3-validation-apply | Planned: Day 15 | Expected: Day 20) - Commit message: "feat(apply): run validation attachments"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m3-validation-apply`
@@ -3467,7 +3533,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Luis]: `git branch -d feature/m3-validation-apply`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D1.cli | Branch: feature/m3-validation-status | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(cli): surface validation summaries"**
+- [ ] **COMMIT (Owner: Jeff | Group: D1.cli | Branch: feature/m3-validation-status | Planned: Day 16 | Expected: Day 21) - Commit message: "feat(cli): surface validation summaries"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-status`
@@ -3491,7 +3557,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D2.cli [Jeff]**: CLI commands for invariants
   **SEQUENTIAL MERGE NOTE**: D2.model lands before D2.reconcile/D2.cli.
 
-- [ ] **COMMIT (Owner: Hamza | Group: D2.model | Branch: feature/m4-invariant-model | Planned: Day 19 | Expected: Day 21) - Commit message: "feat(domain): add invariant model and storage"**
+- [ ] **COMMIT (Owner: Hamza | Group: D2.model | Branch: feature/m4-invariant-model | Planned: Day 19 | Expected: Day 24) - Commit message: "feat(domain): add invariant model and storage"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-invariant-model`
@@ -3510,7 +3576,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Hamza]: `git branch -d feature/m4-invariant-model`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D2.reconcile | Branch: feature/m4-invariant-reconcile | Planned: Day 20 | Expected: Day 22) - Commit message: "feat(plan): reconcile invariants in strategize"**
+- [ ] **COMMIT (Owner: Jeff | Group: D2.reconcile | Branch: feature/m4-invariant-reconcile | Planned: Day 20 | Expected: Day 25) - Commit message: "feat(plan): reconcile invariants in strategize"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-invariant-reconcile`
@@ -3529,7 +3595,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m4-invariant-reconcile`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D2.cli | Branch: feature/m4-invariant-cli | Planned: Day 21 | Expected: Day 23) - Commit message: "feat(cli): add invariant commands"**
+- [ ] **COMMIT (Owner: Jeff | Group: D2.cli | Branch: feature/m4-invariant-cli | Planned: Day 21 | Expected: Day 26) - Commit message: "feat(cli): add invariant commands"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-invariant-cli`
@@ -3553,7 +3619,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D3.cli [Hamza]**: Plan tree/explain CLI
   **SEQUENTIAL MERGE NOTE**: D3.domain → D3.service → D3.cli.
 
-- [ ] **COMMIT (Owner: Hamza | Group: D3.domain | Branch: feature/m4-decision-domain | Planned: Day 21 | Expected: Day 23) - Commit message: "feat(domain): add decision model and context snapshots"**
+- [ ] **COMMIT (Owner: Hamza | Group: D3.domain | Branch: feature/m4-decision-domain | Planned: Day 21 | Expected: Day 26) - Commit message: "feat(domain): add decision model and context snapshots"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-domain`
@@ -3571,7 +3637,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Hamza]: `git branch -d feature/m4-decision-domain`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: D3.service | Branch: feature/m4-decision-service | Planned: Day 22 | Expected: Day 24) - Commit message: "feat(service): add decision recording and snapshot store"**
+- [ ] **COMMIT (Owner: Hamza | Group: D3.service | Branch: feature/m4-decision-service | Planned: Day 22 | Expected: Day 27) - Commit message: "feat(service): add decision recording and snapshot store"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-service`
@@ -3589,7 +3655,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Hamza]: `git branch -d feature/m4-decision-service`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: D3.cli | Branch: feature/m4-decision-cli | Planned: Day 23 | Expected: Day 25) - Commit message: "feat(cli): add plan tree and explain commands"**
+- [ ] **COMMIT (Owner: Hamza | Group: D3.cli | Branch: feature/m4-decision-cli | Planned: Day 23 | Expected: Day 28) - Commit message: "feat(cli): add plan tree and explain commands"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-cli`
@@ -3612,7 +3678,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   **PARALLEL SUBTRACK D4.append [Jeff]**: Append corrections
   **SEQUENTIAL MERGE NOTE**: D4.revert lands before D4.append.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D4.revert | Branch: feature/m4-decision-revert | Planned: Day 24 | Expected: Day 26) - Commit message: "feat(service): add decision correction revert flow"**
+- [ ] **COMMIT (Owner: Jeff | Group: D4.revert | Branch: feature/m4-decision-revert | Planned: Day 24 | Expected: Day 29) - Commit message: "feat(service): add decision correction revert flow"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-decision-revert`
@@ -3630,7 +3696,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git branch -d feature/m4-decision-revert`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: D4.append | Branch: feature/m4-decision-append | Planned: Day 25 | Expected: Day 27) - Commit message: "feat(service): add decision correction append flow"**
+- [ ] **COMMIT (Owner: Jeff | Group: D4.append | Branch: feature/m4-decision-append | Planned: Day 25 | Expected: Day 30) - Commit message: "feat(service): add decision correction append flow"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-decision-append`
@@ -3646,9 +3712,10 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-decision-append` to `master` with description "Add decision correction append flow and docs/tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-decision-append`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group D5: Decision Persistence [Hamza + Luis]** (depends on D1)
-- [ ] **COMMIT (Owner: Hamza | Group: D5.db | Branch: feature/m4-decision-persistence) - Commit message: "feat(db): add decision tables"**
+- [ ] **COMMIT (Owner: Hamza | Group: D5.db | Branch: feature/m4-decision-persistence | Planned: Day 24 | Expected: Day 29) - Commit message: "feat(db): add decision tables"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-persistence`
@@ -3661,13 +3728,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Hamza]: Add DB migration smoke test.
   - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_migration_bench.py` for migration baseline.
   - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Hamza]: `git add .` (only after nox passes)
-  - [ ] Commit [Hamza]: `git commit -m "feat(db): add decision tables"`.
+  - [ ] Git [Hamza]: `git commit -m "feat(db): add decision tables"`.
   - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-persistence` to `master` with description "Add decision persistence tables and migrations.".
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git branch -d feature/m4-decision-persistence`
-- [ ] **COMMIT (Owner: Hamza | Group: D5.repo | Branch: feature/m4-decision-persistence) - Commit message: "feat(repo): add decision repositories"**
+  - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Hamza | Group: D5.repo | Branch: feature/m4-decision-persistence | Planned: Day 25 | Expected: Day 30) - Commit message: "feat(repo): add decision repositories"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-persistence`
@@ -3680,13 +3747,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Hamza]: Add repository integration smoke test.
   - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_repository_bench.py` for tree query performance.
   - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Hamza]: `git add .` (only after nox passes)
-  - [ ] Commit [Hamza]: `git commit -m "feat(repo): add decision repositories"`.
+  - [ ] Git [Hamza]: `git commit -m "feat(repo): add decision repositories"`.
   - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-persistence` to `master` with description "Add decision repositories and persistence queries.".
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git branch -d feature/m4-decision-persistence`
-- [ ] **COMMIT (Owner: Luis | Group: D5.di | Branch: feature/m4-decision-di) - Commit message: "feat(di): wire decision services"**
+  - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Luis | Group: D5.di | Branch: feature/m4-decision-di | Planned: Day 26 | Expected: Day 31) - Commit message: "feat(di): wire decision services"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-decision-di`
@@ -3698,13 +3765,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add CLI smoke test using persisted decisions.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/decision_di_bench.py` for DI resolution overhead.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(di): wire decision services"`.
+  - [ ] Git [Luis]: `git commit -m "feat(di): wire decision services"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-decision-di` to `master` with description "Wire decision services into DI and CLI with tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m4-decision-di`
-- [ ] **COMMIT (Owner: Brent | Group: D5.tests | Branch: feature/m4-decision-tests) - Commit message: "test(persistence): add decision persistence suites"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Brent | Group: D5.tests | Branch: feature/m4-decision-tests | Planned: Day 27 | Expected: Day 31) - Commit message: "test(persistence): add decision persistence suites"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m4-decision-tests`
@@ -3716,15 +3783,15 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Docs [Brent]: Update `docs/development/testing.md` with decision suites.
   - [ ] Tests (ASV) [Brent]: Add `benchmarks/decision_persistence_bench.py` for DB persistence throughput.
   - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-  - [ ] Git [Brent]: `git add .` (only after coverage check passes)
-  - [ ] Commit [Brent]: `git commit -m "test(persistence): add decision persistence suites"`.
+  - [ ] Git [Brent]: `git add .` (only after nox passes)
+  - [ ] Git [Brent]: `git commit -m "test(persistence): add decision persistence suites"`.
   - [ ] Forgejo PR [Brent]: Open PR from `feature/m4-decision-tests` to `master` with description "Add decision persistence test suites and benchmarks.".
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git branch -d feature/m4-decision-tests`
+  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group DOD: Definition of Done + Invariants [Luis + Jeff]** (depends on D2/D4)
-- [ ] **COMMIT (Owner: Luis | Group: DOD.dod | Branch: feature/m4-definition-of-done) - Commit message: "feat(dod): enforce definition-of-done gating"**
+- [ ] **COMMIT (Owner: Luis | Group: DOD.dod | Branch: feature/m4-definition-of-done | Planned: Day 26 | Expected: Day 31) - Commit message: "feat(dod): enforce definition-of-done gating"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-definition-of-done`
@@ -3740,13 +3807,13 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Luis]: Add DoD integration smoke test.
   - [ ] Tests (ASV) [Luis]: Add `benchmarks/dod_evaluation_bench.py` for evaluation overhead.
   - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Luis]: `git add .` (only after nox passes)
-  - [ ] Commit [Luis]: `git commit -m "feat(dod): enforce definition-of-done gating"`.
+  - [ ] Git [Luis]: `git commit -m "feat(dod): enforce definition-of-done gating"`.
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-definition-of-done` to `master` with description "Enforce definition-of-done gating with evaluation and tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m4-definition-of-done`
-- [ ] **COMMIT (Owner: Jeff | Group: DOD.invariants | Branch: feature/m4-invariants) - Commit message: "feat(invariant): add invariant models and enforcement"**
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+- [ ] **COMMIT (Owner: Jeff | Group: DOD.invariants | Branch: feature/m4-invariants | Planned: Day 27 | Expected: Day 32) - Commit message: "feat(invariant): add invariant models and enforcement"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-invariants`
@@ -3765,12 +3832,12 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Tests (Robot) [Jeff]: Add invariant CLI integration tests.
   - [ ] Tests (ASV) [Jeff]: Add `benchmarks/invariant_merge_bench.py` for merge overhead.
   - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark).
-  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Git [Jeff]: `git add .` (only after nox passes)
-  - [ ] Commit [Jeff]: `git commit -m "feat(invariant): add invariant models and enforcement"`.
+  - [ ] Git [Jeff]: `git commit -m "feat(invariant): add invariant models and enforcement"`.
   - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-invariants` to `master` with description "Add invariant models, persistence, and enforcement with tests.".
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m4-invariants`
+  - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 
 ### Section 7: Subplans & Parallelism [M5]
@@ -4016,27 +4083,27 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
       }
       ```
       - [X] Commit: "feat(domain): define retriable vs non-retriable failures"
-  - [ ] **COMMIT (Owner: Brent | Group: E1.tests | Branch: feature/m5-subplan-tests) - Commit message: "test(domain): add subplan model suites"**
-    - [ ] Git [Brent]: `git checkout master`
-    - [ ] Git [Brent]: `git pull origin master`
-    - [ ] Git [Brent]: `git checkout -b feature/m5-subplan-tests`
-    - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-    - [ ] Code [Brent]: Add Behave feature coverage for subplan model defaults, hierarchy helpers, and retry metadata.
-    - [ ] Code [Brent]: Add step definitions in `features/steps/subplan_model_steps.py` (plan hierarchy, defaults, dependency validation).
-    - [ ] Docs [Brent]: Update `docs/development/testing.md` with subplan model test coverage notes.
-    - [ ] Tests (Behave) [Brent]: Add `features/subplan_model.feature` scenarios (hierarchy flags, defaults, dependency guardrails).
-    - [ ] Tests (Robot) [Brent]: Add `robot/subplan_model.robot` smoke coverage for CLI/status surface output.
-    - [ ] Tests (ASV) [Brent]: Add `benchmarks/subplan_model_validation_bench.py` for model validation baseline.
-    - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
-    - [ ] Git [Brent]: `git add .`
-    - [ ] Git [Brent]: `git commit -m "test(domain): add subplan model suites"`
-    - [ ] Forgejo PR [Brent]: Open PR from `feature/m5-subplan-tests` to `master` with description "Add subplan model Behave/Robot suites and benchmarks.".
-    - [ ] Git [Brent]: `git checkout master`
-    - [ ] Git [Brent]: `git branch -d feature/m5-subplan-tests`
-    - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
+  - [ ] **COMMIT (Owner: Brent | Group: E1.tests | Branch: feature/m5-subplan-tests | Planned: Day 25 | Expected: Day 28) - Commit message: "test(domain): add subplan model suites"**
+  - [ ] Git [Brent]: `git checkout master`
+  - [ ] Git [Brent]: `git pull origin master`
+  - [ ] Git [Brent]: `git checkout -b feature/m5-subplan-tests`
+  - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
+  - [ ] Code [Brent]: Add Behave feature coverage for subplan model defaults, hierarchy helpers, and retry metadata.
+  - [ ] Code [Brent]: Add step definitions in `features/steps/subplan_model_steps.py` (plan hierarchy, defaults, dependency validation).
+  - [ ] Docs [Brent]: Update `docs/development/testing.md` with subplan model test coverage notes.
+  - [ ] Tests (Behave) [Brent]: Add `features/subplan_model.feature` scenarios (hierarchy flags, defaults, dependency guardrails).
+  - [ ] Tests (Robot) [Brent]: Add `robot/subplan_model.robot` smoke coverage for CLI/status surface output.
+  - [ ] Tests (ASV) [Brent]: Add `benchmarks/subplan_model_validation_bench.py` for model validation baseline.
+  - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark).
+  - [ ] Git [Brent]: `git add .`
+  - [ ] Git [Brent]: `git commit -m "test(domain): add subplan model suites"`
+  - [ ] Forgejo PR [Brent]: Open PR from `feature/m5-subplan-tests` to `master` with description "Add subplan model Behave/Robot suites and benchmarks.".
+  - [ ] Git [Brent]: `git checkout master`
+  - [ ] Git [Brent]: `git branch -d feature/m5-subplan-tests`
+  - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group E2: Subplan Spawning [Jeff + Aditya]** (depends on D2 + E1)
-- [ ] **COMMIT (Owner: Jeff | Group: E2.service | Branch: feature/m5-subplan-service) - Commit message: "feat(service): add subplan service and spawn workflow"**
+- [ ] **COMMIT (Owner: Jeff | Group: E2.service | Branch: feature/m5-subplan-service | Planned: Day 26 | Expected: Day 29) - Commit message: "feat(service): add subplan service and spawn workflow"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m5-subplan-service`
@@ -4064,7 +4131,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git branch -d feature/m5-subplan-service`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-- [ ] **COMMIT (Owner: Aditya | Group: E2.actor | Branch: feature/m5-subplan-actor) - Commit message: "feat(actor): add plan_subplan tool and decision emission"**
+- [ ] **COMMIT (Owner: Aditya | Group: E2.actor | Branch: feature/m5-subplan-actor | Planned: Day 26 | Expected: Day 29) - Commit message: "feat(actor): add plan_subplan tool and decision emission"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m5-subplan-actor`
@@ -4090,7 +4157,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group E3: Parallel Execution [Luis + Jeff]** (depends on E1/E2)
-- [ ] **COMMIT (Owner: Luis | Group: E3.exec | Branch: feature/m5-subplan-exec) - Commit message: "feat(service): add subplan scheduler and execution"**
+- [ ] **COMMIT (Owner: Luis | Group: E3.exec | Branch: feature/m5-subplan-exec | Planned: Day 27 | Expected: Day 30) - Commit message: "feat(service): add subplan scheduler and execution"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m5-subplan-exec`
@@ -4118,7 +4185,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group E4: Result Merging [Jeff]** (depends on E3)
-- [ ] **COMMIT (Owner: Jeff | Group: E4.merge | Branch: feature/m5-subplan-merge) - Commit message: "feat(merge): add subplan merge strategies"**
+- [ ] **COMMIT (Owner: Jeff | Group: E4.merge | Branch: feature/m5-subplan-merge | Planned: Day 28 | Expected: Day 31) - Commit message: "feat(merge): add subplan merge strategies"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m5-subplan-merge`
@@ -4145,7 +4212,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group E5: Multi-Project Plans [Hamza]** (depends on E2/E4)
-- [ ] **COMMIT (Owner: Hamza | Group: E5.multi | Branch: feature/m5-multi-project) - Commit message: "feat(plan): add multi-project subplan support"**
+- [ ] **COMMIT (Owner: Hamza | Group: E5.multi | Branch: feature/m5-multi-project | Planned: Day 29 | Expected: Day 32) - Commit message: "feat(plan): add multi-project subplan support"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m5-multi-project`
@@ -4177,7 +4244,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
 **Local-mode only**: large-project autonomy is required; server connectivity remains stubbed.
 
 **Parallel Group G1: Large-Project Decomposition [Jeff]**
-- [ ] **COMMIT (Owner: Jeff | Group: G1.decompose | Branch: feature/m6-large-decompose) - Commit message: "feat(plan): add large-project decomposition and dependency closure"**
+- [ ] **COMMIT (Owner: Jeff | Group: G1.decompose | Branch: feature/m6-large-decompose | Planned: Day 26 | Expected: Day 31) - Commit message: "feat(plan): add large-project decomposition and dependency closure"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m6-large-decompose`
@@ -4206,7 +4273,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group G2: Checkpointing & Rollback [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: G2.checkpoint | Branch: feature/m6-checkpoint) - Commit message: "feat(checkpoint): add checkpointing and rollback"**
+- [ ] **COMMIT (Owner: Luis | Group: G2.checkpoint | Branch: feature/m6-checkpoint | Planned: Day 27 | Expected: Day 32) - Commit message: "feat(checkpoint): add checkpointing and rollback"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-checkpoint`
@@ -4234,7 +4301,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group G3: Semantic Validation [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: G3.semantic | Branch: feature/m6-semantic-validation) - Commit message: "feat(validation): add semantic validation service"**
+- [ ] **COMMIT (Owner: Luis | Group: G3.semantic | Branch: feature/m6-semantic-validation | Planned: Day 27 | Expected: Day 32) - Commit message: "feat(validation): add semantic validation service"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-semantic-validation`
@@ -4262,7 +4329,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group G4: Context Tiers & Views [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: G4.context | Branch: feature/m6-context-tiers) - Commit message: "feat(context): add hot/warm/cold tiers and actor views"**
+- [ ] **COMMIT (Owner: Hamza | Group: G4.context | Branch: feature/m6-context-tiers | Planned: Day 28 | Expected: Day 33) - Commit message: "feat(context): add hot/warm/cold tiers and actor views"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m6-context-tiers`
@@ -4291,7 +4358,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group G5: Cost & Risk Estimation [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: G5.estimate | Branch: feature/m6-estimation) - Commit message: "feat(estimation): add cost and risk estimation actor"**
+- [ ] **COMMIT (Owner: Hamza | Group: G5.estimate | Branch: feature/m6-estimation | Planned: Day 28 | Expected: Day 33) - Commit message: "feat(estimation): add cost and risk estimation actor"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m6-estimation`
@@ -4316,7 +4383,7 @@ No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group G6: CLI Polish [Jeff]**
-- [ ] **COMMIT (Owner: Jeff | Group: G6.cli | Branch: feature/m6-cli-polish) - Commit message: "chore(cli): polish help and output"**
+- [ ] **COMMIT (Owner: Jeff | Group: G6.cli | Branch: feature/m6-cli-polish | Planned: Day 29 | Expected: Day 33) - Commit message: "chore(cli): polish help and output"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m6-cli-polish`
@@ -4355,7 +4422,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 **Target: Deliver stubs by M6 (Day 30); full server implementation remains post-Day 30**
 
 **Parallel Group F0: Server Client Stubs [Luis]** (required for M6; no server implementation)
-- [ ] **COMMIT (Owner: Luis | Group: F0.stubs | Branch: feature/m6-server-stubs) - Commit message: "feat(interfaces): add server client stubs"**
+- [ ] **COMMIT (Owner: Luis | Group: F0.stubs | Branch: feature/m6-server-stubs | Planned: Day 28 | Expected: Day 33) - Commit message: "feat(interfaces): add server client stubs"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-server-stubs`
@@ -4395,7 +4462,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 **Note**: Quality automation setup is in Section 0; Section 10 focuses on async infrastructure and later-stage validation support.
 
 **Parallel Group 10A: Async Infrastructure [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: 10A.async | Branch: feature/m6-async-infra) - Commit message: "feat(async): add async command execution and workers"**
+- [ ] **COMMIT (Owner: Luis | Group: 10A.async | Branch: feature/m6-async-infra | Planned: Day 27 | Expected: Day 33) - Commit message: "feat(async): add async command execution and workers"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-async-infra`
@@ -4423,7 +4490,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m6-async-infra`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-- [ ] **COMMIT (Owner: Luis | Group: 10A.retry | Branch: feature/m6-async-infra) - Commit message: "feat(async): wire retry policies into services"**
+- [ ] **COMMIT (Owner: Luis | Group: 10A.retry | Branch: feature/m6-async-infra | Planned: Day 28 | Expected: Day 34) - Commit message: "feat(async): wire retry policies into services"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-async-infra`
@@ -4450,7 +4517,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group 10B: Selective Quality Review [Brent]**
-- [ ] **COMMIT (Owner: Brent | Group: 10B.review | Branch: feature/m6-review-playbook) - Commit message: "docs(qa): add review playbook and priority matrix"**
+- [ ] **COMMIT (Owner: Brent | Group: 10B.review | Branch: feature/m6-review-playbook | Planned: Day 22 | Expected: Day 26) - Commit message: "docs(qa): add review playbook and priority matrix"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m6-review-playbook`
@@ -4474,7 +4541,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group 10C: Validation Testing Support [Brent + Luis]**
-- [ ] **COMMIT (Owner: Brent | Group: 10C.edge | Branch: feature/m6-validation-edge) - Commit message: "test(validation): add edge case suites"**
+- [ ] **COMMIT (Owner: Brent | Group: 10C.edge | Branch: feature/m6-validation-edge | Planned: Day 24 | Expected: Day 29) - Commit message: "test(validation): add edge case suites"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m6-validation-edge`
@@ -4494,7 +4561,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git branch -d feature/m6-validation-edge`
   - [ ] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-- [ ] **COMMIT (Owner: Luis | Group: 10C.semantic | Branch: feature/m6-validation-semantic) - Commit message: "test(validation): add semantic validation suites"**
+- [ ] **COMMIT (Owner: Luis | Group: 10C.semantic | Branch: feature/m6-validation-semantic | Planned: Day 25 | Expected: Day 30) - Commit message: "test(validation): add semantic validation suites"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m6-validation-semantic`
@@ -4514,7 +4581,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m6-validation-semantic`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
-- [ ] **COMMIT (Owner: Brent | Group: 10C.performance | Branch: feature/m6-perf-scale) - Commit message: "test(perf): add scale test fixtures"**
+- [ ] **COMMIT (Owner: Brent | Group: 10C.performance | Branch: feature/m6-perf-scale | Planned: Day 26 | Expected: Day 31) - Commit message: "test(perf): add scale test fixtures"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m6-perf-scale`
@@ -4544,7 +4611,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 **Note**: Security tasks focus on runtime protections; quality gates are handled in Section 0.
 
 **Parallel Group SEC1: Remove eval() usage [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: SEC1.eval | Branch: feature/m4-security-eval) - Commit message: "fix(security): remove eval-based config parsing"**
+- [ ] **COMMIT (Owner: Luis | Group: SEC1.eval | Branch: feature/m4-security-eval | Planned: Day 11 | Expected: Day 13) - Commit message: "fix(security): remove eval-based config parsing"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-security-eval`
@@ -4566,7 +4633,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. (Code review by Brent still pending)
 
 **Parallel Group SEC2: Template Injection Prevention [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: SEC2.template | Branch: feature/m4-security-template) - Commit message: "fix(security): harden template rendering"**
+- [ ] **COMMIT (Owner: Luis | Group: SEC2.template | Branch: feature/m4-security-template | Planned: Day 11 | Expected: Day 13) - Commit message: "fix(security): harden template rendering"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-security-template`
@@ -4589,7 +4656,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group SEC3: Exception Handling Audit [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: SEC3.exceptions | Branch: feature/m4-security-exceptions) - Commit message: "fix(security): enforce explicit exception handling"**
+- [ ] **COMMIT (Owner: Luis | Group: SEC3.exceptions | Branch: feature/m4-security-exceptions | Planned: Day 12 | Expected: Day 14) - Commit message: "fix(security): enforce explicit exception handling"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-security-exceptions`
@@ -4612,7 +4679,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group SEC4: Async Lifecycle Correctness [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: SEC4.async | Branch: feature/m4-security-async-cleanup) - Commit message: "fix(security): close async resources and leaks"**
+- [ ] **COMMIT (Owner: Luis | Group: SEC4.async | Branch: feature/m4-security-async-cleanup | Planned: Day 12 | Expected: Day 14) - Commit message: "fix(security): close async resources and leaks"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-security-async-cleanup`
@@ -4635,7 +4702,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group SEC5: Secrets Management [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: SEC5.secrets | Branch: feature/m4-security-secrets) - Commit message: "feat(security): add secrets masking and validation"**
+- [ ] **COMMIT (Owner: Hamza | Group: SEC5.secrets | Branch: feature/m4-security-secrets | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(security): add secrets masking and validation"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-security-secrets`
@@ -4659,7 +4726,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group SEC6: Read-Only Enforcement [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: SEC6.readonly | Branch: feature/m4-security-readonly) - Commit message: "feat(security): enforce read-only actions"**
+- [ ] **COMMIT (Owner: Luis | Group: SEC6.readonly | Branch: feature/m4-security-readonly | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(security): enforce read-only actions"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-security-readonly`
@@ -4679,11 +4746,11 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-readonly` to `master` with description "Enforce read-only actions and tool gating with tests.".
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git branch -d feature/m4-security-readonly`
-  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
   - [ ] Note: Safety profile enforcement is deferred; see Section 18 POST.safety.
+  - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group SEC7: Audit Logging [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: SEC7.audit | Branch: feature/m4-security-audit) - Commit message: "feat(security): add audit logging for apply"**
+- [ ] **COMMIT (Owner: Hamza | Group: SEC7.audit | Branch: feature/m4-security-audit | Planned: Day 14 | Expected: Day 16) - Commit message: "feat(security): add audit logging for apply"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-security-audit`
@@ -4711,7 +4778,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 **Target: Days 8-12**
 
 **Parallel Group PROV1: Provider Fixes [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: PROV1.fixes | Branch: feature/m4-provider-fixes) - Commit message: "fix(provider): remove FakeListLLM defaults"**
+- [ ] **COMMIT (Owner: Luis | Group: PROV1.fixes | Branch: feature/m4-provider-fixes | Planned: Day 8 | Expected: Day 10) - Commit message: "fix(provider): remove FakeListLLM defaults"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-provider-fixes`
@@ -4736,7 +4803,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group PROV2: Cost Controls & Fallback [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: PROV2.costs | Branch: feature/m4-provider-costs) - Commit message: "feat(provider): add cost controls and fallback"**
+- [ ] **COMMIT (Owner: Luis | Group: PROV2.costs | Branch: feature/m4-provider-costs | Planned: Day 10 | Expected: Day 12) - Commit message: "feat(provider): add cost controls and fallback"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-provider-costs`
@@ -4765,7 +4832,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 ### Section 13: Additional CLI Commands & UX [Days 10-14]
 
 **Parallel Group CLI0: Core System Commands [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: CLI0.core | Branch: feature/m4-cli-core) - Commit message: "feat(cli): add version/info/diagnostics"**
+- [ ] **COMMIT (Owner: Hamza | Group: CLI0.core | Branch: feature/m4-cli-core | Planned: Day 10 | Expected: Day 12) - Commit message: "feat(cli): add version/info/diagnostics"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-cli-core`
@@ -4794,7 +4861,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   **PARALLEL SUBTRACK CLI1.beta [Brent]**: Extended CLI tests + output snapshots
   **SEQUENTIAL MERGE NOTE**: CLI1.alpha depends on A6 automation profiles + D2 invariants; CLI1.beta runs after CLI1.alpha.
 
-- [ ] **COMMIT (Owner: Jeff | Group: CLI1.alpha | Branch: feature/m4-cli-extensions) - Commit message: "feat(cli): add action and plan CLI extensions"**
+- [ ] **COMMIT (Owner: Jeff | Group: CLI1.alpha | Branch: feature/m4-cli-extensions | Planned: Day 11 | Expected: Day 13) - Commit message: "feat(cli): add action and plan CLI extensions"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-cli-extensions`
@@ -4815,7 +4882,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Jeff]: `git branch -d feature/m4-cli-extensions` (post-merge cleanup)
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Brent | Group: CLI1.beta | Branch: feature/m4-cli-extension-tests) - Commit message: "test(cli): cover action and plan extensions"**
+- [ ] **COMMIT (Owner: Brent | Group: CLI1.beta | Branch: feature/m4-cli-extension-tests | Planned: Day 12 | Expected: Day 14) - Commit message: "test(cli): cover action and plan extensions"**
   - [ ] Git [Brent]: `git checkout master`
   - [ ] Git [Brent]: `git pull origin master`
   - [ ] Git [Brent]: `git checkout -b feature/m4-cli-extension-tests`
@@ -4838,7 +4905,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 ### Section 14: Concurrency & Cleanup [Days 12-14]
 
 **Parallel Group CONC1: Plan Locking [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: CONC1.lock | Branch: feature/m4-concurrency-locks) - Commit message: "feat(concurrency): add plan and project locks"**
+- [ ] **COMMIT (Owner: Luis | Group: CONC1.lock | Branch: feature/m4-concurrency-locks | Planned: Day 12 | Expected: Day 14) - Commit message: "feat(concurrency): add plan and project locks"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-concurrency-locks`
@@ -4864,7 +4931,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group CONC2: Resumable Execution [Luis]**
-- [ ] **COMMIT (Owner: Luis | Group: CONC2.resume | Branch: feature/m4-concurrency-resume) - Commit message: "feat(concurrency): add plan resume"**
+- [ ] **COMMIT (Owner: Luis | Group: CONC2.resume | Branch: feature/m4-concurrency-resume | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(concurrency): add plan resume"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-concurrency-resume`
@@ -4889,7 +4956,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group CONC3: Garbage Collection [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: CONC3.gc | Branch: feature/m4-concurrency-cleanup) - Commit message: "feat(ops): add cleanup commands"**
+- [ ] **COMMIT (Owner: Hamza | Group: CONC3.gc | Branch: feature/m4-concurrency-cleanup | Planned: Day 13 | Expected: Day 15) - Commit message: "feat(ops): add cleanup commands"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-concurrency-cleanup`
@@ -4920,7 +4987,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 **Target: Begin scaffolding by Day 25; full implementation after M6 (local mode only)**
 
 **Parallel Group ACMS1: UKO Ontology Scaffold [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: ACMS1.uko | Branch: feature/m6-acms-uko-schema) - Commit message: "feat(uko): add UKO ontology scaffolding"**
+- [ ] **COMMIT (Owner: Hamza | Group: ACMS1.uko | Branch: feature/m6-acms-uko-schema | Planned: Day 26 | Expected: Day 28) - Commit message: "feat(uko): add UKO ontology scaffolding"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-uko-schema`
@@ -4946,7 +5013,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group ACMS2: Context Request Protocol [Jeff]** (depends on ACMS1 + CTX1)
-- [ ] **COMMIT (Owner: Jeff | Group: ACMS2.crp | Branch: feature/m6-acms-crp-models) - Commit message: "feat(acms): add context request protocol models"**
+- [ ] **COMMIT (Owner: Jeff | Group: ACMS2.crp | Branch: feature/m6-acms-crp-models | Planned: Day 27 | Expected: Day 29) - Commit message: "feat(acms): add context request protocol models"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-crp-models`
@@ -4971,7 +5038,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group ACMS3: Context Strategies & Registry [Hamza]** (depends on CTX1/CTX2)
-- [ ] **COMMIT (Owner: Hamza | Group: ACMS3.strategy | Branch: feature/m6-acms-strategy-registry) - Commit message: "feat(acms): add context strategy registry"**
+- [ ] **COMMIT (Owner: Hamza | Group: ACMS3.strategy | Branch: feature/m6-acms-strategy-registry | Planned: Day 27 | Expected: Day 29) - Commit message: "feat(acms): add context strategy registry"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-strategy-registry`
@@ -4996,7 +5063,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group ACMS4: Strategy Coordinator & Fusion Engine [Jeff]** (depends on ACMS2/ACMS3)
-- [ ] **COMMIT (Owner: Jeff | Group: ACMS4.fusion | Branch: feature/m6-acms-fusion-engine) - Commit message: "feat(acms): add strategy coordinator and fusion engine"**
+- [ ] **COMMIT (Owner: Jeff | Group: ACMS4.fusion | Branch: feature/m6-acms-fusion-engine | Planned: Day 28 | Expected: Day 30) - Commit message: "feat(acms): add strategy coordinator and fusion engine"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-fusion-engine`
@@ -5021,7 +5088,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group ACMS5: Scoped Backend Views [Hamza]** (depends on B2.project + CTX1)
-- [ ] **COMMIT (Owner: Hamza | Group: ACMS5.scoped | Branch: feature/m6-acms-scoped-view) - Commit message: "feat(acms): add scoped backend view filtering"**
+- [ ] **COMMIT (Owner: Hamza | Group: ACMS5.scoped | Branch: feature/m6-acms-scoped-view | Planned: Day 28 | Expected: Day 30) - Commit message: "feat(acms): add scoped backend view filtering"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-scoped-view`
@@ -5046,7 +5113,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group ACMS6: Skeleton Compression [Jeff]** (depends on ACMS4 + G4 context tiers)
-- [ ] **COMMIT (Owner: Jeff | Group: ACMS6.skeleton | Branch: feature/m6-acms-skeleton-compress) - Commit message: "feat(acms): add skeleton compressor"**
+- [ ] **COMMIT (Owner: Jeff | Group: ACMS6.skeleton | Branch: feature/m6-acms-skeleton-compress | Planned: Day 29 | Expected: Day 31) - Commit message: "feat(acms): add skeleton compressor"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-skeleton-compress`
@@ -5075,7 +5142,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 ### Section 16: Context Indexing [Days 15-17]
 
 **Parallel Group CTX1: Repository Indexing [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: CTX1.index | Branch: feature/m4-context-indexing) - Commit message: "feat(context): add repo indexing service"**
+- [ ] **COMMIT (Owner: Hamza | Group: CTX1.index | Branch: feature/m4-context-indexing | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(context): add repo indexing service"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-context-indexing`
@@ -5102,7 +5169,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
 **Parallel Group CTX2: Embedding Index [Hamza]**
-- [ ] **COMMIT (Owner: Hamza | Group: CTX2.embedding | Branch: feature/m4-context-embedding) - Commit message: "feat(context): add optional embedding search"**
+- [ ] **COMMIT (Owner: Hamza | Group: CTX2.embedding | Branch: feature/m4-context-embedding | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(context): add optional embedding search"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m4-context-embedding`
@@ -5141,7 +5208,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   **PARALLEL SUBTRACK SK4.refresh [Aditya]**: MCP refresh hooks and dynamic updates
   **SEQUENTIAL MERGE NOTE**: SK2.persistence must land before SK1.core + SK3.cli to avoid schema mismatches; SK4.refresh depends on C7.mcp and can land after SK1.core.
 
-- [ ] **COMMIT (Owner: Jeff | Group: SK1.core | Branch: feature/m4-skill-registry-core) - Commit message: "feat(skill): add registry flattening and capability summaries"**
+- [ ] **COMMIT (Owner: Jeff | Group: SK1.core | Branch: feature/m4-skill-registry-core | Planned: Day 18 | Expected: Day 19) - Commit message: "feat(skill): add registry flattening and capability summaries"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m4-skill-registry-core`
@@ -5166,7 +5233,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Jeff]: `git branch -d feature/m4-skill-registry-core`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: SK2.persistence | Branch: feature/m4-skill-registry-db) - Commit message: "feat(skill): persist flattened tool sets"**
+- [ ] **COMMIT (Owner: Luis | Group: SK2.persistence | Branch: feature/m4-skill-registry-db | Planned: Day 17 | Expected: Day 18) - Commit message: "feat(skill): persist flattened tool sets"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m4-skill-registry-db`
@@ -5189,7 +5256,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Luis]: `git branch -d feature/m4-skill-registry-db`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Aditya | Group: SK3.cli | Branch: feature/m4-skill-registry-cli) - Commit message: "feat(cli): add skill tools and refresh commands"**
+- [ ] **COMMIT (Owner: Aditya | Group: SK3.cli | Branch: feature/m4-skill-registry-cli | Planned: Day 18 | Expected: Day 19) - Commit message: "feat(cli): add skill tools and refresh commands"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m4-skill-registry-cli`
@@ -5212,7 +5279,7 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
   - [ ] Git [Aditya]: `git branch -d feature/m4-skill-registry-cli`
   - [ ] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Aditya | Group: SK4.refresh | Branch: feature/m4-skill-registry-refresh) - Commit message: "feat(skill): add MCP refresh hooks"**
+- [ ] **COMMIT (Owner: Aditya | Group: SK4.refresh | Branch: feature/m4-skill-registry-refresh | Planned: Day 19 | Expected: Day 20) - Commit message: "feat(skill): add MCP refresh hooks"**
   - [ ] Git [Aditya]: `git checkout master`
   - [ ] Git [Aditya]: `git pull origin master`
   - [ ] Git [Aditya]: `git checkout -b feature/m4-skill-registry-refresh`
@@ -5241,12 +5308,12 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is
 
 Deferred items remain planned but are not part of the 30-day MVP scope.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.virtual-core | Branch: feature/post-resource-types-virtual-core) - Commit message: "feat(resource): add virtual core resource types"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.virtual-core | Branch: feature/post-resource-types-virtual-core | Planned: Day 31 | Expected: Day 36) - Commit message: "feat(resource): add virtual core resource types"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/post-resource-types-virtual-core`
   - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit)
-  - [ ] Code [Hamza]: Add built-in **virtual** resource type YAML configs under `resources/types/`: `file`, `directory`, `commit`, `branch`, `tag`, `tree`.
+  - [ ] Code [Hamza]: Add built-in **virtual** resource type YAML configs under `examples/resource-types/`: `file`, `directory`, `commit`, `branch`, `tag`, `tree`.
   - [ ] Code [Hamza]: Set `resource_kind: virtual`, `user_addable: false`, and no sandbox strategy; encode allowed children per spec.
   - [ ] Code [Hamza]: Add equivalence metadata fields (content hash/name/permissions for `file`/`directory`; git object identity for `commit`/`branch`/`tag`/`tree`).
   - [ ] Code [Hamza]: Extend bootstrap registration to include these virtual types and hide them from `resource add` scaffolding.
@@ -5262,7 +5329,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/post-resource-types-virtual-core`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.physical | Branch: feature/post-resource-types-physical) - Commit message: "feat(resource): add deferred physical resource types"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.physical | Branch: feature/post-resource-types-physical | Planned: Day 32 | Expected: Day 37) - Commit message: "feat(resource): add deferred physical resource types"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/post-resource-types-physical`
@@ -5282,7 +5349,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/post-resource-types-physical`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.virtual | Branch: feature/post-resource-types-virtual) - Commit message: "feat(resource): add deferred virtual resource types"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.virtual | Branch: feature/post-resource-types-virtual | Planned: Day 33 | Expected: Day 38) - Commit message: "feat(resource): add deferred virtual resource types"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/post-resource-types-virtual`
@@ -5301,7 +5368,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/post-resource-types-virtual`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.safety-profile | Branch: feature/post-safety-profile) - Commit message: "feat(security): add safety profile model and enforcement stubs"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.safety-profile | Branch: feature/post-safety-profile | Planned: Day 32 | Expected: Day 37) - Commit message: "feat(security): add safety profile model and enforcement stubs"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/post-safety-profile`
@@ -5321,7 +5388,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/post-safety-profile`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Rui | Group: POST.safety-profile-tests | Branch: feature/post-safety-profile-tests) - Commit message: "test(security): cover safety profile enforcement"**
+- [ ] **COMMIT (Owner: Rui | Group: POST.safety-profile-tests | Branch: feature/post-safety-profile-tests | Planned: Day 33 | Expected: Day 38) - Commit message: "test(security): cover safety profile enforcement"**
   - [ ] Git [Rui]: `git checkout master`
   - [ ] Git [Rui]: `git pull origin master`
   - [ ] Git [Rui]: `git checkout -b feature/post-safety-profile-tests`
@@ -5339,7 +5406,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Rui]: `git branch -d feature/post-safety-profile-tests`
   - [ ] Quality [Rui]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.resource | Branch: feature/m7-post-resource-equivalence) - Commit message: "feat(resource): add virtual resource equivalence tracking"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.resource | Branch: feature/m7-post-resource-equivalence | Planned: Day 34 | Expected: Day 39) - Commit message: "feat(resource): add virtual resource equivalence tracking"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-equivalence`
@@ -5364,7 +5431,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/m7-post-resource-equivalence`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server) - Commit message: "feat(client): add server http client"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 35 | Expected: Day 40) - Commit message: "feat(client): add server http client"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-server`
@@ -5389,7 +5456,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/m7-post-server`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server) - Commit message: "feat(client): add plan sync and remote execution"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 36 | Expected: Day 41) - Commit message: "feat(client): add plan sync and remote execution"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-server`
@@ -5413,7 +5480,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/m7-post-server`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server) - Commit message: "feat(client): add websocket updates"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 37 | Expected: Day 42) - Commit message: "feat(client): add websocket updates"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-server`
@@ -5437,7 +5504,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/m7-post-server`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.server | Branch: feature/m7-post-server) - Commit message: "feat(client): add remote project support"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 38 | Expected: Day 43) - Commit message: "feat(client): add remote project support"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m7-post-server`
@@ -5461,7 +5528,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/m7-post-server`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Rui | Group: POST.repl | Branch: feature/m7-post-repl) - Commit message: "feat(cli): add interactive repl"**
+- [ ] **COMMIT (Owner: Rui | Group: POST.repl | Branch: feature/m7-post-repl | Planned: Day 36 | Expected: Day 41) - Commit message: "feat(cli): add interactive repl"**
   - [ ] Git [Rui]: `git checkout master`
   - [ ] Git [Rui]: `git pull origin master`
   - [ ] Git [Rui]: `git checkout -b feature/m7-post-repl`
@@ -5485,7 +5552,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Rui]: `git branch -d feature/m7-post-repl`
   - [ ] Quality [Rui]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.auth | Branch: feature/m7-post-auth) - Commit message: "feat(cli): add auth and team commands"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.auth | Branch: feature/m7-post-auth | Planned: Day 37 | Expected: Day 42) - Commit message: "feat(cli): add auth and team commands"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-auth`
@@ -5509,7 +5576,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/m7-post-auth`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Jeff | Group: POST.tui | Branch: feature/m7-post-tui) - Commit message: "feat(ui): add TUI/Web interface"**
+- [ ] **COMMIT (Owner: Jeff | Group: POST.tui | Branch: feature/m7-post-tui | Planned: Day 38 | Expected: Day 43) - Commit message: "feat(ui): add TUI/Web interface"**
   - [ ] Git [Jeff]: `git checkout master`
   - [ ] Git [Jeff]: `git pull origin master`
   - [ ] Git [Jeff]: `git checkout -b feature/m7-post-tui`
@@ -5530,7 +5597,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Jeff]: `git branch -d feature/m7-post-tui`
   - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.dbresources | Branch: feature/m7-post-resource-db) - Commit message: "feat(resource): add database resources"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.dbresources | Branch: feature/m7-post-resource-db | Planned: Day 39 | Expected: Day 44) - Commit message: "feat(resource): add database resources"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-db`
@@ -5550,7 +5617,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/m7-post-resource-db`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Hamza | Group: POST.cloud | Branch: feature/m7-post-resource-cloud) - Commit message: "feat(resource): add cloud infrastructure resources"**
+- [ ] **COMMIT (Owner: Hamza | Group: POST.cloud | Branch: feature/m7-post-resource-cloud | Planned: Day 40 | Expected: Day 45) - Commit message: "feat(resource): add cloud infrastructure resources"**
   - [ ] Git [Hamza]: `git checkout master`
   - [ ] Git [Hamza]: `git pull origin master`
   - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-cloud`
@@ -5570,7 +5637,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Hamza]: `git branch -d feature/m7-post-resource-cloud`
   - [ ] Quality [Hamza]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.permissions | Branch: feature/m7-post-permissions) - Commit message: "feat(security): add permission system"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.permissions | Branch: feature/m7-post-permissions | Planned: Day 39 | Expected: Day 44) - Commit message: "feat(security): add permission system"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-permissions`
@@ -5590,7 +5657,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope.
   - [ ] Git [Luis]: `git branch -d feature/m7-post-permissions`
   - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%.
 
-- [ ] **COMMIT (Owner: Luis | Group: POST.safety | Branch: feature/m7-post-safety) - Commit message: "feat(security): add safety profile enforcement"**
+- [ ] **COMMIT (Owner: Luis | Group: POST.safety | Branch: feature/m7-post-safety | Planned: Day 40 | Expected: Day 45) - Commit message: "feat(security): add safety profile enforcement"**
   - [ ] Git [Luis]: `git checkout master`
   - [ ] Git [Luis]: `git pull origin master`
   - [ ] Git [Luis]: `git checkout -b feature/m7-post-safety`