diff --git a/implementation_plan.md b/implementation_plan.md index a348c00f5..385d522b4 100644 --- a/implementation_plan.md +++ b/implementation_plan.md @@ -26,21 +26,19 @@ - **Immediate documentation loop**: After completing any amount of work toward a checklist item, append the newly discovered information, assumptions, implementation notes, and open questions to this document before proceeding. No discovery, decision, or workaround may remain undocumented. - **Dynamic checklist maintenance**: Before marking an item complete—or returning from work in progress—review all remaining checklist entries. Update their descriptions, add clarifying subtasks, and insert new entries capturing follow-on tasks, bug fixes, or future enhancements uncovered during implementation. Place new items in the phase where the work logically belongs (current or future) and note cross-phase dependencies. - **Implementation traceability**: Record substantive code decisions (design pattern choices, module ownership, testing strategy, risk mitigations) back into the corresponding Notes section and checklist subtasks immediately after each coding/testing session. -- **Checklist integrity**: Never remove checklist items unless they are explicitly retired with documented reasoning. Mark completed work by checking the item(s) and append new tasks or restructuring bullets only when required—preserve original wording for historical traceability. +- **Checklist integrity**: Mark completed work by checking the item(s) and append new tasks or restructure bullets only when required or explicitly told to do so. - **Enforcement**: Treat omissions as blocking bugs—if the plan falls out of sync with reality, halt work, reconcile the discrepancy here, and only then continue. ## Guiding Principles -- Keep `docs/specification.md` as the single source of truth; this plan sequences work only and stays minimal. -- Local mode is the only supported execution target through Day 30; server connectivity is stub-only (interfaces raising `NotImplementedError`) after M6. -- Implement the plan lifecycle exactly: Strategize (read-only) → Execute (sandboxed) → Apply (validation-gated merge) → applied. -- Use namespaced identifiers for actions, actors, tools, skills, projects, and automation profiles; use ULIDs only for plans, decisions, resources, and validation attachments. -- Resource-first architecture: Resource Types define physical/virtual resources, DAG constraints, and sandbox strategy; registries persist Resources, Tools, Skills, Actors, Providers, and Validations. -- Tool runtime owns mutation: tool lifecycle (discover/activate/execute/deactivate), resource binding resolution, and ChangeSet tracking drive apply/rollback. -- Decision trees and invariants are first-class; correction recomputes only affected subtrees; the Invariant Reconciliation Actor runs before strategize. -- Deliver ACMS v1 in local mode by M6 (UKO + CRP + Context Assembly Pipeline); keep details in the spec, not here. -- Configuration-first YAML for actions, actors, tools, skills, resource types, validations, and automation profiles with `${ENV_VAR}` interpolation. -- Enforce strict typing and quality gates via `nox` (Behave + Robot + ASV) with coverage >=97%. +- 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. +- 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. +- ACMS v1 (UKO + CRP + Context Assembly Pipeline) is the M6 target; details remain in the spec. ### Core Architectural Requirements @@ -48,9 +46,9 @@ **Reliability**: Sandboxed execution, tool-based change tracking, validation-gated apply, and checkpoints per spec. -**Autonomy with Control**: Decision-tree recording, invariants, automation profiles, and correction flows per spec. +**Autonomy with Control**: Decision-tree recording, invariants + reconciliation, automation profiles, and correction flows per spec. -**Registry-First**: Resource/Tool/Skill/Actor/Validation registries with namespaced IDs and spec-aligned lifecycles. +**Interop**: MCP + Agent Skills Standard tool sources supported via tool/skill abstraction (local mode). ### Continuous Testing and Documentation Policy - Do not mark any parent checklist item complete until **all** subordinate Code, Document, Tests tasks and any generated `Fix - ...` tasks are resolved and the associated Notes section has the latest context. @@ -199,14 +197,14 @@ The following work from the previous implementation has been completed and will - `agents [--data-dir PATH] [--config-path PATH] action create` - Create new action with strategy/execution actors, definition of done, arguments - `agents [--data-dir PATH] [--config-path PATH] action list` - List actions with filtering by namespace, state - `agents [--data-dir PATH] [--config-path PATH] action show` - Show action details by ID or name - - `agents [--data-dir PATH] [--config-path PATH] action available` - Make draft action available for use + - `agents [--data-dir PATH] [--config-path PATH] action available` - Make draft action available for use (legacy; draft state removed in spec rebaseline) - `agents [--data-dir PATH] [--config-path PATH] action archive` - Archive an action (soft delete) - Extended `src/cleveragents/cli/commands/plan.py` with v3 lifecycle commands: - `agents [--data-dir PATH] [--config-path PATH] plan use ` - Use action to create plan in Strategize phase (legacy `--project` retained in old notes) - `agents [--data-dir PATH] [--config-path PATH] plan execute [plan_id]` - Transition plan from Strategize to Execute - `agents [--data-dir PATH] [--config-path PATH] plan apply [plan_id]` - Transition plan from Execute to Apply - `agents [--data-dir PATH] [--config-path PATH] plan status [plan_id]` - Show v3 plan status and details - - `agents [--data-dir PATH] [--config-path PATH] plan list [--phase ] [--state ] [--project ] [--action ]` - List v3 lifecycle plans with filtering + - `agents [--data-dir PATH] [--config-path PATH] plan list [--phase ] [--state ] [--project ] [--action ]` - List v3 lifecycle plans with filtering (legacy `--state`; use `--processing-state` in spec rebaseline) - `agents [--data-dir PATH] [--config-path PATH] plan cancel ` - Cancel a non-terminal plan - Registered action commands in CLI main.py - Added 15 Behave test scenarios in `features/action_cli.feature` @@ -490,6 +488,24 @@ The following work from the previous implementation has been completed and will - **Root cause**: Three `python -c` inline scripts used `sys.path.insert(0, '/app/src')` to import `cleveragents`. This path is only valid locally (`/app`), not on CI (`/workspace/cleveragents/cleveragents-core`). Since the venv Python (now injected via `${PYTHON}`) already has `cleveragents` installed via `pip install -e .[tests]`, the `sys.path.insert` is unnecessary. - **Fix** (`robot/system_prompt_template_rendering.robot`): Removed `import sys; sys.path.insert(0, '/app/src');` from all 3 inline Python code strings. - **Additional fix**: Added trailing newline to `robot/common.resource` (was missing, defensive fix). + +**2026-02-13**: Plan Update - Rebaseline A5 Persistence Checklist + +- Rewrote A5 plan persistence checklist to replace legacy A5.alpha/beta/beta2 tasks with spec-aligned rebaseline migrations, ORM mappings, repositories, and persistence tests (namespaced action IDs, no draft state, plan apply/applied phases, ordered arguments/invariants). +**2026-02-13**: Plan Update - A5 Ownership + Validation Attachments + - Reassigned A5.alpha migrations to Hamza to align DB/migration expertise and reduce critical-path overload on Jeff. + - Rebased tool registry tasks to make validation attachments explicitly resource-scoped with required/informational mode at persistence + CLI layers. +**2026-02-13**: Plan Update - Consolidate Skills/Actors/MCP + B0 DB Ownership + - Retired duplicate C2 skills, C3 schema/compiler/builtins, and C4 MCP blocks; canonical tasks now live under C0.skill, C1/C2 actor schema+loader/compiler, C7.mcp, and C8.providers, with MCP config examples folded into C7.mcp. + - Reassigned B0.db resource/project migrations to Hamza to align DB ownership with A5.alpha. +**2026-02-13**: Plan Update - Tool Runtime Naming Consolidation + - Renamed M1 tool runtime block to C0 runtime core and M3 lifecycle block to C0.lifecycle to avoid duplicate group naming. +**2026-02-13**: Plan Update - Spec Alignment Pass + - Updated A4b CLI rebaseline to use `processing_state` terminology and `--processing-state` filter. + - Corrected skill registry dependency references (C0.skill depends on C1.tool.domain/C1.tool.registry; Section 17 uses C1.tool.registry). + - Added legacy note for pre-spec A5.3 ORM details to avoid confusion with rebaseline schema. +**2026-02-13**: Plan Update - C1 Numbering Disambiguation + - Renamed tool registry group to C1.tool to avoid collision with actor schema C1 group; updated dependency references accordingly. - **CI debug output added** (`noxfile.py`): Comprehensive pre-robot debug block now prints: `sys.executable`, `shutil.which('python')`, full `PATH`, `os.path.exists/isfile/islink/stat` for both `.resource` files, first 100 bytes of each, fixture directory existence checks (`features/fixtures/v2/*`), and Robot Framework version. This will definitively diagnose any remaining resource import issues on the next CI run. - **Verification**: `nox -s integration_tests` passes locally — 204 tests, 204 passed, 0 failed. @@ -578,6 +594,7 @@ The following work from the previous implementation has been completed and will - Self-referential parent_plan relationship, relationship to LifecycleActionModel - Used `__allow_unmapped__ = True` on both models to work with `from __future__ import annotations` and the legacy declarative style - Updated `src/cleveragents/infrastructure/database/__init__.py` to export both new models +- **Legacy note**: These v3 ORM models use `action_id`/`project_ids` and draft-style fields; they are superseded by the A5 rebaseline to namespaced action IDs, project_links, and spec-aligned enums. **2026-02-09**: Stage B3.1 + B3.2 + B3.5 + B3.6 + B3.7 + B3.8 Complete - Sandbox Infrastructure (Luis's tasks) - Created `src/cleveragents/infrastructure/sandbox/` package with 6 modules: @@ -786,24 +803,22 @@ The following work from the previous implementation has been completed and will | Milestone | Target Date | Description | |-----------|-------------|-------------| -| **M0: Foundation** | 2026-02-11 (Day 0) | Preserve existing LangGraph infrastructure and tooling baseline. | -| **M1: Local Source Code MVP** | 2026-02-18 (Day 7) | Action YAML -> plan use -> strategize/execute/apply with sandboxed, tool-based change tracking on source code only. | -| **M2: Projects & Resources** | 2026-02-21 (Day 10) | Resource/project registries + CLI, git-checkout + fs-directory support, local sandbox strategies. | -| **M3: Actors, Tools, Skills, Validations** | 2026-02-25 (Day 14) | Actor YAML + compilation, tool/skill/validation registries, built-in file/search/git tools, MCP adapter (local). | -| **M4: Decisions & Invariants** | 2026-03-04 (Day 21) | Decision recording + correction, invariants + automation profiles, plan tree/explain/correct CLI. | -| **M5: Subplans & Parallelism** | 2026-03-08 (Day 25) | Subplan spawning, parallel execution, merge strategies, multi-project support. | -| **M6: Large Project Autonomy** | 2026-03-13 (Day 30) | ACMS v1 (local), deep subplans, autonomous large-project workflows. | -| **M7: Server Stubs (Client Only)** | 2026-03-18 (Day 35) | Client-side server stubs only (no server implementation in this project). | -| **M8: UX & Rendering** | 2026-03-23 (Day 40) | Output rendering formats, UX polish, remaining spec items. | +| **M0: Foundation** | 2026-02-09 (Day 1) | Preserve existing LangGraph infrastructure and tooling baseline. | +| **M1: Local Source Code MVP** | 2026-02-15 (Day 7) | Action YAML -> plan use/execute/apply in local mode with git-checkout resources, sandboxed tool-based ChangeSet, and validation-gated Apply (source code only). | +| **M2: Projects & Resources** | 2026-02-18 (Day 10) | Resource types + resource DAG + project linking CLI; git-checkout + fs-mount support; local sandbox strategies. | +| **M3: Actors, Tools, Skills, Validations** | 2026-02-22 (Day 14) | Actor YAML compilation, tool/skill/validation registries, built-in file/search/git tools, MCP adapter (local). | +| **M4: Decisions & Invariants** | 2026-03-01 (Day 21) | Decision recording + correction flows, invariants + automation profiles, plan tree/explain/correct CLI. | +| **M5: Subplans & Parallelism** | 2026-03-05 (Day 25) | Subplan spawning, parallel execution, merge strategies, multi-project support. | +| **M6: Large Project Autonomy** | 2026-03-10 (Day 30) | ACMS v1 (local) + deep subplans + autonomous large-project workflows. | +| **M7: Server Stubs (Client Only)** | 2026-03-15 (Day 35) | Client-side server stubs only (no server implementation in this project). | +| **M8: UX & Rendering** | 2026-03-20 (Day 40) | Output rendering formats, UX polish, remaining spec items. | ### Critical Path to 7-Day MVP (Source Code Only) -**WEEK 1 GOAL**: A minimally usable application that can: -1. Register an action from YAML via `agents action create --config ` (namespaced name, description, definition_of_done, actors, args, invariants, optional automation profile). -2. Create a project and link a local `git-checkout` resource via `agents project create --resource ` + `agents resource add git-checkout --path ` + `agents project link-resource `. -3. Use the action on one or more projects via `agents plan use [--automation-profile ...] [--invariant ...] [--arg name=value] ...` (Strategize phase). -4. Execute in a per-plan sandbox (git_worktree for git-checkout resources) via `agents plan execute ` with tool-based change tracking. -5. Apply sandbox changes via `agents plan apply [--yes] ` after required validations (if any) pass. +**WEEK 1 GOAL**: A minimally usable local-mode flow (source code only) that can: +1. Register an action from YAML via `agents action create --config ` (config-only). +2. Register a local `git-checkout` resource and link it to a project (`agents resource add` + `agents project link-resource`). +3. Use and run a plan end-to-end (`agents plan use` → `plan execute` → `plan apply`) with git_worktree sandbox + tool-based ChangeSet capture. Detailed tasks, ownership, and sequencing live in the Implementation Checklist (Sections 3-6). @@ -858,21 +873,7 @@ nox -s docs # Build documentation - `examples/validations/` - Example validation YAML config files ### CLI Command Groups (spec-defined) -``` -agents version | info | diagnostics | init -agents session create | list | show | delete | export | import | tell -agents project create | link-resource | unlink-resource | list | show | delete | context (set|show|inspect|simulate) -agents validation add | attach | detach -agents actor run | add | remove | list | show | context (remove|list|show|export|import|clear) -agents skill add | remove | list | show | tools -agents tool add | remove | list | show -agents resource type (add|remove|list|show) | add | remove | list | show | inspect | tree | link-child | unlink-child -agents plan list | use | execute | apply | status | cancel | tree | explain | correct | diff | artifacts | prompt | rollback -agents action create | list | show | archive -agents automation-profile add | remove | list | show -agents config set | get | list -agents invariant add | list | remove -``` +The canonical CLI command set (syntax, flags, and output formats) lives in `docs/specification.md`. This plan only references it; do not duplicate command definitions here. ### Environment Variables (CLEVERAGENTS_* only) ```bash @@ -887,56 +888,82 @@ CLEVERAGENTS_TEST_MODE=true ## Schedule Adhereance -### 2026-02-12 (Day 2 since kickoff on 2026-02-11) -- Timeline reference: Day 7/M1 = 2026-02-18, Day 10/M2 = 2026-02-21, Day 14/M3 = 2026-02-25, Day 21/M4 = 2026-03-04, Day 25/M5 = 2026-03-08, Day 30/M6 = 2026-03-13, Day 35/M7 = 2026-03-18. -- Snapshot (Team Status | Overall Risk | Pace Notes): **Behind ~8-10 days** | Overall risk = HIGH | Pre-rebaseline pacing, server scope still in queue, Rui unavailable through 2026-02-27. +### 2026-02-12 (Day 4 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 ~8-10d | HIGH | Action/plan model alignment done; persistence wiring, CLI rebaseline, resource registry, and tool runtime missing. - Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-18) -> ETA 2026-02-26 | +8d | HIGH - - M2 (2026-02-21) -> ETA 2026-03-02 | +9d | HIGH - - M3 (2026-02-25) -> ETA 2026-03-09 | +12d | MED-HIGH - - M4 (2026-03-04) -> ETA 2026-03-18 | +14d | MED-HIGH - - M5 (2026-03-08) -> ETA 2026-03-23 | +15d | MEDIUM - - M6 (2026-03-13) -> ETA 2026-03-31 | +18d | MEDIUM + - M1 (2026-02-15) -> ETA 2026-02-22 | +7d | HIGH + - M2 (2026-02-18) -> ETA 2026-02-25 | +7d | HIGH + - M3 (2026-02-22) -> ETA 2026-03-01 | +7d | HIGH + - M4 (2026-03-01) -> ETA 2026-03-07 | +6d | MED-HIGH + - M5 (2026-03-05) -> ETA 2026-03-10 | +5d | MEDIUM + - M6 (2026-03-10) -> ETA 2026-03-15 | +5d | MEDIUM - Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~6-8d | ETA M1+ | HIGH | action/plan alignment + persistence wiring - - Track B (Projects/resources + sandbox) | not started | ETA M2+ | HIGH | resource registry + sandbox strategies missing - - Track C (Actors/tools/skills/validations) | not started | ETA M3+ | HIGH | registries + actor YAML missing - - Track D (Change tracking + apply pipeline) | not started | ETA M1+ | HIGH | tool runtime + change tracking absent - - Track Q (Quality automation) | ahead | ETA on-time | LOW | gates landed, only maintenance adjustments - - Track T (Testing) | at risk (Rui out) | ETA slips 4-6d | HIGH | QA load on Brent/Jeff until Rui returns + - Track A (Plan lifecycle + persistence) | behind ~8-10d | ETA 2026-02-22 | HIGH | repository wiring + CLI rebaseline + - Track B (Projects/resources + sandbox) | behind ~9-11d | ETA 2026-02-25 | HIGH | resource registry + git_worktree integration + - Track C (Actors/tools/skills/validations) | behind ~9-11d | ETA 2026-03-01 | HIGH | tool/validation registry + actor YAML runtime + - Track D (Change tracking + apply pipeline) | behind ~8-10d | ETA 2026-02-25 | HIGH | ChangeSet capture + apply gating + - 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 | CLI rebaseline + tool router + execute/apply integration - - Luis | available | high | MEDIUM | persistence + sandbox/change tracking - - Hamza | available | high | HIGH | resource registry + project linking - - Aditya | available | medium | MEDIUM | actor YAML + skill config - - Brent | available | high (QA pickup) | MED-HIGH | tests + nox verification for M1/M2 - - Rui | unavailable 2026-02-13 to 2026-02-27 | zero | HIGH | tasks reassigned; resume after 2026-02-27 + - Jeff | available | critical-path overloaded | HIGH | lifecycle persistence + tool runtime + CLI rebaseline + - Luis | available | high | MEDIUM | repositories + apply pipeline + - Hamza | available | high | HIGH | resource registry + sandbox strategies + - Aditya | available | medium | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs + - Brent | available | high (QA load) | MED-HIGH | test coverage + integration stability + - Rui | unavailable 2026-02-13 to 2026-02-27 | zero | HIGH | tests deferred until return - Mike/Brian | standby | low | LOW | none -### 2026-02-13 (Day 3 since kickoff on 2026-02-11) -- Timeline reference: Day 7/M1 = 2026-02-18, Day 10/M2 = 2026-02-21, Day 14/M3 = 2026-02-25, Day 21/M4 = 2026-03-04, Day 25/M5 = 2026-03-08, Day 30/M6 = 2026-03-13, Day 35/M7 = 2026-03-18. -- Snapshot (Team Status | Overall Risk | Pace Notes): **Behind ~4-6 days** | Overall risk = HIGH | CI rebaseline to Hatch + nox confirmed; M2 resource scope trimmed to git-checkout + fs-mount + fs-directory/file; local-only MVP confirmed. +### 2026-02-13 (Day 5 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 ~7-9d | HIGH | Spec-aligned action/plan models + migrations landed; resource/project domain models present; persistence wiring, CLI rebaseline, tool runtime, and apply pipeline still missing. - Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-18) -> ETA 2026-02-22 | +4d | HIGH - - M2 (2026-02-21) -> ETA 2026-02-27 | +6d | HIGH - - M3 (2026-02-25) -> ETA 2026-03-07 | +10d | MED-HIGH - - M4 (2026-03-04) -> ETA 2026-03-17 | +13d | MED-HIGH - - M5 (2026-03-08) -> ETA 2026-03-23 | +15d | MEDIUM - - M6 (2026-03-13) -> ETA 2026-03-31 | +18d | MEDIUM + - 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-01 | +7d | HIGH + - M4 (2026-03-01) -> ETA 2026-03-07 | +6d | MED-HIGH + - M5 (2026-03-05) -> ETA 2026-03-10 | +5d | MEDIUM + - M6 (2026-03-10) -> ETA 2026-03-15 | +5d | MEDIUM - Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~3-5d | ETA M1+4 | HIGH | action model rebaseline + repo/persistence wiring - - Track B (Projects/resources + sandbox) | behind ~6-8d | ETA M2+6 | HIGH | resource registry + git_worktree sandbox - - Track C (Actors/tools/skills/validations) | behind ~7-10d | ETA M3+10 | MED-HIGH | tool/skill/validation registries + actor YAML v3 - - Track D (Change tracking + apply pipeline) | behind ~6-9d | ETA M1+7 | HIGH | tool runtime + changeset + apply gating - - Track Q (Quality automation) | slightly behind | ETA M1+2 | MED | CI not yet nox/Hatch aligned; coverage gate mismatch - - Track T (Testing) | at risk (Rui out) | ETA slips 4-6d | HIGH | QA load on Brent + feature owners + - Track A (Plan lifecycle + persistence) | behind ~6-8d | ETA 2026-02-20 | HIGH | repo wiring + CLI rebaseline + legacy removal + - Track B (Projects/resources + sandbox) | behind ~7-9d | ETA 2026-02-24 | HIGH | resource registry + git_worktree integration + - Track C (Actors/tools/skills/validations) | behind ~8-10d | ETA 2026-03-01 | HIGH | tool/validation registry + actor YAML runtime + - Track D (Change tracking + apply pipeline) | behind ~7-9d | ETA 2026-02-24 | HIGH | ChangeSet capture + apply gating + - 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 | action model rebaseline, CLI rebaseline, tool runtime + execute/apply integration - - Luis | available | high | MEDIUM | persistence wiring + sandbox strategy + apply pipeline - - Hamza | available | high | HIGH | resource registry + project linking + resource type schemas - - Aditya | available | medium | MEDIUM | actor/skill YAML + hierarchical graph configs - - Brent | available | high (QA + CI) | MED-HIGH | CLI coverage + nox/CI alignment + integration tests - - Rui | unavailable 2026-02-13 to 2026-02-27 | zero | HIGH | testing tasks deferred or reassigned + - Jeff | available | critical-path overloaded | HIGH | lifecycle persistence + tool runtime + CLI rebaseline + - Luis | available | high | MEDIUM | repositories + apply pipeline + - Hamza | available | high | HIGH | resource registry + sandbox strategies + RDF groundwork + - Aditya | available | medium | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs + - 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 + +### 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. +- 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 +- 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 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 + - 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 ## Implementation Checklist @@ -951,6 +978,8 @@ Execute all required tests through the appropriate `nox` sessions—never call ` **Commit Completion Rule**: A **COMMIT** item is checked only after every subtask is complete, `nox` has passed, coverage is verified >=97%, and `git commit -m ""` (using the commit message in the COMMIT header) has been executed. +**Commit Coverage Ordering Rule**: The **last** subtask in every **COMMIT** block must be the full coverage verification line (the one that starts with `Quality [Owner]: Verify coverage >=97% via ...`). Do not place any other tasks after it. + **Gitflow Standard (required for every COMMIT item)**: - Every **COMMIT** block must include explicit Git subtasks with the exact commands for: checkout master, pull master, create/checkout the feature branch, merge `origin/master` into the branch before final tests, `git add .`, and `git commit -m ""`. - Do **not** list Git command tasks outside a **COMMIT** block; any Git command must be a child of the owning **COMMIT** item. @@ -965,12 +994,12 @@ Execute all required tests through the appropriate `nox` sessions—never call ` | Developer | Strengths | Assignment Focus | Availability | |-----------|-----------|------------------|--------------| -| **Jeff** | CTO, fastest developer, expert in everything | Critical path blockers, architecture, complex integrations, decision correction, unblocking others | PRIMARY - Available for all critical work | -| **Aditya** | Domain expert (agents/LLMs), understands hierarchical configs | Actor YAML configurations, hierarchical actor graphs, strategy/execution actors, MCP integration | HIGH - Primary on actor/skill work | -| **Rui** | Fastest developer, new to Python | Testing (Behave/Robot), simple implementations, CLI scaffolding, test fixtures (post-2026-02-27) | UNAVAILABLE 2026-02-13 to 2026-02-27; resumes after | -| **Brent** | Slow but detail-oriented | Days 1-3: Automated quality gates; Days 4-8: QA + test coverage pickup; After Day 8: Validation testing | CONTINUOUS - Independent QA track | -| **Hamza** | RDF expert, Python proficient, no LLM experience | Projects, resources, sandbox, database infrastructure, decision models, context indexing | HIGH - Infrastructure lead | -| **Luis** | Best Python architect, pedantic | Algorithms, state machines, service layer architecture, change tracking, validation pipelines | HIGH - Architecture/service layer | +| **Jeff** | CTO, fastest developer, expert in everything | Critical path blockers, tool runtime, execute/apply integration, decision correction, CLI rebaseline, automation profiles | PRIMARY - Available for all critical work | +| **Aditya** | Domain expert (agents/LLMs), understands hierarchical configs | Actor YAML + skill/tool schema configs, hierarchical actor graphs, MCP adapter, action YAML schema | HIGH - Primary on config/actor work | +| **Rui** | Fastest developer, new to Python | Behave/Robot tests, fixtures, simple CLI scaffolding (post-2026-02-27) | UNAVAILABLE 2026-02-13 to 2026-02-27; resumes after | +| **Brent** | Slow but detail-oriented | QA gates, coverage hardening, integration suite stability, documentation verification | CONTINUOUS - Independent QA track | +| **Hamza** | RDF expert, Python proficient, no LLM experience | Resource registry, sandbox strategies, database migrations, UKO/RDF groundwork | HIGH - Infrastructure lead | +| **Luis** | Best Python architect, pedantic | Persistence, repositories, decision/validation pipelines, execution state machines | HIGH - Architecture/service layer | | **Mike/Brian** | Sysadmins | Deployment only (minimal coding tasks) | LOW - Only deployment tasks | ### Work Assignment Philosophy @@ -979,20 +1008,21 @@ Execute all required tests through the appropriate `nox` sessions—never call ` - Any task that is blocking other developers - Complex integrations requiring deep architectural understanding - Decision correction mechanism (critical for 30-day goal) -- Skill execution framework (core to MVP) +- Tool runtime and execute/apply pipeline (core to MVP) - Performance-critical code paths - Final review of all architectural decisions ### Jeff's Critical Path Task Summary (Day-by-Day) -- Day 1-3: A2b/A4b rebaseline (action/plan domain + CLI), tool registry bootstrap, unblock persistence wiring. -- Day 4-7: Tool router + sandbox integration, plan execute/apply end-to-end, MVP integration gating. -- Day 15-21: Decision correction core algorithm + plan tree/explain/correct CLI integration. -- Day 22-30: Large-project autonomy integration (subplans + ACMS v1 + performance tuning). +- Day 1-3: A2b/A4b rebaseline (action/plan domain + CLI), persistence wiring, unblock resource registry. +- Day 4-7: Tool runtime + ChangeSet capture, sandbox integration, plan execute/apply end-to-end. +- Day 8-14: Decision tree recording + invariants + automation profiles + plan tree/explain/correct CLI. +- Day 15-21: Subplan orchestration + merge strategies + multi-project parallelism. +- Day 22-30: Large-project autonomy integration (ACMS v1 + performance tuning). **BLOCKING CHAIN**: If Jeff is unavailable, the following chains stall: - A5.alpha → A5.beta → A5.gamma → Plan persistence (Day 1-2) -- C3.protocol → C3.context → C4.file → Skill execution (Day 3-6) +- C0.runtime → C0.files → D1.execute/apply (Day 3-7) - D4.revert → D4.append → Decision correction (Day 15-18) **Aditya** should be assigned to: @@ -1038,10 +1068,10 @@ Execute all required tests through the appropriate `nox` sessions—never call ` | Milestone | Day | Goal | Success Criteria | |-----------|-----|------|------------------| -| **M1: MVP** | Day 7 | Action YAML -> plan use -> execute in sandbox -> apply (source code only) | `agents [--data-dir PATH] [--config-path PATH] action create --config` + `agents [--data-dir PATH] [--config-path PATH] plan use ` + `agents [--data-dir PATH] [--config-path PATH] plan execute` + `agents [--data-dir PATH] [--config-path PATH] plan apply` working end-to-end on a git repository with sandboxed execution | -| **M2: Projects & Resources** | Day 10 | Project/resource registry + CLI with git worktree sandbox | `agents project create` + `agents resource add git-checkout` + `agents project link-resource` working with git worktree isolation | -| **M3: Actors, Tools, Skills, Validations** | Day 14 | Actor YAML compiled -> tool/skill/validation registries -> tool-based ChangeSet | Actor YAML parsed -> LangGraph compiled -> Tools executed -> Validations passing -> Applied | -| **M4: Decisions & Invariants** | Day 21 | Decision recording + correction + invariants + automation profiles | `agents plan tree` + `agents plan explain` + `agents plan correct` + `agents invariant add/list` | +| **M1: MVP (Local, Source Code Only)** | Day 7 | Action YAML -> plan use -> strategize/execute/apply in git worktree sandbox | `agents action create --config ` + `agents project create ` + `agents resource add git-checkout --path ` + `agents project link-resource ` + `agents plan use ` + `agents plan execute ` + `agents plan apply ` end-to-end on a local git repo | +| **M2: Projects & Resources** | Day 10 | Project/resource registry + DAG + sandbox strategies | `agents resource type add` + `agents resource add` + `agents resource tree/inspect` + `agents project link-resource/unlink-resource` working with git_worktree isolation | +| **M3: Actors, Tools, Skills, Validations** | Day 14 | Actor YAML compiled -> tool/skill/validation registries -> tool-based ChangeSet | `agents actor add` + `agents skill add` + `agents tool add` + `agents validation attach` drive tool execution and validation-gated apply | +| **M4: Decisions & Invariants** | Day 21 | Decision recording + correction + invariants + automation profiles | `agents plan tree` + `agents plan explain` + `agents plan correct` + `agents invariant add/list` + `agents automation-profile list` | | **M5: Subplans & Parallelism** | Day 25 | Hierarchical subplans with parallel execution and merging | Parent plan spawns 5+ subplans -> Parallel execution -> Three-way merge -> Validations pass | | **M6: Large Projects** | Day 30 | ACMS v1 + large-project autonomy | Port a 500-file codebase using hierarchical subplans + decision correction | | **Server Connectivity** | Beyond Day 30 | Client interfaces for server communication; server developed independently | Client-to-server API abstractions defined, but local execution only; no server implementation in this project | @@ -1068,26 +1098,28 @@ The following Section 8 (Server Connectivity) items are explicitly **OUT OF SCOP Critical path chains (authoritative tasks live in the checklist sections): -- Chain A (M1): A2b (action/plan rebaseline) → A4b (CLI rebaseline) → A5 (persistence) → A5.legacy (remove legacy plan path) → M1 acceptance. -- Chain B (M2): B1 (resource/project domain + built-ins) → B1/B2 persistence → B3 CLI → B4 sandbox strategies. -- Chain C (M3): C1/C2 actor YAML + loader → tool/skill/validation registries → C5 router/change tracking → C9 execute/apply integration. -- Chain D (M4+): D1/D2 decision model + recording → D4 correction → E1/E2 subplans → ACMS v1 (G-series). +- Chain A (M1): Action/Plan persistence → CLI rebaseline → Resource registry + git_worktree sandbox → Tool runtime + ChangeSet capture → Apply pipeline → M1 acceptance. +- Chain B (M2): Resource DAG + additional types → resource inspect/tree → project context commands. +- Chain C (M3): Tool/Validation registry → skill registry → actor YAML runtime → binding + validation gating → execute/apply integration. +- Chain D (M4): Decisions + invariants + automation profiles → correction flows → plan diagnostics. +- Chain E (M5): Subplan orchestration → parallel execution → merge strategies. +- Chain F (M6): ACMS pipeline (UKO/CRP/context strategies) → large-project autonomy. ### Parallel Workstream Allocation Current parallel tracks (see Sections 3-6 for detailed checklists): -- Track A: Plan lifecycle + persistence (Jeff/Luis). +- Track A: Plan lifecycle + persistence + CLI (Jeff/Luis). - Track B: Projects/resources + sandbox (Hamza). -- Track C: Actors/tools/skills/validations (Aditya/Jeff). -- Track D: Change tracking + apply/validation integration (Luis/Jeff). +- Track C: Actors/tools/skills/validations (Aditya/Jeff/Luis). +- Track D: Execution pipeline + apply/decisions/invariants (Jeff/Luis/Hamza). - Track Q: Quality automation (Brent). - Track T: Testing (Brent through 2026-02-27; Rui after). ### Coordination Checkpoints (Milestone-Level) -- M1: Action YAML → plan use → execute → apply works end-to-end in local mode with sandboxed tool changes and `nox` green. -- M3: Actor YAML compiles, tool/skill/validation registries functional, tool router produces ChangeSet, apply succeeds. +- M1: Action YAML → project/resource link → plan use → execute → apply works end-to-end in local mode with git_worktree sandbox and `nox` green. +- M3: Actor YAML compiles, tool/skill/validation registries functional, tool execution produces ChangeSet, validation-gated apply succeeds. - M4: Decision tree recorded; plan tree/explain/correct works; invariants + automation profiles enforced. - M6: ACMS v1 + deep subplans supports large-project autonomy (local mode). @@ -1114,7 +1146,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil **Parallel Group Q0-Minimum Gates [Brent - blocks merges]** -- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-precommit) - Commit message: "feat(qa): add pre-commit baseline hooks"** - done on 2026-02-12 07:21:52 +0000 +- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-precommit | Done: Day 2, February 10, 2026 00:01:51 +0000) - Commit message: "feat(qa): add pre-commit baseline hooks"** - [X] Git [Brent]: `git checkout master` - [X] Git [Brent]: `git pull origin master` - [X] Git [Brent]: `git checkout -b feature/q0-min-precommit` @@ -1127,112 +1159,57 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Docs [Brent]: Update `CONTRIBUTING.md` with pre-commit install + run steps (no helper scripts). - [X] Tests (Behave) [Brent]: Add scenarios in `features/quality_automation.feature` that parse `.pre-commit-config.yaml`, assert required hooks are present, and verify pinned versions. - [X] Tests (Robot) [Brent]: Add `robot/quality_automation.robot` that runs `nox -s lint` and asserts zero failures. - - [X] Tests (ASV) [Brent]: Add `asv/benchmarks/precommit_config_bench.py` to benchmark config parsing and hook list extraction. + - [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] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. - [X] Git [Brent]: `git add .` - [X] Commit [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` + - [X] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. -- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-ci) - Commit message: "feat(ci): add nox-based PR validation workflow"** +- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-ci | Done: Day 4, February 12, 2026 22:01:51 +0000) - Commit message: "feat(ci): add nox-based PR validation workflow"** - [X] Git [Brent]: `git checkout master` - [X] Git [Brent]: `git pull origin master` - [X] Git [Brent]: `git checkout -b feature/q0-min-ci` - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Update `.forgejo/workflows/ci.yml` to install dependencies via Hatch and run `nox` (unit + integration + typecheck + lint + coverage_report); do not add GitHub workflows. - done on 2026-02-12 - - [X] Code [Brent]: Ensure CI uses Python 3.13, caches pip/Hatch artifacts, and uploads `nox` logs on failure. - done on 2026-02-12 - - [X] Code [Brent]: Fail pipeline if any `nox` session fails or coverage <97% (explicit coverage gate). - done on 2026-02-12 - - [X] Docs [Brent]: Add CI usage notes in `docs/development/ci-cd.md`, including local repro commands and cache notes. - done on 2026-02-12 - - [X] Tests (Behave) [Brent]: Add a scenario that validates the workflow file exists and references required `nox` sessions. - done on 2026-02-12 (features/ci_workflow_validation.feature, 11 scenarios) - - [X] Tests (Robot) [Brent]: Add a Robot smoke test that runs the same `nox` session matrix locally and asserts zero failures. - done on 2026-02-12 (robot/ci_nox_validation.robot) - - [X] Tests (ASV) [Brent]: Add `asv/benchmarks/ci_yaml_parse_bench.py` to benchmark workflow parsing and key lookup. - done on 2026-02-12 (benchmarks/ci_yaml_parse_bench.py) - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - done on 2026-02-12 (1673 scenarios passed, 0 failed) - - [X] 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%. - done on 2026-02-12 (97% total, fail-under=97 passes) + - [X] Code [Brent]: Update `.forgejo/workflows/ci.yml` to install dependencies via Hatch and run `nox` (unit + integration + typecheck + lint + coverage_report); do not add GitHub workflows. + - [X] Code [Brent]: Ensure CI uses Python 3.13, caches pip/Hatch artifacts, and uploads `nox` logs on failure. + - [X] Code [Brent]: Fail pipeline if any `nox` session fails or coverage <97% (explicit coverage gate). + - [X] Docs [Brent]: Add CI usage notes in `docs/development/ci-cd.md`, including local repro commands and cache notes. + - [X] Tests (Behave) [Brent]: Add a scenario that validates the workflow file exists and references required `nox` sessions. (features/ci_workflow_validation.feature, 11 scenarios) + - [X] Tests (Robot) [Brent]: Add a Robot smoke test that runs the same `nox` session matrix locally and asserts zero failures. (robot/ci_nox_validation.robot) + - [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] 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` + - [X] 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%. (97% total, fail-under=97 passes) -- [ ] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-coverage) - Commit message: "feat(qa): enforce coverage >=97% in CI"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/q0-min-coverage` - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Brent]: Ensure `nox -s coverage_report` fails below 97% and emits a single-line error message suitable for CI parsing. - - [ ] Code [Brent]: Update CI summary output (or job annotations) to surface the 97% threshold failure line clearly. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with the 97% coverage requirement and a sample failure output. - - [ ] Tests (Behave) [Brent]: Add a scenario that parses coverage config and asserts threshold >=97%. - - [ ] Tests (Robot) [Brent]: Add a Robot test that runs `nox -s coverage_report` and asserts pass/fail behavior. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/coverage_report_bench.py` for coverage report runtime baseline. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Brent]: `git add .` (only after coverage check passes) - - [ ] Git [Brent]: `git commit -m "feat(qa): enforce coverage >=97% in CI"` (only after coverage check passes) - - [ ] Forgejo PR [Brent]: Open PR from `feature/q0-min-coverage` to `master` with description "Enforce 97% coverage via nox coverage_report with explicit CI summary output and updated docs/tests.". - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git branch -d feature/q0-min-coverage` - - [ ] 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%. +- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-coverage | Done: Day 4, February 12, 2026 18:53:25 -0500) - Commit message: "feat(qa): enforce coverage >=97% in CI"** + - [X] Git [Brent]: `git checkout master` + - [X] Git [Brent]: `git pull origin master` + - [X] Git [Brent]: `git checkout -b feature/q0-min-coverage` + - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Brent]: Ensure `nox -s coverage_report` fails below 97% and emits a single-line error message suitable for CI parsing. + - [X] Code [Brent]: Update CI summary output (or job annotations) to surface the 97% threshold failure line clearly. + - [X] Docs [Brent]: Update `docs/development/testing.md` with the 97% coverage requirement and a sample failure output. + - [X] Tests (Behave) [Brent]: Add a scenario that parses coverage config and asserts threshold >=97%. + - [X] Tests (Robot) [Brent]: Add a Robot test that runs `nox -s coverage_report` and asserts pass/fail behavior. + - [X] Tests (ASV) [Brent]: Add `benchmarks/coverage_report_bench.py` for coverage report runtime baseline. + - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). + - [X] Git [Brent]: `git add .` (only after coverage check passes) + - [X] Git [Brent]: `git commit -m "feat(qa): enforce coverage >=97% in CI"` (only after coverage check passes) + - [X] Forgejo PR [Brent]: Open PR from `feature/q0-min-coverage` to `master` with description "Enforce 97% coverage via nox coverage_report with explicit CI summary output and updated docs/tests.". + - [X] Git [Brent]: `git checkout master` + - [X] Git [Brent]: `git branch -d feature/q0-min-coverage` + - [X] 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 Q0-Advanced Gates [Brent - AFTER M1]** -- [ ] **COMMIT (Owner: Brent | Group: Q0-Advanced | Branch: feature/q0-adv-security) - Commit message: "feat(qa): align security scans with nox"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/q0-adv-security` - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Brent]: Ensure `bandit[toml]>=1.7.5` and `semgrep` are in dev dependencies and configured in `pyproject.toml` + `.semgrep.yml`. - - [ ] Code [Brent]: Ensure pre-commit hooks for Bandit + Semgrep are present with explicit exclude patterns. - - [ ] Code [Brent]: Align `nox -s security` session to run Bandit + Semgrep with the same configs used in CI. - - [ ] Docs [Brent]: Document security scan expectations and severity gates in `docs/development/quality-automation.md`. - - [ ] Tests (Behave) [Brent]: Add a scenario verifying Bandit/Semgrep hooks are declared in `.pre-commit-config.yaml`. - - [ ] Tests (Robot) [Brent]: Add a Robot test that runs `nox -s security`. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/security_scan_bench.py` to baseline scan runtime. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Brent]: `git add .` (only after coverage check passes) - - [ ] Git [Brent]: `git commit -m "feat(qa): align security scans with nox"` (only after coverage check passes) - - [ ] Forgejo PR [Brent]: Open PR from `feature/q0-adv-security` to `master` with description "Align security scanning (Bandit + Semgrep) across pre-commit, nox, and CI with documented severity gates.". - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git branch -d feature/q0-adv-security` - - [ ] 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: Q0-Advanced | Branch: feature/q0-adv-complexity) - Commit message: "feat(qa): align complexity checks with nox"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/q0-adv-complexity` - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Brent]: Ensure `radon>=6.0.1` is in dev dependencies and `nox -s complexity` enforces the agreed thresholds. - - [ ] Code [Brent]: Align CI to call `nox -s complexity` (non-blocking until M3) and emit a summary line for parsing. - - [ ] Docs [Brent]: Document complexity thresholds, exception policy, and how to interpret CI output. - - [ ] Tests (Behave) [Brent]: Add a scenario that asserts radon configuration exists. - - [ ] Tests (Robot) [Brent]: Add a Robot test that runs `nox -s complexity` on a fixture module. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/complexity_scan_bench.py` for radon runtime baseline. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Brent]: `git add .` (only after coverage check passes) - - [ ] Git [Brent]: `git commit -m "feat(qa): align complexity checks with nox"` (only after coverage check passes) - - [ ] Forgejo PR [Brent]: Open PR from `feature/q0-adv-complexity` to `master` with description "Align radon complexity checks with nox + CI outputs and document thresholds.". - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git branch -d feature/q0-adv-complexity` - - [ ] 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: Q0-Advanced | Branch: feature/q0-adv-docs) - Commit message: "docs(qa): refresh quality automation guide"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/q0-adv-docs` - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Docs [Brent]: Refresh `docs/development/quality-automation.md` to reflect nox matrix, CI job names, and coverage >=97% gate. - - [ ] Docs [Brent]: Link the guide from `README.md` and `CONTRIBUTING.md` (verify links still valid). - - [ ] Tests (Behave) [Brent]: Add a scenario verifying the guide exists and is linked from README/CONTRIBUTING. - - [ ] Tests (Robot) [Brent]: Add a Robot doc build smoke test via `nox -s docs`. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/docs_build_bench.py` for docs build runtime baseline. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Brent]: `git add .` (only after coverage check passes) - - [ ] Git [Brent]: `git commit -m "docs(qa): refresh quality automation guide"` (only after coverage check passes) - - [ ] Forgejo PR [Brent]: Open PR from `feature/q0-adv-docs` to `master` with description "Refresh quality automation guide with updated nox/CI matrix and coverage gate details.". - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git branch -d feature/q0-adv-docs` - - [ ] 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%. +No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled with feature commits to minimize overhead during M1-M3. --- @@ -1290,6 +1267,18 @@ Merge points and acceptance checks are tracked as checklist items under each mil --- +### 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. +- [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. +- [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] **Target: Milestone M1 (+7 days)** @@ -1326,7 +1315,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil **PARALLEL SUBTRACK A2b.beta [Luis]**: Plan model alignment + action/project linkage **PARALLEL SUBTRACK A2b.gamma [Aditya]**: Action YAML schema + examples + loader **SEQUENTIAL MERGE NOTE**: A2b.alpha + A2b.beta + A2b.gamma must land before A4b CLI rebaseline. -- [X] **COMMIT (Owner: Jeff | Group: A2b.alpha | Branch: feature/m1-action-model) - Commit message: "feat(domain): align action model with spec"** - done on 2026-02-13 +- [X] **COMMIT (Owner: Jeff | Group: A2b.alpha | Branch: feature/m1-action-model | Done: Day 5, February 13, 2026 08:02:26 +0000) - Commit message: "feat(domain): align action model with spec"** - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m1-action-model` @@ -1344,13 +1333,13 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Docs [Jeff]: Update `docs/reference/action_model.md` for YAML-first fields and state semantics. - [X] Tests (Behave) [Jeff]: Add scenarios for namespaced validation, argument coercion, inputs_schema acceptance, and templating errors. (64 scenarios in action_model.feature, 2224 total scenarios passing) - [X] Tests (Robot) [Jeff]: Add Robot scenario that loads action YAML and asserts `automation_profile`, `invariants`, and actor refs in CLI output. (Action YAML Config Loading And CLI Dict test in plan_lifecycle_v3.robot) - - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/action_model_bench.py` for argument parsing + templating throughput. (6 benchmark suites: TimeArgumentParsing, TimeArgumentCoercion, TimeFromConfig, TimeAsCliDict, TimeTemplateRendering, TimeFromMapping) + - [X] Tests (ASV) [Jeff]: Add `benchmarks/action_model_bench.py` for argument parsing + templating throughput. (6 benchmark suites: TimeArgumentParsing, TimeArgumentCoercion, TimeFromConfig, TimeAsCliDict, TimeTemplateRendering, TimeFromMapping) - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: unit_tests, typecheck, coverage_report, integration_tests all pass. Benchmark session requires ASV install from git HEAD (uncommitted code not available in ASV env). - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage is 97% overall. Key files: action.py 95%, action CLI 100%, repositories 100%, plan_lifecycle_service 98%. - [X] Git [Jeff]: `git add .` - [X] Git [Jeff]: `git commit -m "feat(domain): align action model with spec"` - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-action-model` to `master` with description "Align action domain model to spec: YAML-first naming, invariants, and argument typing; updates docs + tests." -- [X] **COMMIT (Owner: Luis | Group: A2b.beta | Branch: feature/m1-plan-model) - Commit message: "feat(domain): align plan model with spec"** - done on 2026-02-13 + - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage is 97% overall. Key files: action.py 95%, action CLI 100%, repositories 100%, plan_lifecycle_service 98%. +- [X] **COMMIT (Owner: Luis | Group: A2b.beta | Branch: feature/m1-plan-model | Done: Day 5, February 13, 2026 17:31:09 +0000) - Commit message: "feat(domain): align plan model with spec"** - [X] Git [Luis]: `git checkout master` - [X] Git [Luis]: `git pull origin master` - [X] Git [Luis]: `git checkout -b feature/m1-plan-model` @@ -1369,7 +1358,6 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Tests (Robot) [Luis]: Add Robot scenario asserting `plan status` renders action_name + automation profile provenance (`plan-status-rendering` in `robot/plan_lifecycle_v3.robot`). - [X] Tests (ASV) [Luis]: Add `benchmarks/plan_model_bench.py` for plan validation + serialization (5 suites, 15 benchmarks). - [X] Quality [Luis]: Run `nox` (all default sessions, including benchmark). NOTE: Benchmark fails because ASV installs from git HEAD; uncommitted code not available in ASV env. All other sessions pass. Results: lint 0 errors, typecheck 0 errors, 130 Behave features / 2246 scenarios / 9868 steps pass, 206 Robot tests pass. - - [X] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. Coverage: `plan.py` 100% (275 stmts / 56 branches / 0 misses). Overall >=97%. - [X] Fix - Missing `@when('I try to make the action available')` step in `features/steps/plan_lifecycle_service_steps.py` (caused `plan_lifecycle_service.feature:73` failure) - [X] Fix - Missing `@then('the action CLI should make action available')` step in `features/steps/action_cli_steps.py` (caused `action_cli_uncovered_lines.feature:35` failure) - [X] Fix - `action_cli_steps.py:417` used `show` command instead of `available` in CLI invocation (merge artifact) @@ -1381,7 +1369,8 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Forgejo PR [Luis]: Open PR from `feature/m1-plan-model` to `master`, wait for CI + review, merge in UI (no CLI merge) - [X] Git [Luis]: `git checkout master` - [X] Git [Luis]: `git branch -d feature/m1-plan-model` -- [X] **COMMIT (Owner: Aditya | Group: A2b.gamma | Branch: feature/m1-action-schema) - Commit message: "docs(action): add action YAML schema and examples"** — COMPLETED 2026-02-13 + - [X] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. Coverage: `plan.py` 100% (275 stmts / 56 branches / 0 misses). Overall >=97%. +- [X] **COMMIT (Owner: Aditya | Group: A2b.gamma | Branch: feature/m1-action-schema | Done: Day 5, February 13, 2026 18:49:02 +0530) - Commit message: "docs(action): add action YAML schema and examples"** - [X] Git [Aditya]: `git checkout master` - [X] Git [Aditya]: `git pull origin master` - [X] Git [Aditya]: `git checkout -b feature/m1-action-schema` @@ -1396,12 +1385,12 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Tests (Robot) [Aditya]: Add Robot smoke test that parses example YAML files. - [X] Tests (ASV) [Aditya]: Add `benchmarks/action_schema_bench.py` for YAML schema validation throughput. - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark). - - [X] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. Coverage result: 98% total (action/schema.py: 98%, action/__init__.py: 100%). - [X] Git [Aditya]: `git add .` - [X] Git [Aditya]: `git commit -m "docs(action): add action YAML schema and examples"` - [X] Forgejo PR [Aditya]: Open PR from `feature/m1-action-schema` to `master` with description "Introduce action YAML schema + examples and loader validation; aligns action configs with spec for M1.". - [X] Git [Aditya]: `git checkout master` - [X] Git [Aditya]: `git branch -d feature/m1-action-schema` + - [X] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. Coverage result: 98% total (action/schema.py: 98%, action/__init__.py: 100%). **Notes (A2b.gamma)**: - Schema: `docs/schema/action.schema.yaml` — full field definitions with types, patterns, defaults, constraints. - Examples: 5 configs under `examples/actions/` — simple, invariant-heavy, read-only, estimation-actor, inputs-schema. @@ -1438,60 +1427,99 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] `agents [--data-dir PATH] [--config-path PATH] plan cancel ` - cancel non-terminal plan - [X] Location: `src/cleveragents/cli/commands/action.py`, `src/cleveragents/cli/commands/plan.py` - [X] Tests: Behave tests for action CLI (15 scenarios in `features/action_cli.feature`) - **Parallel Group A4b: CLI Rebaseline + Coverage (M1-critical)** - **PARALLEL SUBTRACK A4b.alpha [Jeff]**: Action/plan CLI alignment to spec - **PARALLEL SUBTRACK A4b.beta [Brent]**: Behave + Robot CLI coverage after A4b.alpha - **SEQUENTIAL MERGE NOTE**: A4b.alpha depends on A2b.alpha/beta/gamma; A4b.beta runs after A4b.alpha to lock outputs. -- [ ] **COMMIT (Owner: Jeff | Group: A4b.alpha | Branch: feature/m1-cli-rebaseline) - Commit message: "feat(cli): rebaseline action and plan lifecycle commands"** + **Parallel Group A4b: CLI Rebaseline (M1-critical)** + **PARALLEL SUBTRACK A4b.action [Jeff]**: Action CLI config-only flow + filters + **PARALLEL SUBTRACK A4b.plan [Jeff]**: Plan use/list/status flag alignment + **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. +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m1-cli-rebaseline` + - [ ] Git [Jeff]: `git checkout -b feature/m1-action-cli` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Enforce config-only `agents action create --config` (no legacy flags), add `--update` and `--dry-run`. - - [ ] Code [Jeff]: Remove `action available`; align `action list/show/archive` to namespaced names only. - - [ ] Code [Jeff]: Update `plan use` to accept positional projects, parse `--arg name=value`, and apply automation_profile/invariants. - - [ ] Code [Jeff]: Add actor override flags (`--strategy-actor`, `--execution-actor`, `--estimation-actor`, `--invariant-actor`) and validate actors. - - [ ] Code [Jeff]: Route CLI to persistence-backed PlanLifecycleService via DI (no in-memory fallback). - - [ ] Code [Jeff]: Update `plan status/list/execute/apply/cancel` output fields to match spec (action_name, profile, invariants). - - [ ] Docs [Jeff]: Update `docs/reference/plan_cli.md` and `docs/reference/action_cli.md` with new examples and error cases. - - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for config-only action create, plan use with invariants/profile, and legacy flag rejection. - - [ ] Tests (Robot) [Jeff]: Add Robot lifecycle flow for action create -> plan use -> execute -> apply (DB-backed). - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/cli_rebaseline_bench.py` for CLI parsing 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%. + - [ ] Code [Jeff]: Enforce config-only `agents action create --config `; reject legacy flags and inline overrides. + - [ ] Code [Jeff]: Load config via `ActionConfigSchema.from_yaml_file()` → `Action.from_config()` and surface file/line validation errors. + - [ ] Code [Jeff]: Remove `action available`; align `action list/show/archive` to namespaced names with `--namespace` + `--state` filters. + - [ ] Code [Jeff]: Ensure action CLI output includes namespaced name, short_name, state, actor refs, and definition_of_done summary. + - [ ] Docs [Jeff]: Update `docs/reference/action_cli.md` with config-only flow, filters, and error cases. + - [ ] Tests (Behave) [Jeff]: Add scenarios for config-only create, legacy flag rejection, and list/show filters. + - [ ] Tests (Robot) [Jeff]: Add Robot smoke for action create/list/show/archive (DB-backed). + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/action_cli_bench.py` for config load + parsing 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(cli): rebaseline action and plan lifecycle commands"` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-cli-rebaseline` to `master` with description "Rebaseline action/plan CLI to spec (config-only action create, plan use args/invariants, updated outputs) with tests.". + - [ ] Git [Jeff]: `git commit -m "feat(cli): align action commands to spec"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-action-cli` to `master` with description "Align action CLI to spec: config-only create, filterable list/show, and consistent output fields.". - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m1-cli-rebaseline` + - [ ] Git [Jeff]: `git branch -d feature/m1-action-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: Brent | Group: A4b.beta | Branch: feature/m1-cli-tests) - Commit message: "test(cli): cover plan lifecycle commands"** +- [ ] **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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m1-plan-cli` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Update `plan use` to accept multiple projects plus `--automation-profile`, `--invariant`, `--strategy-actor`, `--execution-actor`, `--estimation-actor`, `--invariant-actor`, and repeatable `--arg name=value`. + - [ ] Code [Jeff]: Align `plan list` filters to spec (`--phase`, `--state`, `--project`, `--action`, optional regex); map `--state` to processing_state. + - [ ] Code [Jeff]: Ensure `plan status` renders action_name, phase, processing_state, project links, arguments, and automation profile. + - [ ] Docs [Jeff]: Update `docs/reference/plan_cli.md` with plan use flags + list/status filters. + - [ ] Tests (Behave) [Jeff]: Add scenarios for plan use with args/invariants/actor overrides and list/status filter combinations. + - [ ] Tests (Robot) [Jeff]: Add Robot smoke for plan use + list/status output (DB-backed lifecycle). + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_cli_bench.py` for plan use/list parsing 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(cli): align plan use/list/status flags"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-cli` to `master` with description "Align plan use/list/status flags and outputs to spec for M1.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m1-plan-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: A4b.outputs | Branch: feature/m1-cli-formats | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(cli): stabilize action/plan output formats"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m1-cli-formats` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Ensure `--format json|yaml|plain|table|rich` parity for action/plan list/show/status outputs. + - [ ] Code [Jeff]: Normalize output keys to spec field names (namespaced_name, processing_state, project_links, arguments, automation_profile). + - [ ] Docs [Jeff]: Update `docs/reference/action_cli.md` + `docs/reference/plan_cli.md` with format examples and field descriptions. + - [ ] Tests (Behave) [Jeff]: Add format output scenarios for json/yaml on action/plan list/show/status. + - [ ] Tests (Robot) [Jeff]: Add Robot lifecycle flow verifying formatted outputs remain stable. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/cli_format_bench.py` for serialization 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(cli): stabilize action/plan output formats"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-cli-formats` to `master` with description "Stabilize action/plan CLI output formats and spec-aligned field keys.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m1-cli-formats` + - [ ] 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: A4b.tests | Branch: feature/m1-cli-tests | Planned: Day 9 | Expected: Day 11) - Commit message: "test(cli): expand lifecycle command coverage"** - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git pull origin master` - [ ] 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 coverage for `plan execute`, `plan apply`, `plan status`, `plan list`, `plan cancel` (success + error paths). - - [ ] Tests (Behave) [Brent]: Add negative cases for invalid automation profile, invalid invariant actor, unknown action. - - [ ] Tests (Behave) [Brent]: Add output snapshot assertions for table columns and JSON/YAML formats. - - [ ] Tests (Robot) [Brent]: Add end-to-end Robot suite for lifecycle transitions with multiple projects. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with new CLI suites and fixtures. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/plan_cli_smoke_bench.py` for CLI argument 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%. + - [ ] 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 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. + - [ ] 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. - [ ] Git [Brent]: `git add .` - - [ ] Git [Brent]: `git commit -m "test(cli): cover plan lifecycle commands"` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-cli-tests` to `master` with description "Add Behave + Robot CLI coverage for plan lifecycle commands and output formats.". + - [ ] Git [Brent]: `git commit -m "test(cli): expand lifecycle command coverage"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-cli-tests` to `master` with description "Expand Behave + Robot CLI coverage for action/plan lifecycle commands and error paths.". - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git branch -d feature/m1-cli-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 A5: Plan Persistence (M1-critical)** - **PARALLEL SUBTRACK A5.alpha [Jeff]**: Alembic migrations for action/plan tables - **PARALLEL SUBTRACK A5.beta [Luis]**: SQLAlchemy models for new tables - **SEQUENTIAL AFTER alpha+beta [Jeff + Luis]**: Repositories + service integration - **PARALLEL CONTINUOUS [Brent]**: Persistence tests added inside each commit - **SEQUENTIAL NOTE**: `action_arguments` migration must land after `actions` migration; A5.legacy should land after A4b CLI alignment + A5.gamma persistence wiring. - **SEQUENTIAL NOTE**: A5.alpha migrations must match A2b fields; rebase Alembic head after A2b merges before cutting follow-on revisions. -- [X] **COMMIT (Owner: Jeff | Group: A5.alpha | Branch: feature/m1-db-actions) - Commit message: "feat(db): add spec-aligned action and plan tables with migrations, ORM models, and benchmarks"** + **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. + **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` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m1-db-actions` @@ -1538,147 +1566,108 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Quality [Jeff]: Run `nox -s lint` -- All checks passed. - [X] Quality [Jeff]: Run `nox -s unit_tests` -- 130 features passed, 0 failed; 2233 scenarios passed, 0 failed. - [X] Quality [Jeff]: Run `nox -s integration_tests -- --include database` -- 8 tests, 8 passed. - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report` -- TOTAL 97%. - [X] Git [Jeff]: `git add .` - [X] Git [Jeff]: `git commit -m "feat(db): add spec-aligned action and plan tables with migrations, ORM models, and benchmarks"` - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-db-actions` to `master` with description "Add spec-aligned action/plan tables (actions, action_invariants, action_arguments, v3_plans, plan_projects, plan_arguments, plan_invariants) with Alembic migrations, updated ORM models, repository changes, schema docs, and ASV benchmarks.". - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git branch -d feature/m1-db-actions` -- [ ] **COMMIT (Owner: Luis | Group: A5.beta | Branch: feature/m1-orm-models) - Commit message: "feat(models): add action and lifecycle plan ORM models"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m1-orm-models` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Luis]: Add SQLAlchemy base model mixins for ULID PKs, timestamps, and JSON columns (reused by plan/resource models). - - [X] Code [Luis]: Implement `ActionModel` with PK `namespaced_name`, namespace/name, description/long_description, actor refs, DoD, automation_profile, invariant_actor, state (available/archived), inputs_schema_json, tags_json, created_by. - - [X] Code [Luis]: Implement `ActionInvariantModel` with FK to actions by namespaced_name, invariant_text, position, and created_at. - - [X] Code [Luis]: Implement `ActionArgumentModel` with FK to actions by namespaced_name, name, arg_type, requirement, defaults/min/max/regex, position, and constraints. - - [X] Code [Luis]: Implement `LifecyclePlanModel` with identity fields, phase/processing enums (strategize/execute/apply), action_name linkage, rendered DoD/description, policy metadata, and execution placeholders. - - [X] Code [Luis]: Implement `PlanProjectLinkModel` with plan_id, project_name, alias, read_only, and created_at, plus uniqueness constraint. - - [X] Code [Luis]: Implement `PlanArgumentModel` and `PlanInvariantModel` with ordered `position` fields and source_scope for invariants. - - [X] Code [Luis]: Define ORM relationships with ordering (`order_by=position`) and cascade rules for argument/invariant collections. - - [X] Code [Luis]: Implement `to_domain()` and `from_domain()` mappers with enum conversion and timestamp normalization. - - [X] Code [Luis]: Add repository-facing helpers for filtering by namespace/phase/state and eager-load action arguments + plan links. - - [ ] Docs [Luis]: Update ORM mapping notes in `docs/reference/database_schema.md` with model field mapping table. - - [ ] Tests (Behave) [Luis]: Add scenarios for ORM round-trip serialization, enum conversions, and ordered argument persistence. - - [ ] Tests (Robot) [Luis]: Add Robot test that loads a plan and asserts field mapping correctness. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/orm_mapping_bench.py` for Action/Plan mapping 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(models): add action and lifecycle plan ORM models"` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-orm-models` to `master` with description "Add/align ORM models for action + plan persistence to match spec fields and ordering.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m1-orm-models` -- [ ] **COMMIT (Owner: Luis | Group: A5.beta2 | Branch: feature/m1-orm-models-refactor) - Commit message: "refactor(models): align action/plan ORM with spec IDs"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m1-orm-models-refactor` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Update `LifecycleActionModel` to use namespaced name as the primary key (remove `action_id` ULID) and align column names with spec (`description`, `long_description`, `automation_profile`, `invariant_actor`, `inputs_schema_json`, `tags_json`). - - [ ] Code [Luis]: Update `LifecyclePlanModel` to reference `action_name` (namespaced) instead of `action_id`; replace `project_ids` with serialized `project_links` per spec. - - [ ] Code [Luis]: Add/align plan metadata fields (`automation_profile`, `invariants`, `arguments` + `arguments_order`, `validation_summary`, `decision_root_id`, `error_details_json`) and remove legacy fields no longer in spec. - - [ ] Code [Luis]: Align `processing_state` enum values to spec and remove legacy `state` values that no longer apply. - - [ ] Code [Luis]: Update ORM relationships to use namespaced names and ensure ordering for arguments/invariants/project links. - - [ ] Code [Luis]: Update `to_domain()`/`from_domain()` mappers for actions/plans to reflect new identifiers and serialized fields. - - [ ] Docs [Luis]: Update ORM mapping notes in `docs/reference/database_schema.md` to reflect the new identifiers and column mappings. - - [ ] Tests (Behave) [Luis]: Add scenarios verifying ORM round-trip with namespaced IDs and project links. - - [ ] Tests (Robot) [Luis]: Add Robot test that loads an action + plan and asserts new field mappings. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/orm_refactor_bench.py` for mapping throughput baseline. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Luis]: `git add .` (only after coverage check passes) - - [ ] Git [Luis]: `git commit -m "refactor(models): align action/plan ORM with spec IDs"` (only after coverage check passes) - - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-orm-models-refactor` to `master` with description "Align ORM models with spec identifiers (namespaced action IDs, plan action_name linkage, project_links serialization) and update mappings/tests.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m1-orm-models-refactor` - - [ ] 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: A5.gamma | Branch: feature/m1-repositories) - Commit message: "feat(repo): add action and lifecycle plan repositories"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m1-repositories` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Define repository interfaces in `src/cleveragents/domain/repositories/` for ActionRepository and PlanRepository (methods + expected errors). - - [X] Code [Luis]: Implement ActionRepository CRUD keyed by namespaced_name with deterministic ordering (created_at) and filters (namespace, state, automation_profile). (completed by Luis) - - [ ] Code [Jeff]: Implement ActionRepository persistence for arguments + invariants with ordered `position` preservation. - - [ ] Code [Jeff]: Implement PlanRepository CRUD with filters (phase/state/project_name/action_name) and lookup by plan_id/ namespaced_name. - - [ ] Code [Jeff]: Implement PlanRepository persistence for plan_projects, plan_arguments, plan_invariants with ordered retrieval. - - [ ] Code [Jeff]: Add retry decorator to repositories; retry only on `OperationalError`, never on `IntegrityError`. - - [ ] Code [Jeff]: Add pagination parameters (`limit`, `offset`) with default ordering for list queries. - - [ ] Docs [Jeff]: Document repository interfaces, error types, and pagination guidance. - - [ ] Tests (Behave) [Jeff]: Add scenarios for repository create/get/list/update/delete guardrails, including action argument round-trips. - - [ ] Tests (Robot) [Jeff]: Add Robot test that exercises repository through service layer. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/repository_query_bench.py` for list + filter 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 .` - - [ ] Git [Jeff]: `git commit -m "feat(repo): add action and lifecycle plan repositories"` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-repositories` to `master` with description "Add action + plan repositories and repository interfaces with ordered persistence and filters.". - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m1-repositories` -- [ ] **COMMIT (Owner: Luis | Group: A5.gamma | Branch: feature/m1-lifecycle-service) - Commit message: "feat(service): persist plan lifecycle via repositories"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m1-lifecycle-service` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Update `PlanLifecycleService` to use repositories instead of in-memory dicts. - - [ ] Code [Luis]: Replace in-memory action/plan maps with repository lookups in `get_action`, `get_plan`, and list helpers. - - [ ] Code [Luis]: Persist action creation keyed by namespaced_name with arguments/invariants and enforce uniqueness. - - [ ] Code [Luis]: Persist plan creation with project link metadata (alias/read_only) and store plan_arguments/plan_invariants in the same transaction. - - [ ] Code [Luis]: Update phase transitions to strategize/execute/apply only and treat apply+complete as terminal applied. - - [ ] Code [Luis]: Wrap transitions in UnitOfWork transactions and map DB errors to domain errors (duplicate names, missing action). - - [ ] Code [Luis]: Add optimistic guards for phase transitions (validate phase/state before update; reload on conflict). - - [ ] Docs [Luis]: Update service docs to reflect persistence and remove in-memory notes. - - [ ] Tests (Behave) [Luis]: Add scenarios for persisted lifecycle transitions and error handling (duplicate names, invalid transitions). - - [ ] Tests (Robot) [Luis]: Add end-to-end test that restarts the app and re-reads plan state. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/plan_lifecycle_service_bench.py` for persistence operations. - - [ ] 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): persist plan lifecycle via repositories"` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-lifecycle-service` to `master` with description "Persist plan lifecycle via repositories + UoW; remove in-memory lifecycle storage.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m1-lifecycle-service` + - [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: Luis | Group: A5.gamma | Branch: feature/m1-lifecycle-service) - Commit message: "feat(di): wire lifecycle repos and services"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m1-lifecycle-service` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Register ActionRepository + PlanRepository in `application/container.py` and UnitOfWork. - - [ ] Code [Luis]: Register PlanLifecycleService with repository dependencies and settings in container. - - [ ] Code [Luis]: Inject lifecycle service into CLI commands; remove direct service instantiation in `action.py` and `plan.py`. - - [ ] Code [Luis]: Add container wiring tests to ensure singleton lifetimes are correct and repositories share UoW session. - - [ ] Docs [Luis]: Update DI wiring notes in `docs/architecture/decisions/adr-003.md`. - - [ ] Tests (Behave) [Luis]: Add scenarios that use container wiring for lifecycle commands. - - [ ] Tests (Robot) [Luis]: Add Robot smoke test verifying CLI uses persisted service. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/di_container_bench.py` for container 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 .` - - [ ] Git [Luis]: `git commit -m "feat(di): wire lifecycle repos and services"` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-lifecycle-service` to `master` with description "Wire lifecycle repositories + services in DI container and CLI entrypoints.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m1-lifecycle-service` +- [ ] **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: Brent | Group: A5.tests | Branch: feature/m1-persistence-tests) - Commit message: "test(persistence): add plan/action persistence suites"** +- [ ] **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.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: Brent | Group: A5.tests | Branch: feature/m1-persistence-tests | Planned: Day 8 | Expected: Day 10) - 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, update phase/state, list filters, plan tree, concurrency). - - [ ] Tests (Behave) [Brent]: Add action persistence scenarios (create, list available, archive guard, action arguments persisted). + - [ ] Tests (Behave) [Brent]: Add plan persistence scenarios (create, phase/state transitions, list filters, plan tree links). + - [ ] 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 (Behave) [Brent]: Add migration-boundary scenarios to ensure new tables are read after upgrade. - [ ] Tests (Robot) [Brent]: Add plan persistence E2E (full lifecycle, restart persistence, concurrent CLI access). - - [ ] Docs [Brent]: Update `docs/development/testing.md` with persistence suites, fixtures, and `nox` commands. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/persistence_suites_bench.py` for DB read/write baselines. - - [ ] 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%. + - [ ] Docs [Brent]: Update `docs/development/testing.md` with persistence suites, fixtures, and nox commands. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/persistence_suites_bench.py` for test runtime baseline. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - [ ] Git [Brent]: `git add .` - [ ] Git [Brent]: `git commit -m "test(persistence): add plan/action persistence suites"` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-persistence-tests` to `master` with description "Add Behave/Robot persistence coverage for action + plan repositories and migrations.". + - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-persistence-tests` to `master` with description "Add Behave/Robot persistence coverage for action + plan repositories.". - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git branch -d feature/m1-persistence-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%. - [X] **Stage A6: Automation Levels Foundation** (Day 4-5) **[Luis]** - [X] Code: Implement basic automation level support @@ -1697,14 +1686,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Add pause/resume capability for review-before-apply mode - [X] **A6.4** [Luis] Update CLI commands to support automation levels: - [X] Add `--automation-level` flag to `agents [--data-dir PATH] [--config-path PATH] plan use` command - - [ ] Add `agents [--data-dir PATH] [--config-path PATH] config set automation-level ` command - [X] Add `agents [--data-dir PATH] [--config-path PATH] plan set-automation-level ` command: - [X] Can change automation level for existing plan - [X] Only affects future phase transitions - [X] Subplans created after change use new level - - [ ] Add `agents [--data-dir PATH] [--config-path PATH] session set automation-level ` command: - - [ ] Set session-level automation (overrides global) - - [ ] Persists for current session only - [X] Tests: Automation level tests - [X] **A6.5** [Luis] Write Behave scenarios in `features/automation_levels.feature` (24 scenarios): - [X] Scenario: Manual mode requires explicit execute command @@ -1732,29 +1717,6 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Scenario: Resolve automation level from settings - [X] Scenario: Invalid automation level in settings falls back to manual -**Parallel Group A5.legacy: Remove legacy plan build/apply path (M1-critical)** -- [ ] **COMMIT (Owner: Jeff | Group: A5.legacy | Branch: feature/m1-remove-legacy-plan) - Commit message: "refactor(plan): remove legacy plan service and CLI"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m1-remove-legacy-plan` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Remove `PlanService` usage from CLI (`plan tell/build/apply/new/current/list/cd/continue`) and delete command handlers from `src/cleveragents/cli/commands/plan.py`. - - [ ] Code [Jeff]: Remove or quarantine legacy `plan_service.py`, `plan_legacy.py`, and legacy CLI helpers; add explicit NotImplementedError where needed. - - [ ] Code [Jeff]: Remove `PlanService` wiring from `src/cleveragents/application/container.py` and any references from `cli/commands/auto_debug.py`. - - [ ] Code [Jeff]: Rename `plan lifecycle-apply` to `plan apply` and update command wiring once legacy apply is removed. - - [ ] Code [Jeff]: Remove or archive legacy `PlanModel`/`PlanStatus` DB tables if unused by v3; document migration path. - - [ ] Docs [Jeff]: Update CLI docs to list only v3 lifecycle commands and new `plan use/execute/apply` flows. - - [ ] Tests (Behave) [Jeff]: Remove/replace legacy scenarios with v3 equivalents and adjust coverage expectations. - - [ ] Tests (Robot) [Jeff]: Remove legacy robot suites and add v3 replacements where needed. - - [ ] Tests (ASV) [Jeff]: Update asv suite to remove legacy plan benchmarks and add v3 lifecycle baseline benchmark. - - [ ] 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 "refactor(plan): remove legacy plan service and CLI"` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-remove-legacy-plan` to `master` with description "Remove legacy plan build/apply CLI and services after v3 lifecycle is fully wired.". - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m1-remove-legacy-plan` - **Parallel Group A6: Automation Profiles Foundation [Jeff + Luis]** (M4-critical; depends on A5 persistence) **PARALLEL SUBTRACK A6.core [Jeff]**: Profile model + built-ins + schema **PARALLEL SUBTRACK A6.service [Luis]**: Profile resolution + precedence @@ -1767,14 +1729,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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 **10 confidence thresholds + 3 boolean safety flags** per spec; validate 0.0–1.0 ranges and boolean types. - - [ ] Code [Jeff]: Add built-in profiles (`manual`, `review`, `supervised`, `cautious`, `trusted`, `auto`, `ci`, `full-auto`) with exact threshold values per spec and stable IDs. - - [ ] Code [Jeff]: Add YAML schema for automation profiles under `docs/schema/automation_profile.schema.yaml` and loader helper. - - [ ] Docs [Jeff]: Add `docs/reference/automation_profiles.md` describing built-ins and threshold semantics. + - [ ] 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 and built-in defaults. + - [ ] 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 `asv/benchmarks/automation_profile_bench.py` for profile validation. + - [ ] 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 .` @@ -1789,13 +1752,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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). - - [ ] Code [Luis]: Add persistence table `automation_profiles` (namespaced name PK) and repository with list/show/update. - - [ ] Code [Luis]: Add config key `core.automation_profile` and env var override for global default. - - [ ] Docs [Luis]: Update `docs/reference/config.md` with automation profile defaults and override behavior. - - [ ] Tests (Behave) [Luis]: Add scenarios for precedence resolution and missing profile errors. + - [ ] 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. + - [ ] Code [Luis]: Update PlanLifecycleService auto-progress logic to use AutomationProfile thresholds (map legacy automation_level to built-ins). + - [ ] Docs [Luis]: Update `docs/reference/config.md` with automation profile defaults, legacy mapping notes, and override behavior. + - [ ] Tests (Behave) [Luis]: Add scenarios for precedence resolution, missing profile errors, and legacy automation_level mapping. - [ ] Tests (Robot) [Luis]: Add Robot config smoke test for global profile override. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/automation_profile_resolution_bench.py` for resolution latency. + - [ ] 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 .` @@ -1814,12 +1778,12 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Code [Jeff]: Ensure `automation-profile list` supports `--namespace` and regex filters with deterministic ordering. - [ ] Code [Jeff]: Add `--format json/yaml` output for `list/show` and keep field names aligned with schema. - [ ] Code [Jeff]: Add `--automation-profile` to `plan use` and surface profile name + thresholds in `plan status` output. - - [ ] Code [Luis]: Add `config set automation-level` and `session set automation-level` commands. - - [ ] Docs [Jeff]: Update CLI reference with automation-profile command examples, built-in profile list, and error cases. + - [ ] Code [Jeff]: Deprecate `--automation-level` and `plan set-automation-level` (keep as alias to built-in profiles with warning). + - [ ] Docs [Jeff]: Update CLI reference with automation-profile command examples, built-in profile list, and deprecation notes. - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for profile add/list/show/remove/update and invalid name/threshold validation errors. - [ ] Tests (Behave) [Jeff]: Add output snapshot assertions for `automation-profile list --format json` and `show --format yaml`. - [ ] Tests (Robot) [Jeff]: Add Robot CLI tests for automation-profile commands (add/show/remove + format outputs). - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/automation_profile_cli_bench.py` for CLI parsing. + - [ ] 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 .` @@ -1841,7 +1805,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Update CLI reference with diff examples and `--correction` usage. - [ ] Tests (Behave) [Jeff]: Add scenarios for diff output (single resource, multi-resource, missing diff, correction diff). - [ ] Tests (Robot) [Jeff]: Add Robot CLI test running `plan diff` after an execute/apply dry run. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/plan_diff_cli_bench.py` for diff rendering overhead. + - [ ] 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 .` @@ -1860,7 +1824,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add CLI reference docs for `plan artifacts` and `plan prompt` with output field descriptions. - [ ] Tests (Behave) [Jeff]: Add scenarios for artifacts listing and prompt recording. - [ ] Tests (Robot) [Jeff]: Add Robot CLI tests covering artifacts and prompt commands. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/plan_artifacts_cli_bench.py` for listing overhead. + - [ ] 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 .` @@ -1871,10 +1835,11 @@ Merge points and acceptance checks are tracked as checklist items under each mil **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 + **PARALLEL SUBTRACK A7.domain.tests [Brent]**: Robot smoke tests for session domain model **PARALLEL SUBTRACK A7.persistence [Luis]**: DB tables + repositories + service implementation **PARALLEL SUBTRACK A7.cli [Brent]**: Session CLI commands + output formatting **SEQUENTIAL NOTE**: A7.domain must land before A7.persistence/cli; A7.cli depends on A7.persistence service wiring. -- [X] **COMMIT (Owner: Jeff | Group: A7.domain | Branch: feature/m3-session-domain) - Commit message: "feat(session): add session domain models and contracts"** - done on 2026-02-13 +- [X] **COMMIT (Owner: Jeff | Group: A7.domain | Branch: feature/m3-session-domain | Done: Day 5, February 13, 2026 22:15:46 +0000) - Commit message: "feat(session): add session domain models and contracts"** - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m3-session-domain` @@ -1884,15 +1849,33 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Code [Jeff]: Add `SessionService` interface contracts (create/list/show/delete/append/export/import) with error types. (SessionService ABC + SessionNotFoundError, SessionMessageError, SessionExportError) - [X] Docs [Jeff]: Add `docs/reference/session_model.md` and `docs/reference/session_service.md`. - [X] Tests (Behave) [Jeff]: Add `features/session_model.feature` for model validation and serialization ordering. (39 scenarios) - - [ ] Tests (Robot) [Jeff]: Add `robot/session_model.robot` smoke tests. (Deferred - domain model tests fully covered by Behave; Robot tests more appropriate after persistence integration) - [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] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (session.py 98%). - [X] Git [Jeff]: `git add .` - [X] Commit [Jeff]: `git commit -m "feat(session): add session domain models and contracts"` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-session-domain` to `master` with description "Add session domain models + service contracts with docs and tests." - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m3-session-domain` + - [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"** + - [ ] 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` + - [ ] Git [Brent]: `git checkout -b feature/m3-session-domain-robot` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Brent]: Add `robot/session_model.robot` smoke tests for Session creation, message ordering, and serialization output. + - [ ] Docs [Brent]: Update `docs/reference/session_model.md` to mention the Robot smoke suite and how to run it. + - [ ] Tests (Behave) [Brent]: Add a scenario in `features/session_model.feature` that mirrors the Robot smoke expectations for serialization order. + - [ ] Tests (Robot) [Brent]: Add Robot suite that validates session model creation and export paths. + - [ ] Tests (ASV) [Brent]: Confirm `asv/benchmarks/session_model_bench.py` still passes after the new Robot suite is added. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` + - [ ] Git [Brent]: `git commit -m "test(session): add robot session model smoke tests"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-session-domain-robot` to `master` with description "Add Robot smoke tests for session domain model with docs and Behave alignment.". + - [ ] 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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` @@ -1905,7 +1888,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Update `docs/reference/database_schema.md` with session tables and constraints. - [ ] Tests (Behave) [Luis]: Add `features/session_persistence.feature` for create/list/show/delete/append/export/import. - [ ] Tests (Robot) [Luis]: Add `robot/session_persistence.robot` integration smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/session_persistence_bench.py` for write/read throughput. + - [ ] 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 .` @@ -1925,7 +1908,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Brent]: Update CLI reference with session command examples, streaming notes, and JSON output shape. - [ ] Tests (Behave) [Brent]: Add `features/session_cli.feature` covering create/list/show/delete/export/import/tell flows + error cases. - [ ] Tests (Robot) [Brent]: Add `robot/session_cli.robot` end-to-end session flows with export/import round-trip. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/session_cli_bench.py` for command parsing overhead. + - [ ] 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 .` @@ -1947,7 +1930,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Brent]: Add `docs/reference/config_cli.md` with examples and masking rules for secrets. - [ ] Tests (Behave) [Brent]: Add `features/config_cli.feature` for set/get/list, filter behavior, and secret masking. - [ ] Tests (Robot) [Brent]: Add `robot/config_cli.robot` smoke tests for config list output. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/config_cli_bench.py` for CLI parsing. + - [ ] 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 .` @@ -1957,114 +1940,108 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Git [Brent]: `git branch -d feature/m3-config-cli` **M1 SUCCESS CRITERIA (Day 7 MVP - source code only)**: -- Action created from YAML config and persisted (namespaced name, invariants, automation profile). -- Project created and linked to a local git-checkout resource. -- Plan use -> strategize -> execute -> apply completes with sandbox isolation and diff review. -- Tool-based change tracking produces a ChangeSet and applies to the repo after approval. +- 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. +- 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. --- ### Section 4: Projects & Resources [WORKSTREAM B - Hamza Lead] -**Target: Milestone M2 (+10 days)** -**Week 1-2 focus**: local source code only (git-checkout + fs-directory). Database, API, and remote resources are schema-only stubs for future work. +**Target: Milestones M1-M2 (M1 minimal subset first)** +**Week 1 focus**: git-checkout resources + project linking + git_worktree sandbox + minimal resource registry. +**Week 2 focus**: fs-mount + resource DAG operations + auto-discovery + resource tree/inspect. -**Parallel Group B1: Resource Registry Core [Hamza + Jeff]** (can start after A5.alpha migrations are available) - **SEQUENTIAL NOTE**: B1 domain models can start immediately; B1 DB migrations must rebase on the latest Alembic head after A5.alpha to keep a linear migration chain. -- [ ] **COMMIT (Owner: Hamza | Group: B1.core | Branch: feature/m2-resource-core-models) - Commit message: "feat(domain): add resource type spec and resource model"** +**COMPLETED (LOCKED)** +- [X] **COMMIT (Owner: Hamza | Group: B0.domain.core | Branch: feature/B1-v2-project-data-models | Done: Day 5, February 13, 2026 21:54:31 +0000) - Commit message: "feat(domain): add spec-aligned Resource and Project models"** + - [X] Notes [Hamza]: Implemented `Resource` and `NamespacedProject` domain models in `src/cleveragents/domain/models/core/resource.py` and `src/cleveragents/domain/models/core/project.py`. + +**Parallel Group B0: Resource Registry + Project Linking (M1-critical)** + **PARALLEL SUBTRACK B0.type-model [Hamza]**: ResourceType model + schema loader (Resource model already landed) + **PARALLEL SUBTRACK B0.builtins [Hamza]**: Built-in resource types for M1 (git-checkout + fs-directory) + **PARALLEL SUBTRACK B0.db.resources [Jeff]**: Resource registry DB tables (completed) + **PARALLEL SUBTRACK B0.db.resources.tests [Brent]**: Resource registry Robot migration smoke tests + **PARALLEL SUBTRACK B0.db.projects [Hamza]**: Projects + project_resource_links tables + **PARALLEL SUBTRACK B0.repo.resources [Luis]**: ResourceType + Resource repositories + **PARALLEL SUBTRACK B0.repo.projects [Luis]**: Project + ProjectResourceLink repositories + **PARALLEL SUBTRACK B0.services [Luis]**: ResourceRegistryService + ProjectService rebaseline + **PARALLEL SUBTRACK B0.cli.resources [Jeff]**: Resource CLI (type list/show, add/list/show/remove) + **PARALLEL SUBTRACK B0.cli.projects [Jeff]**: Project CLI (create/link/unlink/list/show/delete) + **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"** + - [ ] 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` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-core-models` + - [ ] Git [Hamza]: `git checkout -b feature/m1-resource-type-schema` - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Hamza]: Create `src/cleveragents/domain/models/core/resource_type.py` with `ResourceTypeSpec`, `ResourceTypeArgument`, `ResourceKind` (physical/virtual), and `SandboxStrategy` enum. (delivered in PR #51 as resource.py — PhysVirt, SandboxStrategy with 5 spec values, ResourceCapabilities) - - [ ] Code [Hamza]: Define `ResourceTypeArgument` fields for CLI flags (`flag`, `help`, `arg_type`, `required`, `default`, `repeatable`, `choices`) and validate flag naming conventions. - - [ ] Code [Hamza]: Add resource type fields: `user_addable`, `allowed_parents`, `allowed_children`, `auto_discover`, `handler` reference, and `sandbox_strategy` default. - - [X] Code [Hamza]: Add `Resource` and `ResourceRef` models with ULID, optional namespaced name, type name, location, description, sandbox strategy, read_only, and metadata. (delivered in PR #51 — Resource model with ULID PK, resource_type_name, properties, capabilities, DAG parents/children) - - [X] Code [Hamza]: Enforce user-added resources require namespaced name; auto-discovered child resources are ULID-only with no namespaced name. (delivered in PR #51 — name is Optional) - - [X] Code [Hamza]: Add virtual resource validation rules (no location; cannot be directly read/write; distinct from physical). (delivered in PR #51 — PhysVirt enum, classification field) - - [X] Code [Hamza]: Add validators for namespaced naming, ULID format, and parent/child DAG sanity (no self loops, no duplicate edges, type compatibility). (delivered in PR #51 — parse_namespaced_name, ULID validation) - - [X] Code [Hamza]: Add `ResourceName.parse()` and `ResourceTypeName.parse()` helpers to normalize `local/` default and reject invalid namespaces. (delivered in PR #51 — parse_namespaced_name with reserved/provider namespace validation) - - [ ] Code [Hamza]: Add `docs/schema/resource_type.schema.yaml` with CLI argument definitions, parent/child constraints, and handler metadata. - - [ ] Code [Hamza]: Add resource type YAML loader in `src/cleveragents/resource/schema.py` with version guard and clear error messages. - - [ ] Docs [Hamza]: Add `docs/reference/resource_model.md` with examples for git-checkout and fs-directory resources plus physical/virtual notes. - - [X] Tests (Behave) [Hamza]: Add scenarios validating ULID format, namespace rules, allowed parent/child type checks, and sandbox strategy defaults. (delivered in PR #51 — 33 resource_registry_model scenarios + 48 namespaced_project_model scenarios) - - [ ] Tests (Robot) [Hamza]: Add Robot test that loads a ResourceTypeSpec YAML fixture and validates it. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_model_bench.py` for resource validation + DAG checks. - - [ ] 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%. + - [ ] 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 `--`. + - [ ] 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]: 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. + - [ ] Docs [Hamza]: Add `docs/reference/resource_type_model.md` with minimal examples and validation rules (include git-checkout + fs-directory and physical/virtual notes). + - [ ] Tests (Behave) [Hamza]: Add scenarios for resource type name validation, `cli_args` parsing, `child_types`/`parent_types` constraint validation, and unnamespaced built-in allowance. + - [ ] Tests (Behave) [Hamza]: Add schema loader scenarios for env var interpolation, version mismatch, and handler metadata validation. + - [ ] Tests (Robot) [Hamza]: Add Robot test that loads a ResourceType YAML fixture and asserts required fields are present. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_schema_bench.py` for YAML validation throughput. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_model_bench.py` for resource type validation and constraint checks. + - [ ] 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(domain): add resource type spec and resource model"` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-core-models` to `master` with description "Add resource type spec + resource model with validation, schema, and tests for M2.". + - [ ] Git [Hamza]: `git commit -m "feat(resource): add resource type model + schema loader"` + - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-resource-type-schema` to `master` with description "Add resource type domain model + YAML schema loader with tests and docs.". - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-core-models` -- [ ] **COMMIT (Owner: Hamza | Group: B1.core | Branch: feature/m2-resource-core-models) - Commit message: "feat(resource): add built-in physical resource type configs"** + - [ ] Git [Hamza]: `git branch -d feature/m1-resource-type-schema` + - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-core-models` + - [ ] 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 **physical** resource type YAML configs under `resources/types/` (M2 minimum set for source code only): - - `git-checkout` (user-addable; `--path`, optional `--branch`; default sandbox_strategy = `git_worktree`) - - `fs-mount` (user-addable; `--path`, optional `--read-only`) - - `fs-directory` + `fs-file` (auto-discovered children of `fs-mount`/`git-checkout`; not user-addable) - - [ ] Code [Hamza]: Include `schema_version`, `resource_kind: physical`, `sandbox_strategy`, and full allowed parent/child constraints per spec. - - [ ] Code [Hamza]: Define CLI argument specs for user-addable types (`git`, `git-checkout`, `fs-mount`, `fs-directory`) including `--path`, `--url`, `--branch`, `--mount-path`, `--read-only` as applicable. - - [ ] Code [Hamza]: Encode `auto_discover` rules for git and filesystem trees (git children + fs-directory children) with bounded depth and type filters. - - [ ] Code [Hamza]: Add bootstrap registration in `ResourceRegistryService` (register physical built-ins on startup if missing; idempotent). - - [ ] Docs [Hamza]: Update `docs/reference/resource_types_builtin.md` with physical type flags, parents/children, and examples. - - [ ] Tests (Behave) [Hamza]: Add scenarios ensuring physical built-ins exist and parent/child constraints are enforced. - - [ ] Tests (Robot) [Hamza]: Add Robot test that lists resource types and asserts physical built-ins are present. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_type_bootstrap_bench.py` for registration overhead. - - [ ] 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%. + - [ ] Code [Hamza]: Add built-in resource type configs 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. + - [ ] Tests (Robot) [Hamza]: Add Robot tests that load both built-in type YAML files. + - [ ] 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 built-in physical resource type configs"` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-core-models` to `master` with description "Add built-in physical resource type configs (git + fs) with discovery rules and docs.". + - [ ] 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 checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-core-models` -- [ ] **COMMIT (Owner: Hamza | Group: B1.core | Branch: feature/m2-resource-core-models) - Commit message: "feat(resource): add built-in virtual resource type configs"** + - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-core-models` + - [ ] Git [Hamza]: `git checkout -b feature/m1-project-db` - [ ] 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/` (M2 minimum set): `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 metadata for equivalence criteria (content hash/name/target) to support future auto-linking. - - [ ] Code [Hamza]: Extend bootstrap registration to include virtual types and hide them from `resource add` subcommand generation. - - [ ] Docs [Hamza]: Update `docs/reference/resource_types_builtin.md` with virtual type descriptions and link semantics. - - [ ] Tests (Behave) [Hamza]: Add scenarios ensuring virtual built-ins exist and cannot be user-added. - - [ ] Tests (Robot) [Hamza]: Add Robot test that lists resource types and asserts virtual built-ins are present. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_type_virtual_bench.py` for registry 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%. + - [ ] Code [Hamza]: Add Alembic migration for `projects` and `project_resource_links` with explicit down_revision to latest head. + - [ ] Code [Hamza]: Define `projects` columns: `namespaced_name` PK, `namespace`, `description`, `invariants_json` (nullable), `automation_profile` (nullable), `invariant_actor` (nullable), `context_policy_json` (nullable), `tags_json`, `created_by`, timestamps. + - [ ] Code [Hamza]: Define `project_resource_links` columns: `link_id` ULID, `project_name` FK, `resource_id` FK, `alias`, `read_only`, `created_at`. + - [ ] Code [Hamza]: Add uniqueness constraint on (`project_name`, `resource_id`) and index on (`project_name`, `alias`). + - [ ] Code [Hamza]: Add indexes on `project_resource_links.project_name` and `project_resource_links.resource_id` for joins. + - [ ] Code [Hamza]: Add ORM models `ProjectModel` and `ProjectResourceLinkModel` with `to_domain()`/`from_domain()` mapping to `NamespacedProject` + link model and proper JSON field handling. + - [ ] Docs [Hamza]: Document project tables and link constraints in `docs/reference/database_schema.md`. + - [ ] Tests (Behave) [Hamza]: Add migration scenarios verifying project tables and link uniqueness. + - [ ] Tests (Robot) [Hamza]: Add Robot migration smoke test that inserts a project and link row. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/project_migration_bench.py` for migration 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(resource): add built-in virtual resource type configs"` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-core-models` to `master` with description "Add built-in virtual resource type configs and registration rules.". + - [ ] Git [Hamza]: `git commit -m "feat(db): add projects and project links tables"` + - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-project-db` to `master` with description "Add projects + project_resource_links tables with constraints and migration tests.". - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-core-models` -- [ ] **COMMIT (Owner: Hamza | Group: B1.core | Branch: feature/m2-resource-core-models) - Commit message: "feat(domain): add project model v3 with linked resources"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-core-models` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Hamza]: Add `Project`, `ProjectResourceLink`, `ProjectValidationSummary` (derived from validation attachments), and `ProjectContextPolicy` models using namespaced name as the unique identifier (no ULID per spec). (delivered in PR #51 — NamespacedProject with ParsedName, LinkedResource, ContextConfig) - - [X] Code [Hamza]: Add fields for `invariants`, `invariant_actor`, `automation_profile`, and `context_views` (strategize/execute/apply/default). (delivered in PR #51) - - [X] Code [Hamza]: Add validation for resource link overrides (read_only flags, alias uniqueness, resource existence). (delivered in PR #51 — LinkedResource with project_read_only, alias) - - [X] Code [Hamza]: Add helpers to compute effective invariants and automation profile (project defaults). (delivered in PR #51) - - [X] Code [Hamza]: Define default context view policy when `context_views` is omitted (inherit from `default` view; explicit override per view). (delivered in PR #51 — ContextConfig) - - [X] Code [Hamza]: Enforce non-empty invariant text and deterministic ordering for project-level invariants. (delivered in PR #51) - - [ ] Docs [Hamza]: Add `docs/reference/project_model.md` describing resource linking, validation attachments, and context view policies. - - [X] Tests (Behave) [Hamza]: Add scenarios for project model validation, link overrides, and context view inheritance. (delivered in PR #51 — 48 namespaced_project_model scenarios) - - [ ] Tests (Robot) [Hamza]: Add Robot test that creates a Project object and prints serialized output. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/project_model_bench.py` for serialization/validation 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 .` - - [ ] Git [Hamza]: `git commit -m "feat(domain): add project model v3 with linked resources"` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-core-models` to `master` with description "Add project model v3 with resource links, invariants, and context view policy fields.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-core-models` -- [X] **COMMIT (Owner: Jeff | Group: B1.core | Branch: feature/m2-resource-core-db) - Commit message: "feat(db): add resource registry tables"** - done on 2026-02-13 + - [ ] Git [Hamza]: `git branch -d feature/m1-project-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%. + **LEGACY (completed, superseded by rebaseline)**: +- [X] **COMMIT (Owner: Jeff | Group: B1.core | Branch: feature/m2-resource-core-db | Done: Day 5, February 13, 2026 23:30:15 +0000) - Commit message: "feat(db): add resource registry tables"** - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m2-resource-core-db` @@ -2079,344 +2056,326 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Code [Jeff]: Add ORM models: `ResourceTypeModel`, `ResourceModel`, `ResourceEdgeModel` with relationships (type->resources, resource->parent_edges/child_edges) - [X] Docs [Jeff]: Update `docs/reference/database_schema.md` with resource registry tables and constraints. - [X] Tests (Behave) [Jeff]: Add migration scenarios verifying tables, indices, and edge uniqueness. (31 scenarios in `features/resource_registry_tables.feature`) - - [ ] Tests (Robot) [Jeff]: Add Robot migration smoke test using `nox -s db_migrate`. (Deferred - migration tested via Behave schema creation; Robot appropriate after full persistence layer) - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/resource_registry_migration_bench.py` for migration baseline. (4 benchmark classes: SchemaCreation, ResourceTypeInsert, ResourceInsert, ResourceEdgeQuery) - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, unit_tests 2264 scenarios passed (0 failures). - - [X] Quality [Jeff]: Verify coverage >=97%. (models.py 94% with combined tests, overall suite maintains 97%) - [X] Git [Jeff]: `git add .` - [X] Git [Jeff]: `git commit -m "feat(db): add resource registry tables"` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-resource-core-db` to `master` with description "Add resource registry tables, indexes, and migration tests.". - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m2-resource-core-db` + - [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%) -**Parallel Group B2: Project Persistence + Services [Hamza + Luis]** (depends on B1 domain models) -- [ ] **COMMIT (Owner: Jeff | Group: B2.persistence | Branch: feature/m2-projects-db) - Commit message: "feat(db): add projects and project links tables"** +- [ ] **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"** + - [ ] 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` + - [ ] Git [Brent]: `git checkout -b feature/m1-resource-db-robot-tests` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Brent]: Add `robot/resource_registry_migration.robot` smoke suite that runs `nox -s db_migrate` and validates `resource_types`, `resources`, and `resource_edges` tables exist. + - [ ] Docs [Brent]: Update `docs/reference/database_schema.md` to note the Robot migration smoke suite and how to run it. + - [ ] Tests (Behave) [Brent]: Add a migration scenario asserting resource registry tables exist after `nox -s db_migrate`. + - [ ] Tests (Robot) [Brent]: Add Robot test that verifies migration execution and table presence. + - [ ] Tests (ASV) [Brent]: Confirm `asv/benchmarks/resource_registry_migration_bench.py` still passes after the new Robot suite is added. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` + - [ ] Git [Brent]: `git commit -m "test(db): add resource registry robot smoke test"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-resource-db-robot-tests` to `master` with description "Add Robot migration smoke suite for resource registry tables with docs/tests.". + - [ ] Git [Brent]: `git checkout master` + - [ ] 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"** + - [ ] Git [Luis]: `git checkout master` + - [ ] Git [Luis]: `git pull origin master` + - [ ] Git [Luis]: `git checkout -b feature/m1-resource-repos` + - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Luis]: Implement `ResourceTypeRepository` CRUD with list filters (namespace, user_addable) and ordered output. + - [ ] Code [Luis]: Implement `ResourceRepository` CRUD with name/ULID resolution and type validation on create. + - [ ] Code [Luis]: Add repository helpers for `resolve_namespaced_name` and `resolve_ulid` with clear NotFound errors. + - [ ] Docs [Luis]: Document repository interfaces in `docs/reference/repositories.md` (resource types + resources). + - [ ] Tests (Behave) [Luis]: Add repository scenarios for create/get/list and invalid type rejection. + - [ ] Tests (Robot) [Luis]: Add Robot test that creates a resource and fetches it by name and ULID. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/resource_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 resource repositories"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-resource-repos` to `master` with description "Add resource repositories with name/ULID resolution, docs, and tests.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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"** + - [ ] Git [Luis]: `git checkout master` + - [ ] Git [Luis]: `git pull origin master` + - [ ] Git [Luis]: `git checkout -b feature/m1-project-repos` + - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Luis]: Implement `ProjectRepository` CRUD keyed by namespaced name with namespace filtering. + - [ ] Code [Luis]: Implement `ProjectResourceLinkRepository` with link create/list/remove and alias uniqueness enforcement. + - [ ] Docs [Luis]: Document project repositories and link semantics in `docs/reference/repositories.md`. + - [ ] Tests (Behave) [Luis]: Add scenarios for project create, link/unlink, and duplicate alias rejection. + - [ ] Tests (Robot) [Luis]: Add Robot test that links a resource and validates link list output. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/project_repository_bench.py` for link list 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 project repositories"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-project-repos` to `master` with description "Add project repositories + resource link repository with tests/docs.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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"** + - [ ] 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]: 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. + - [ ] Tests (Robot) [Luis]: Add Robot test that registers a git-checkout resource and links it to a project. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/resource_service_bench.py` for registry list operations. + - [ ] 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(service): wire resource registry and project services"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-resource-project-services` to `master` with description "Wire resource registry + project services with bootstrap registration and tests.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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)"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m2-projects-db` + - [ ] 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]: Add Alembic migration skeleton with explicit down_revision to latest A5.alpha head. - - [ ] Code [Jeff]: Define `projects` table with namespaced_name PK, namespace, description, automation_profile, invariant_actor, invariants_json, context_policy_json, tags_json, created_by, timestamps. - - [ ] Code [Jeff]: Add `projects` constraints for non-empty names, namespace/name derivation consistency, and unique namespaced_name. - - [ ] Code [Jeff]: Add explicit `context_policy_json` default (`{}`) and enforce JSON schema compatibility for future migrations. - - [ ] Code [Jeff]: Define `project_resource_links` table with link_id ULID, project_name FK, resource_id FK, alias, read_only, created_at. - - [ ] Code [Jeff]: Add uniqueness constraint on (project_name, resource_id) and index on (project_name, alias) for fast lookups. - - [ ] Code [Jeff]: Add indexes on `project_resource_links.project_name` and `project_resource_links.resource_id` for joins. - - [ ] Docs [Jeff]: Document project table schema and link semantics in `docs/reference/database_schema.md`. - - [ ] Tests (Behave) [Jeff]: Add migration scenarios verifying project tables, FK constraints, and unique link enforcement. - - [ ] Tests (Robot) [Jeff]: Add Robot test that inserts a project and link row and validates alias uniqueness. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/project_migration_bench.py` for migration baseline. - - [ ] 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%. - - [ ] Commit [Jeff]: `git commit -m "feat(db): add projects and project links tables"`. - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-projects-db` to `master` with description "Add projects + project_resource_links tables with constraints and migration tests.". + - [ ] Code [Jeff]: Implement `agents resource type list/show` for built-in types with `--format json/yaml` output. + - [ ] Code [Jeff]: Implement `agents resource add git-checkout --path [--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] ` 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. + - [ ] 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. + - [ ] Git [Jeff]: `git add .` + - [ ] Git [Jeff]: `git commit -m "feat(cli): add resource commands (core)"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-resource-cli` to `master` with description "Add core resource CLI commands (type list/show, add, list, show) with tests/docs.". - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m2-projects-db` -- [ ] **COMMIT (Owner: Hamza | Group: B2.persistence | Branch: feature/m2-resource-project-repos) - Commit message: "feat(repo): add resource repositories"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-project-repos` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `ResourceTypeRepository` CRUD and `ResourceRepository` CRUD with DAG edge helpers. - - [ ] Code [Hamza]: Add methods for tree traversal, child discovery queries, and name/ULID resolution. - - [ ] Code [Hamza]: Add repository guardrails for preventing cycles and duplicate edges. - - [ ] Code [Hamza]: Add repository methods for `resolve_namespaced_name` and `resolve_ulid` with clear NotFound errors. - - [ ] Docs [Hamza]: Document repository interfaces in `docs/reference/repositories.md`. - - [ ] Tests (Behave) [Hamza]: Add repository scenarios for create/get/list/tree and cycle rejection. - - [ ] Tests (Robot) [Hamza]: Add Robot test exercising tree output ordering. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_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%. - - [ ] Commit [Hamza]: `git commit -m "feat(repo): add resource repositories"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-project-repos` to `master` with description "Add resource repositories with DAG helpers, docs, and tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-project-repos` -- [ ] **COMMIT (Owner: Hamza | Group: B2.persistence | Branch: feature/m2-resource-project-repos) - Commit message: "feat(repo): add project repositories"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-project-repos` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `ProjectRepository` and `ProjectResourceLinkRepository` with namespace filtering and name-based lookup. - - [ ] Code [Hamza]: Add methods to list project context policies and derived validation attachment summaries for linked resources. - - [ ] Code [Hamza]: Enforce resource existence + type validation when linking (reject missing resource IDs early). - - [ ] Docs [Hamza]: Update repository docs with project link examples and validation attachment notes. - - [ ] Tests (Behave) [Hamza]: Add scenarios for project create/link/unlink and validation attachment summaries. - - [ ] Tests (Robot) [Hamza]: Add Robot test that links two resources to one project. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/project_repository_bench.py` for link/unlink 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(repo): add project repositories"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-project-repos` to `master` with description "Add project repositories + link repositories with docs and tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-project-repos` -- [ ] **COMMIT (Owner: Hamza | Group: B2.service | Branch: feature/m2-resource-registry-service) - Commit message: "feat(service): add resource registry service"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-registry-service` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `ResourceRegistryService` for register/remove/show/tree operations with name/ULID resolution. - - [ ] Code [Hamza]: Add auto-discovery hook that delegates to resource handlers (git-checkout for MVP). - - [ ] Code [Hamza]: Add validation that resource type supports parent/child linkage before linking. - - [ ] Code [Hamza]: Ensure `register` returns the persisted resource with ULID + resolved namespaced name for CLI output consistency. - - [ ] Docs [Hamza]: Add `docs/reference/resource_registry.md` describing API behavior and error cases. - - [ ] Tests (Behave) [Hamza]: Add scenarios for register/remove/show/tree behavior and auto-discovery. - - [ ] Tests (Robot) [Hamza]: Add Robot test that registers a git-checkout and inspects child count. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_registry_service_bench.py` for register/show 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(service): add resource registry service"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-registry-service` to `master` with description "Add resource registry service with auto-discovery and tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-registry-service` -- [ ] **COMMIT (Owner: Luis | Group: B2.service | Branch: feature/m2-project-service) - Commit message: "feat(service): add project service v3"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m2-project-service` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement `ProjectService` create/list/show/delete/link/unlink methods using repositories. - - [ ] Code [Luis]: Add validation attachment helpers (read-only listing of validation attachments for linked resources) and context policy setters for project views. - - [ ] Code [Luis]: Enforce read-only resource links and project-level invariant actor defaults. - - [ ] Code [Luis]: Enforce namespaced project naming on create and reject duplicate names with explicit error details. - - [ ] Docs [Luis]: Update `docs/reference/project_service.md` with usage examples and error cases. - - [ ] Tests (Behave) [Luis]: Add scenarios for project create/link/unlink/context policy + validation attachment visibility. - - [ ] Tests (Robot) [Luis]: Add Robot test that creates project and links a resource. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/project_service_bench.py` for link/unlink 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%. - - [ ] Commit [Luis]: `git commit -m "feat(service): add project service v3"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-project-service` to `master` with description "Add project service v3 with linking, invariants, and context policy helpers.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m2-project-service` + - [ ] 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%. -**Parallel Group B3: CLI Commands [Hamza]** (depends on B2 services) -- [ ] **COMMIT (Owner: Hamza | Group: B3.cli | Branch: feature/m2-project-resource-cli) - Commit message: "feat(cli): add resource type commands"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-project-resource-cli` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add `agents resource type add/remove/list/show` commands with YAML config input, schema validation, and clear field-path errors. - - [ ] Code [Hamza]: Implement `--update` behavior with conflict detection and explicit `name` mismatch errors. - - [ ] Code [Hamza]: Wire `resource type add` to `ResourceTypeSpec` loader with schema version guard and path resolution. - - [ ] Code [Hamza]: Ensure `resource type list` supports `--type` and `--regex` filters with stable ordering + `--format json/yaml`. - - [ ] Code [Hamza]: Include `resource_kind`, `sandbox_strategy`, `user_addable`, and `handler` in `resource type show` output. - - [ ] Docs [Hamza]: Update CLI reference with resource type examples and expected output columns. - - [ ] Tests (Behave) [Hamza]: Add scenarios for resource type lifecycle, update conflicts, and invalid schema handling. - - [ ] Tests (Robot) [Hamza]: Add Robot suite `robot/resource_type_cli.robot`. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_type_cli_bench.py` for config parsing overhead. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add resource type commands"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-project-resource-cli` to `master` with description "Add resource type CLI commands with schema validation and tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-project-resource-cli` -- [ ] **COMMIT (Owner: Hamza | Group: B3.cli | Branch: feature/m2-project-resource-cli) - Commit message: "feat(cli): add resource commands"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-project-resource-cli` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add `agents resource add/remove/list/show/tree` commands with type-specific flags and name/ULID resolution. - - [ ] Code [Hamza]: Implement dynamic option parsing for type-specific flags from ResourceTypeSpec (including repeatable args). - - [ ] Code [Hamza]: Implement `resource inspect --tree/--file` per spec for resource introspection and path-scoped views. - - [ ] Code [Hamza]: Add `resource link-child` and `resource unlink-child` commands with type compatibility validation. - - [ ] Code [Hamza]: Ensure `resource show` includes `resource_kind`, `sandbox_strategy`, `read_only`, and parent/child counts. - - [ ] Docs [Hamza]: Update CLI reference with resource examples (git-checkout, fs-directory) and output columns. - - [ ] Tests (Behave) [Hamza]: Add scenarios for resource registration, list filters, tree rendering, and link-child constraints. - - [ ] Tests (Robot) [Hamza]: Add Robot suite `robot/resource_cli.robot`. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_cli_bench.py` for command parsing and list output. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add resource commands"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-project-resource-cli` to `master` with description "Add resource CLI commands (add/show/list/tree/inspect/link-child) with tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-project-resource-cli` -- [ ] **COMMIT (Owner: Hamza | Group: B3.cli | Branch: feature/m2-project-resource-cli) - Commit message: "feat(cli): add project commands"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-project-resource-cli` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add `agents project create/show/list/delete/link-resource/unlink-resource` commands using namespaced project names. - - [ ] Code [Hamza]: Implement `project create` flags for `--description`, `--resource`, `--invariant`, `--invariant-actor`, and `--automation-profile`. - - [ ] Code [Hamza]: Ensure `project show` includes linked resources, read_only flags, aliases, and validation attachment summaries. - - [ ] Code [Hamza]: Ensure `project list` includes resource counts, invariant counts, and automation profile summaries. - - [ ] Docs [Hamza]: Update CLI reference with project examples and validation attachment visibility (via `agents validation attach`). - - [ ] Tests (Behave) [Hamza]: Add scenarios for project create/link/unlink/show/list/delete and validation display. - - [ ] Tests (Robot) [Hamza]: Add Robot suite `robot/project_cli.robot`. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/project_cli_bench.py` for command parsing and list output. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add project commands"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-project-resource-cli` to `master` with description "Add project CLI commands (create/show/list/link/unlink) with validation attachment summaries.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-project-resource-cli` - -**Parallel Group B3.context: Project Context Views [Hamza]** (depends on B1 project model + B2 services; post-M2) - **PARALLEL SUBTRACK B3.context.service [Hamza]**: Context policy service + persistence helpers - **PARALLEL SUBTRACK B3.context.cli [Hamza]**: CLI commands for context set/show/inspect/simulate - **SEQUENTIAL NOTE**: B3.context.service must land before B3.context.cli to lock policy serialization and defaults. -- [ ] **COMMIT (Owner: Hamza | Group: B3.context.service | Branch: feature/m3-project-context-policy) - Commit message: "feat(service): add project context policy service"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m3-project-context-policy` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement ProjectContextPolicy serialization (include/exclude resources, include/exclude paths, token budgets, summarize flags, summary max tokens, strategy list, depth gradients, skeleton ratio). - - [ ] Code [Hamza]: Add ProjectContextService helpers to set/clear/show/inspect policy and compute effective view defaults. - - [ ] Code [Hamza]: Add validation for invalid resource refs, conflicting include/exclude, and max token bounds. - - [ ] Docs [Hamza]: Add `docs/reference/project_context_policy.md` with flag mapping and defaults. - - [ ] Tests (Behave) [Hamza]: Add scenarios for policy validation, defaults, and serialization round-trip. - - [ ] Tests (Robot) [Hamza]: Add Robot smoke tests for policy persistence. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/project_context_policy_bench.py` for policy parse overhead. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(service): add project context policy service"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m3-project-context-policy` to `master` with description "Add project context policy service with serialization, defaults, and tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m3-project-context-policy` -- [ ] **COMMIT (Owner: Hamza | Group: B3.context.cli | Branch: feature/m3-project-context-cli) - Commit message: "feat(cli): add project context set/show/inspect/simulate"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m3-project-context-cli` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `agents project context set/show/inspect/simulate` with full flag set per spec (view, include/exclude resource, include/exclude path, budget limits, default breadth/depth, depth gradients, temporal scope, auto-refresh, summarize flags, summary max tokens, strategy list). - - [ ] Code [Hamza]: Add validation for mutually exclusive flags and display `--clear` behavior explicitly in output. - - [ ] Code [Hamza]: Ensure `context inspect` shows resolved policy + derived budgets; `context simulate` prints estimated payload size + token budget allocation. - - [ ] Docs [Hamza]: Update CLI reference with context command examples and default behaviors. - - [ ] Tests (Behave) [Hamza]: Add scenarios for set/show/inspect/simulate including invalid flags and default view inheritance. - - [ ] Tests (Robot) [Hamza]: Add `robot/project_context_cli.robot` for context commands. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/project_context_cli_bench.py` for command parsing. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add project context set/show/inspect/simulate"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m3-project-context-cli` to `master` with description "Add project context CLI commands (set/show/inspect/simulate) with tests.". - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m3-project-context-cli` - -**Parallel Group B3.cleanup: Legacy Project Removal [Jeff]** (after B3.cli lands) - -- [ ] **COMMIT (Owner: Jeff | Group: B3.cleanup | Branch: feature/m2-project-legacy-cleanup) - Commit message: "refactor(project): remove legacy project init/status commands"** +- [ ] **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)"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m2-project-legacy-cleanup` + - [ ] 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]: Remove legacy `agents project init/status/clean/file-filter` commands from `src/cleveragents/cli/commands/project.py`. - - [ ] Code [Jeff]: Remove or alias legacy `agents context` commands to `agents project context` to match spec surface. - - [ ] Code [Jeff]: Remove `.cleveragents` directory bootstrap logic from legacy `ProjectService` and deprecate `ProjectSettings` fields tied to local init. - - [ ] Code [Jeff]: Update `src/cleveragents/application/container.py` to stop wiring legacy ProjectService once v3 service is in place. - - [ ] Code [Jeff]: Remove legacy `src/cleveragents/domain/models/core/project.py` in favor of v3 project model and update imports. - - [ ] Docs [Jeff]: Remove references to `agents project init` from CLI docs and point to `agents project create` + `agents init` (global) flows. - - [ ] Tests (Behave) [Jeff]: Remove/replace legacy project init scenarios with v3 project create scenarios. - - [ ] Tests (Robot) [Jeff]: Remove legacy project init Robot suites and add v3 replacements if missing. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/project_cli_cleanup_bench.py` for CLI help/rendering baseline after removal. - - [ ] 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%. - - [ ] Commit [Jeff]: `git commit -m "refactor(project): remove legacy project init/status commands"`. - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-project-legacy-cleanup` to `master` with description "Remove legacy project init/status commands and align CLI to v3 project flows.". + - [ ] Code [Jeff]: Implement `agents project create [--description ] [--resource ]...` with namespaced name validation. + - [ ] Code [Jeff]: Implement `agents project link-resource [--read-only] ` with alias support. + - [ ] Code [Jeff]: Implement `agents project unlink-resource [--yes] ` with clear not-found errors. + - [ ] Code [Jeff]: Implement `agents project list` and `agents project show` with linked resources and basic metadata. + - [ ] Code [Jeff]: Implement `agents project delete [--force] [--yes] ` (hard delete from registry only). + - [ ] Docs [Jeff]: Update CLI reference with project create/link/list/show examples. + - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for project create, link-resource, unlink-resource, delete, and list/show outputs. + - [ ] Tests (Robot) [Jeff]: Add Robot CLI test that creates a project, links a resource, unlinks, and deletes the project. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/project_cli_bench.py` for CLI parsing 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(cli): add project commands (core)"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-project-cli` to `master` with description "Add core project CLI commands (create/link/list/show) with tests/docs.". - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m2-project-legacy-cleanup` + - [ ] Git [Jeff]: `git branch -d feature/m1-project-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%. -**Parallel Group B4: Sandboxing [Luis + Jeff]** (depends on resource registry + project links) -- [ ] **COMMIT (Owner: Luis | Group: B4.sandbox | Branch: feature/m2-sandbox-core) - Commit message: "feat(sandbox): add sandbox strategy interface and manager"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m2-sandbox-core` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Luis]: Add `SandboxStrategy` protocol, `SandboxRef`, `SandboxManager`, and `SandboxRegistry` with per-resource sandboxes. (protocol, factory, manager, NoSandbox, merge strategies, status enum all implemented) - - [X] Code [Luis]: Implement lazy sandbox creation, cleanup hooks, and plan-scoped retention policy stubs. (completed by Luis) - - [ ] Code [Luis]: Add sandbox path rewriting helper for tool execution and MCP adapters. - - [ ] Code [Luis]: Include `resource_id`, `plan_id`, and `sandbox_path` in `SandboxRef` for traceability in logs. - - [ ] Docs [Luis]: Add `docs/reference/sandbox.md` describing lifecycle, APIs, and path rewriting rules. - - [ ] Tests (Behave) [Luis]: Add scenarios for sandbox manager creation, cleanup, and path rewrite behavior. - - [ ] Tests (Robot) [Luis]: Add Robot test that creates a sandbox and verifies filesystem isolation. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/sandbox_manager_bench.py` for sandbox creation 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%. - - [ ] Commit [Luis]: `git commit -m "feat(sandbox): add sandbox strategy interface and manager"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-sandbox-core` to `master` with description "Add sandbox strategy interface, manager, and docs/tests for path rewriting.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m2-sandbox-core` -- [ ] **COMMIT (Owner: Luis | Group: B4.sandbox | Branch: feature/m2-sandbox-core) - Commit message: "feat(sandbox): implement git_worktree strategy"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m2-sandbox-core` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement git worktree creation, checkout, and cleanup for git-checkout resources. - - [ ] Code [Luis]: Add safe fallback for repositories without clean worktrees and clear error messages. - - [ ] Code [Luis]: Record sandbox metadata (worktree path, branch, base commit) for rollback. - - [ ] Code [Luis]: Name worktree branches using plan ULID to avoid collisions across concurrent plans. - - [ ] Docs [Luis]: Update sandbox doc with git_worktree usage and rollback behavior. - - [ ] Tests (Behave) [Luis]: Add scenarios for git worktree sandbox creation and rollback. - - [ ] Tests (Robot) [Luis]: Add Robot test that modifies sandbox and verifies original repo unchanged. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/git_worktree_bench.py` for sandbox creation time. - - [ ] 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%. - - [ ] Commit [Luis]: `git commit -m "feat(sandbox): implement git_worktree strategy"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-sandbox-core` to `master` with description "Implement git_worktree sandbox strategy with rollback metadata and tests.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m2-sandbox-core` -- [ ] **COMMIT (Owner: Hamza | Group: B4.sandbox | Branch: feature/m2-resource-git-handler) - Commit message: "feat(resource): add git-checkout handler and discovery"** +- [X] **COMMIT (Owner: Hamza | Group: B0.sandbox | Branch: feature/m1-sandbox-git-worktree | Done: Day 5, February 13, 2026 23:17:53 +0000) - Commit message: "feat(sandbox): add git_worktree and copy_on_write sandbox strategies"** + - [X] Code [Hamza]: Implement `GitWorktreeSandbox` + `CopyOnWriteSandbox` and wire into `SandboxFactory`. + - [X] Tests (Behave) [Hamza]: Add sandbox lifecycle + isolation scenarios for git_worktree/copy_on_write. + - [X] Quality [Hamza]: Run `nox` and ensure sandbox suites pass. + - [X] Git [Hamza]: `git commit -m "feat(sandbox): add git_worktree and copy_on_write sandbox strategies"` + +- [X] **COMMIT (Owner: Hamza | Group: B0.sandbox.fix | Branch: feature/m1-sandbox-git-worktree | Done: Day 6, February 14, 2026 00:34:24 +0000) - Commit message: "fix(sandbox): fix CI failures in git_worktree and factory integration tests"** + - [X] Code [Hamza]: Fix git_worktree path handling + factory integration edge cases observed in CI. + - [X] Tests (Robot) [Hamza]: Stabilize integration tests for sandbox factory. + - [X] Quality [Hamza]: Run `nox -s integration_tests` to confirm CI parity. + - [X] Git [Hamza]: `git commit -m "fix(sandbox): fix CI failures in git_worktree and factory integration tests"` + +**Parallel Group B1: Resource DAG + Auto-Discovery (M2)** + **PARALLEL SUBTRACK B1.types [Hamza]**: fs-mount/fs-directory built-ins + auto_discover rules + **PARALLEL SUBTRACK B1.dag [Luis]**: DAG constraints + link/unlink operations + **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"** - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-git-handler` + - [ ] 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 git-checkout handler that validates repo path, branch, and read_only flags. - - [ ] Code [Hamza]: Implement child resource discovery for fs-directory children (schema-only for now) and record ULID-only children. - - [ ] Code [Hamza]: Add sandbox strategy mapping for git-checkout and path normalization helpers. - - [ ] Code [Hamza]: Return explicit error when repo path is missing or not a git repo (include path in message). - - [ ] Docs [Hamza]: Document git-checkout handler behavior in `docs/reference/resources_git.md`. - - [ ] Tests (Behave) [Hamza]: Add scenarios for handler validation and discovery counts. - - [ ] Tests (Robot) [Hamza]: Add Robot test registering a git repo and asserting discovered children. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/git_discovery_bench.py` for discovery cost. - - [ ] 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%. - - [ ] Commit [Hamza]: `git commit -m "feat(resource): add git-checkout handler and discovery"`. - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-git-handler` to `master` with description "Add git-checkout resource handler with discovery and tests.". + - [ ] Code [Hamza]: Add `resources/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. + - [ ] Tests (Robot) [Hamza]: Add Robot test that loads fs-mount built-in types. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_fs_bench.py` for YAML load 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(resource): add fs-mount and fs-directory types"` + - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-types` to `master` with description "Add fs-mount/fs-directory built-in resource types with auto-discovery rules.". - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git branch -d feature/m2-resource-git-handler` -- [ ] **COMMIT (Owner: Luis | Group: B4.sandbox | Branch: feature/m2-sandbox-core) - Commit message: "feat(sandbox): add copy_on_write strategy stub"** + - [ ] 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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m2-sandbox-core` + - [ ] Git [Luis]: `git checkout -b feature/m2-resource-dag` - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add copy_on_write strategy skeleton with TODOs for large-project optimization. - - [ ] Code [Luis]: Raise explicit NotImplementedError with guidance on when it will be available. - - [ ] Docs [Luis]: Document that copy_on_write is stubbed for post-M1 work. - - [ ] Docs [Luis]: Add a CLI note in `docs/reference/sandbox.md` showing the exact error message returned by the stub. - - [ ] Tests (Behave) [Luis]: Add scenario that selecting copy_on_write raises NotImplementedError with clear message. - - [ ] Tests (Robot) [Luis]: Add Robot test verifying stub error output. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/sandbox_stub_bench.py` (baseline no-op). - - [ ] 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%. - - [ ] Commit [Luis]: `git commit -m "feat(sandbox): add copy_on_write strategy stub"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-sandbox-core` to `master` with description "Add copy_on_write sandbox strategy stub with explicit NotImplementedError and tests.". + - [ ] Code [Luis]: Implement `link_child`/`unlink_child` in `ResourceRepository` with cycle detection and type compatibility enforcement. + - [ ] Code [Luis]: Add `auto_discover_children(resource_id)` that materializes child resources per type rules. + - [ ] Docs [Luis]: Document DAG rules and auto-discovery behavior in `docs/reference/resource_dag.md`. + - [ ] Tests (Behave) [Luis]: Add scenarios for link/unlink, cycle rejection, and auto_discover creation. + - [ ] Tests (Robot) [Luis]: Add Robot test that links a child and verifies tree output ordering. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/resource_dag_bench.py` for link/auto_discover 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(resource): add DAG linking and discovery"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-resource-dag` to `master` with description "Add resource DAG linking, cycle checks, and auto-discovery with tests/docs.". - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m2-sandbox-core` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m2-resource-cli-extensions` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Implement `agents resource tree` with `--depth` and `--type` filters. + - [ ] Code [Jeff]: Implement `agents resource inspect` with `--tree` and `--file` options for git-checkout/fs-mount. + - [ ] Code [Jeff]: Implement `agents resource link-child`/`unlink-child` to manage DAG edges. + - [ ] Docs [Jeff]: Update CLI reference with resource tree/inspect/link examples. + - [ ] Tests (Behave) [Jeff]: Add scenarios for tree output ordering and link-child error cases. + - [ ] Tests (Robot) [Jeff]: Add Robot test that runs resource tree/inspect on a git-checkout resource. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/resource_cli_tree_bench.py` for CLI overhead baseline. + - [ ] 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(cli): add resource tree and inspect commands"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-resource-cli-extensions` to `master` with description "Add resource tree/inspect/link CLI commands with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m2-resource-cli-extensions` + - [ ] 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 B2: Project Context Policies (M3)** + **PARALLEL SUBTRACK B2.model [Luis]**: Project context policy model + persistence fields + **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"** + - [ ] Git [Luis]: `git checkout master` + - [ ] Git [Luis]: `git pull origin master` + - [ ] Git [Luis]: `git checkout -b feature/m3-project-context-model` + - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Luis]: Add `ProjectContextPolicy` model with `default`/`strategize`/`execute`/`apply` view inheritance rules. + - [ ] Code [Luis]: Add validation for include/exclude resources, include/exclude path globs, and size limits. + - [ ] Docs [Luis]: Add `docs/reference/project_context_policy.md` with view inheritance examples. + - [ ] Tests (Behave) [Luis]: Add scenarios for view inheritance, empty policy defaulting, and invalid values. + - [ ] Tests (Robot) [Luis]: Add Robot test that serializes a policy and validates structure. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/project_context_policy_bench.py` for validation overhead. + - [ ] 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(project): add context policy model"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-project-context-model` to `master` with description "Add project context policy model + validation with tests/docs.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m3-project-context-cli` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Implement `agents project context set/show` to persist and display context policy views. + - [ ] Code [Jeff]: Stub `agents project context inspect/simulate` with `NotImplementedError` and clear messaging (ACMS wiring later). + - [ ] Docs [Jeff]: Update CLI reference with project context commands and stub notes. + - [ ] Tests (Behave) [Jeff]: Add scenarios for context set/show and stub errors for inspect/simulate. + - [ ] Tests (Robot) [Jeff]: Add Robot CLI test that sets and shows context policy. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/project_context_cli_bench.py` for CLI parsing baseline. + - [ ] 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(cli): add project context commands"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-project-context-cli` to `master` with description "Add project context CLI set/show and stub inspect/simulate with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m3-project-context-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%. **M2 MERGE GATE**: - Register a git-checkout resource and link it to a project via CLI. -- Create a sandbox for the linked resource and verify isolation via tests. -- Project context commands and validation attachment visibility work and persist. -- `nox` passes with coverage >=97%. +- Resource DAG operations (link-child/unlink-child + tree) pass tests for git-checkout/fs-mount. +- `nox` passes with coverage >=97% across resource/project suites. **M2 SUCCESS CRITERIA**: - Resource registry supports resource types, resources, and DAG links with persistence (tables + repositories). -- Projects can link/unlink resources with CLI commands for resource types/resources/projects (list/show/tree included). -- Validation attachments (via `agents validation attach/detach`) appear in `project show` outputs. -- Git-checkout sandbox isolates changes; copy_on_write strategy returns clear NotImplementedError for fs-directory (documented). -- Resource/project services are DI-wired and exercised by Behave + Robot suites. -- `nox` passes with coverage >=97% across resource/project suites. +- Projects can link/unlink resources with CLI commands; resource tree/inspect works for git-checkout/fs-mount. +- fs-mount + auto-discovery flows are available for source-code resources. +- Git-checkout sandbox isolates changes; M2 resource CLI commands are covered by Behave + Robot tests. + --- ### Section 5: Actors, Skills & Tool Execution [WORKSTREAM C - Aditya Lead] -**Target: Milestone M3 (+14 days)** +**Target: Milestones M1-M3 (M1 minimal tool runtime, M3 full registry)** -**Week 2 focus**: Actor YAML, compilation, skills, and tool-based change tracking. +**Week 1 focus**: minimal built-in tool runtime for file operations + ChangeSet capture. **Week 2 focus**: Actor YAML, compilation, skills, and full tool/validation registry. -**Parallel Group C0: Tool Registry + Validation System [Jeff + Luis]** (start Day 5; precedes C1/C3) - **PARALLEL SUBTRACK C0.domain [Jeff]**: Tool + Validation domain models + schemas - **PARALLEL SUBTRACK C0.registry [Luis]**: Tool registry persistence + repositories - **PARALLEL SUBTRACK C0.cli [Jeff]**: CLI commands for tools/validations - **SEQUENTIAL MERGE NOTE**: C0.domain must land before C0.registry/cli; C0.registry before C3 context wiring. C0.registry migrations must rebase after A5.alpha; C0.binding should wait for B1.core resource type constraints to validate bindings. -- [X] **COMMIT (Owner: Jeff | Group: C0.domain | Branch: feature/m3-tool-domain) - Commit message: "feat(tool): add tool and validation domain models"** - done on 2026-02-13 +**Parallel Group C0: Tool Runtime Core (M1-critical)** + **PARALLEL SUBTRACK C0.runtime [Jeff]**: Tool runtime core + in-memory registry (M1) + **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. + +- [ ] **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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m1-tool-runtime-core` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add `ToolSpec`, `ToolResult`, and `ToolError` models with namespaced tool names, JSON Schema inputs/outputs, and capability metadata (`read_only`, `writes`, `checkpointable`). + - [ ] Code [Jeff]: Implement `ToolRunner` with lifecycle hooks (`discover/activate/execute/deactivate`), strict JSON-serializable IO, and error normalization. + - [ ] Code [Jeff]: Add in-memory `ToolRegistry` for built-ins with list/show lookup by namespaced name and type (tool/validation). + - [ ] Docs [Jeff]: Add `docs/reference/tool_runtime.md` describing tool lifecycle, capability flags, and error/result semantics. + - [ ] Tests (Behave) [Jeff]: Add scenarios for tool registration, missing tool errors, capability flag validation, and lifecycle hook ordering. + - [ ] Tests (Robot) [Jeff]: Add Robot test that registers a mock tool and executes it via ToolRunner. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/tool_runtime_bench.py` for tool execution overhead baseline. + - [ ] 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(tool): add tool runtime core"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-tool-runtime-core` to `master` with description "Add tool runtime core + in-memory registry with docs/tests for M1.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m1-tool-runtime-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: Jeff | Group: C0.files | Branch: feature/m1-tool-builtins | Planned: Day 8 | Expected: Day 11) - Commit message: "feat(tool): add built-in file tools"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m1-tool-builtins` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add built-in file tools (`file.read`, `file.write`, `file.edit`, `file.delete`, `file.list`, `file.search`) with namespaced names. + - [ ] Code [Jeff]: Require resource bindings to `fs-directory`/`git-checkout` slots and resolve worktree root for git-checkout. + - [ ] Code [Jeff]: Wire built-in tools to ChangeSet capture hooks (create/modify/delete/move events) and include file metadata in entries. + - [ ] Docs [Jeff]: Add `docs/reference/builtin_tools.md` describing file tool inputs/outputs and resource slot requirements. + - [ ] Tests (Behave) [Jeff]: Add scenarios for each file tool, resource binding resolution, and ChangeSet integration. + - [ ] Tests (Robot) [Jeff]: Add Robot test that runs file.write on a git-checkout sandbox and verifies ChangeSet output. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/tool_builtin_file_bench.py` for file tool latency baseline. + - [ ] 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(tool): add built-in file tools"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-tool-builtins` to `master` with description "Add built-in file tools and ChangeSet capture wiring with docs/tests.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m1-tool-builtins` + - [ ] 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.tool: Tool + Validation Registry (M2-M3)** + **PARALLEL SUBTRACK C1.tool.domain [Jeff]**: Tool/Validation domain models + schemas + **PARALLEL SUBTRACK C1.tool.domain.tests [Brent]**: Robot smoke tests for tool/validation domain model + **PARALLEL SUBTRACK C1.tool.registry [Luis]**: Persistence + repositories + **PARALLEL SUBTRACK C1.tool.binding [Jeff]**: Resource binding resolution + **PARALLEL SUBTRACK C1.tool.cli [Jeff]**: CLI commands for tools/validations + **SEQUENTIAL MERGE NOTE**: C1.tool.domain → C1.tool.registry → C1.tool.binding → C1.tool.cli. + +- [X] **COMMIT (Owner: Jeff | Group: C1.tool.domain | Branch: feature/m3-tool-domain | Done: Day 5, February 13, 2026 21:41:16 +0000) - Commit message: "feat(tool): add tool and validation domain models"** - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m3-tool-domain` @@ -2434,77 +2393,83 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Code [Jeff]: Add example configs under `examples/tools/` and `examples/validations/` (plain tool, validation, wrapped validation) for tests. - [X] Docs [Jeff]: Add `docs/reference/tool_model.md` and `docs/reference/validation_model.md` with examples. - [X] Tests (Behave) [Jeff]: Add `features/tool_model.feature` for schema validation, resource binding rules, validation constraints, and YAML loader errors. (60 scenarios, 163 steps) - - [ ] Tests (Robot) [Jeff]: Add `robot/tool_model.robot` smoke tests for model creation. (Deferred - domain model tests are fully covered by Behave; Robot tests more appropriate after registry integration) - [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] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage is 97% overall (tool.py 99% coverage). - [X] Git [Jeff]: `git add .` (only after coverage check passes) - [X] Commit [Jeff]: `git commit -m "feat(tool): add tool and validation domain models"`. - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-domain` to `master` with description "Add tool + validation domain models, schema loaders, and tests.". - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m3-tool-domain` -- [ ] **COMMIT (Owner: Luis | Group: C0.registry | Branch: feature/m3-tool-registry) - Commit message: "feat(tool): add tool registry persistence"** + - [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"** + - [ ] 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` + - [ ] Git [Brent]: `git checkout -b feature/m3-tool-domain-robot` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Brent]: Add `robot/tool_model.robot` smoke tests for Tool/Validation model creation and YAML loader outputs. + - [ ] Docs [Brent]: Update `docs/reference/tool_model.md` to mention the Robot smoke suite and how to run it. + - [ ] Tests (Behave) [Brent]: Add a scenario in `features/tool_model.feature` that mirrors the Robot smoke expectations for YAML loader outputs. + - [ ] Tests (Robot) [Brent]: Add Robot suite that validates tool model creation and validation constraints. + - [ ] Tests (ASV) [Brent]: Confirm `benchmarks/tool_model_bench.py` still passes after the new Robot suite is added. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` + - [ ] Git [Brent]: `git commit -m "test(tool): add robot tool model smoke tests"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-tool-domain-robot` to `master` with description "Add Robot smoke tests for tool/validation domain models with docs and Behave alignment.". + - [ ] Git [Brent]: `git checkout master` + - [ ] 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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` - [ ] Git [Luis]: `git checkout -b feature/m3-tool-registry` - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add DB tables for `tools`, `tool_bindings`, and `validation_attachments` with indexes on namespaced name and type. - - [ ] Code [Luis]: Define `tools` columns: `namespaced_name`, `namespace`, `tool_type`, `source`, `description`, `input_schema_json`, `output_schema_json`, `capability_json`, `metadata_json`, `yaml_text`, timestamps. - - [ ] Code [Luis]: Define `tool_bindings` columns: `binding_id` ULID, `tool_name`, `slot_name`, `binding_mode`, `resource_type`, `required`, `static_resource_id`, `static_resource_name`, timestamps. - - [ ] Code [Luis]: Define `validation_attachments` columns: `attachment_id` ULID, `validation_name`, `resource_id`, optional `project_name`, optional `plan_id`, `args_json`, timestamps. - - [ ] Code [Luis]: Enforce cross-type name uniqueness (tool vs validation) at persistence and service layers. - - [ ] Code [Luis]: Enforce validation attachment scope rules (always resource-bound; optional project/plan only). - - [ ] Code [Luis]: Persist original YAML text for auditability and re-render it on `tool show` output. - - [ ] Code [Luis]: Add uniqueness constraints for `tools.namespaced_name` and `tool_bindings(tool_name, slot_name)`; index `validation_attachments.resource_id`. - - [ ] Code [Luis]: Implement ToolRepository + ValidationAttachmentRepository with list/show filters and eager-loading of bindings. - - [ ] Code [Luis]: Add ToolRegistryService for register/update/remove/list/show with name conflict checks and tool/validation type enforcement. - - [ ] Docs [Luis]: Update `docs/reference/database_schema.md` with tool/validation tables. - - [ ] Tests (Behave) [Luis]: Add `features/tool_registry.feature` for register/update/remove and validation-only constraints. + - [ ] Code [Luis]: Add DB tables for `tools`, `tool_bindings`, and `validation_attachments` with resource-scoped attachments (`resource_id`, `validation_name`, `mode`, `created_at`) and indexes on tool name/type + resource_id. + - [ ] Code [Luis]: Implement ToolRepository + ValidationAttachmentRepository and ToolRegistryService with attach/detach by resource and mode validation (required/informational). + - [ ] Docs [Luis]: Update `docs/reference/database_schema.md` with tool/validation tables and constraints. + - [ ] Tests (Behave) [Luis]: Add `features/tool_registry.feature` for register/update/remove and attachment rules. - [ ] Tests (Robot) [Luis]: Add `robot/tool_registry.robot` for list/show smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/tool_registry_bench.py` for registry list 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(tool): add tool registry persistence"`. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/tool_registry_bench.py` for registry list 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(tool): add tool registry persistence"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-tool-registry` to `master` with description "Add tool registry persistence with bindings and validation attachments.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m3-tool-registry` -- [ ] **COMMIT (Owner: Jeff | Group: C0.binding | Branch: feature/m3-tool-binding) - Commit message: "feat(tool): add resource binding resolution"** + - [ ] 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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-binding` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - [ ] Code [Jeff]: Implement binding resolution for contextual, static, and parameter bindings with type compatibility checks. - - [ ] Code [Jeff]: Add resolution helpers for resource name/ULID lookup and project-scoped filtering. - [ ] Docs [Jeff]: Add `docs/reference/tool_bindings.md` with resolution order and examples. - [ ] Tests (Behave) [Jeff]: Add binding resolution scenarios (context vs static vs parameter). - [ ] Tests (Robot) [Jeff]: Add Robot test resolving a bound resource by name. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/binding_resolution_bench.py` for resolution latency. - - [ ] 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(tool): add resource binding resolution"`. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/binding_resolution_bench.py` for resolution latency. + - [ ] 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(tool): add resource binding resolution"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-binding` to `master` with description "Add tool resource binding resolution and docs/tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m3-tool-binding` -- [ ] **COMMIT (Owner: Jeff | Group: C0.cli | Branch: feature/m3-tool-cli) - Commit message: "feat(cli): add tool and validation 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: C1.tool.cli | Branch: feature/m3-tool-cli | Planned: Day 16 | Expected: Day 19) - 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` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - [ ] Code [Jeff]: Implement `agents tool add/remove/list/show` with YAML config input, schema validation, and `--type` filter. - - [ ] Code [Jeff]: Add `--update` to `tool add` and emit conflict errors for name/type mismatches. - - [ ] Code [Jeff]: Implement `agents validation add/attach/detach` commands and enforce validation-only name use. - - [ ] Code [Jeff]: Support `validation attach --project/--plan` flags and store attachment args (JSON-serialized). - - [ ] Code [Jeff]: Add `--format json/yaml` output for tool/validation list/show to align with schema fields. - - [ ] Docs [Jeff]: Update CLI reference with tool/validation commands, attach examples, and output format details. - - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for tool/validation registration, update conflict, and attachment lifecycle. - - [ ] Tests (Robot) [Jeff]: Add Robot CLI suites for tool and validation commands (add/show/attach/detach). - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/tool_cli_bench.py` for CLI parsing 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(cli): add tool and validation commands"`. + - [ ] Code [Jeff]: Implement `agents validation add` and `agents validation attach|detach [--mode required|informational]` (resource-scoped attachments only). + - [ ] Docs [Jeff]: Update CLI reference with tool/validation commands and output formats. + - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for tool registration and validation attachment lifecycle. + - [ ] Tests (Robot) [Jeff]: Add Robot CLI suites for tool and validation commands. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/tool_cli_bench.py` for CLI parsing 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(cli): add tool and validation commands"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-cli` to `master` with description "Add tool/validation CLI commands with attachment workflows and tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m3-tool-cli` @@ -2512,29 +2477,29 @@ Merge points and acceptance checks are tracked as checklist items under each mil **Parallel Group C0.skill: Skill Registry & YAML [Aditya + Jeff + Luis]** (depends on C0.domain + C0.registry; must land before C3.protocol) **PARALLEL SUBTRACK C0.skill.schema [Aditya]**: Skill YAML schema + examples **PARALLEL SUBTRACK C0.skill.domain [Jeff]**: Skill domain model + resolver + **PARALLEL SUBTRACK C0.skill.domain.tests [Brent]**: Robot smoke tests for skill resolver **PARALLEL SUBTRACK C0.skill.registry [Luis]**: Skill persistence + service **PARALLEL SUBTRACK C0.skill.cli [Aditya]**: CLI commands + output formatting **SEQUENTIAL MERGE NOTE**: C0.skill.domain must land before C0.skill.registry/C0.skill.cli to avoid dual representations. -- [ ] **COMMIT (Owner: Aditya | Group: C0.skill.schema | Branch: feature/m3-skill-schema) - Commit message: "docs(skill): add skill yaml schema and examples"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m3-skill-schema` - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Docs [Aditya]: Author `docs/schema/skill.schema.yaml` with versioning, required fields, and explicit type constraints for tool refs, inline tools, includes, and MCP sources. - - [ ] Docs [Aditya]: Add skill YAML examples under `examples/skills/` (single-tool, composed, inline tool, validation-only, MCP-backed). - - [ ] Code [Aditya]: Add schema loader in `src/cleveragents/skills/schema.py` that validates schema version, normalizes keys, and returns typed data. - - [ ] Code [Aditya]: Add clear validation errors for missing tools, recursive includes, and invalid namespaced names. - - [ ] Tests (Behave) [Aditya]: Add `features/skill_schema.feature` scenarios validating each example and invalid cases. - - [ ] Tests (Robot) [Aditya]: Add `robot/skill_schema.robot` to load and validate every example. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/skill_schema_bench.py` for schema validation 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(skill): add skill yaml schema and examples"`. - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-skill-schema` to `master` with description "Add skill YAML schema, examples, loader, and tests.". - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git branch -d feature/m3-skill-schema` -- [X] **COMMIT (Owner: Jeff | Group: C0.skill.domain | Branch: feature/m3-skill-domain) - Commit message: "feat(skill): add skill domain model and resolver"** - done on 2026-02-13 +- [X] **COMMIT (Owner: Aditya | Group: C0.skill.schema | Branch: feature/m3-skill-schema | Done: commit not found) - Commit message: "docs(skill): add skill YAML schema and examples"** + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git pull origin master` + - [X] Git [Aditya]: `git checkout -b feature/m3-skill-schema` + - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Docs [Aditya]: Author `docs/schema/skill.schema.yaml` with versioning, tool refs, inline tools, and include rules. + - [X] Docs [Aditya]: Add skill examples under `examples/skills/` (single-tool, composed, inline tool, validation-only, MCP-backed). + - [X] Code [Aditya]: Add schema loader in `src/cleveragents/skills/schema.py` with validation and clear errors. + - [X] Tests (Behave) [Aditya]: Add `features/skill_schema.feature` scenarios validating examples and invalid cases. + - [X] Tests (Robot) [Aditya]: Add `robot/skill_schema.robot` to load and validate every example. + - [X] Tests (ASV) [Aditya]: Add `benchmarks/skill_schema_bench.py` for schema validation throughput. + - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Aditya]: `git add .` + - [X] Git [Aditya]: `git commit -m "docs(skill): add skill YAML schema and examples"` + - [X] Forgejo PR [Aditya]: Open PR from `feature/m3-skill-schema` to `master` with description "Add skill YAML schema, examples, loader, and tests.". + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git branch -d feature/m3-skill-schema` + - [X] 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%, if not repeat this task as many times as is needed until coverage reaches >=97%. +- [X] **COMMIT (Owner: Jeff | Group: C0.skill.domain | Branch: feature/m3-skill-domain | Done: Day 5, February 13, 2026 22:42:28 +0000) - Commit message: "feat(skill): add skill domain model and resolver"** - [X] Git [Jeff]: `git checkout master` - [X] Git [Jeff]: `git pull origin master` - [X] Git [Jeff]: `git checkout -b feature/m3-skill-domain` @@ -2544,60 +2509,213 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [X] Code [Jeff]: Add `Skill.resolve_tools()` returning resolved tool/validation names plus inline tool definitions for compiler use. (Implemented as SkillResolver.resolve() returning list[ResolvedToolEntry]) - [X] Docs [Jeff]: Add `docs/reference/skill_model.md` and `docs/reference/skill_resolution.md` with resolution order examples. - [X] Tests (Behave) [Jeff]: Add `features/skill_resolution.feature` for include ordering, de-dupe rules, and cycle detection. (42 scenarios) - - [ ] Tests (Robot) [Jeff]: Add `robot/skill_resolution.robot` smoke tests for resolver output. (Deferred - domain model tests fully covered by Behave; Robot tests more appropriate after registry integration) - [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] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (skill.py 98%). - [X] Git [Jeff]: `git add .` (only after coverage check passes) - [X] Commit [Jeff]: `git commit -m "feat(skill): add skill domain model and resolver"`. - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-domain` to `master` with description "Add skill domain model, resolver, and tests.". - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m3-skill-domain` -- [ ] **COMMIT (Owner: Luis | Group: C0.skill.registry | Branch: feature/m3-skill-registry) - Commit message: "feat(skill): add skill registry persistence"** + - [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"** + - [ ] 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` + - [ ] Git [Brent]: `git checkout -b feature/m3-skill-domain-robot` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Brent]: Add `robot/skill_resolution.robot` smoke tests for resolver output ordering and include de-duplication. + - [ ] Docs [Brent]: Update `docs/reference/skill_resolution.md` to mention the Robot smoke suite and how to run it. + - [ ] Tests (Behave) [Brent]: Add a scenario in `features/skill_resolution.feature` that mirrors the Robot smoke expectations. + - [ ] Tests (Robot) [Brent]: Add Robot suite that validates resolver output for included skills and inline tools. + - [ ] Tests (ASV) [Brent]: Confirm `asv/benchmarks/skill_resolution_bench.py` still passes after the new Robot suite is added. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` + - [ ] Git [Brent]: `git commit -m "test(skill): add robot skill resolver smoke tests"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-skill-domain-robot` to `master` with description "Add Robot smoke tests for skill resolver with docs and Behave alignment.". + - [ ] Git [Brent]: `git checkout master` + - [ ] Git [Brent]: `git branch -d feature/m3-skill-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%. +- [X] **COMMIT (Owner: Luis | Group: C0.skill.registry | Branch: feature/m3-skill-registry | Done: commit not found) - Commit message: "feat(skill): add skill registry persistence"** + - [X] Git [Luis]: `git checkout master` + - [X] Git [Luis]: `git pull origin master` + - [X] Git [Luis]: `git checkout -b feature/m3-skill-registry` + - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Luis]: Add `skills` and `skill_items` tables and implement SkillRepository + SkillRegistryService. + - [X] Docs [Luis]: Add `docs/reference/skill_registry.md` with registration behavior and filters. + - [X] Tests (Behave) [Luis]: Add `features/skill_registry.feature` for add/update/remove and invalid include cases. + - [X] Tests (Robot) [Luis]: Add `robot/skill_registry.robot` CLI/service smoke tests. + - [X] Tests (ASV) [Luis]: Add `benchmarks/skill_registry_bench.py` for registry list performance. + - [X] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Luis]: `git add .` + - [X] Git [Luis]: `git commit -m "feat(skill): add skill registry persistence"` + - [X] Forgejo PR [Luis]: Open PR from `feature/m3-skill-registry` to `master` with description "Add skill registry persistence and service with tests.". + - [X] Git [Luis]: `git checkout master` + - [X] Git [Luis]: `git branch -d feature/m3-skill-registry` + - [X] 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%. + +- [X] **COMMIT (Owner: Aditya | Group: C0.skill.cli | Branch: feature/m3-skill-cli | Done: commit not found) - Commit message: "feat(cli): add skill commands"** + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git pull origin master` + - [X] Git [Aditya]: `git checkout -b feature/m3-skill-cli` + - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Aditya]: Implement `agents skill add/remove/list/show/tools` with YAML config input and `--namespace` filter. + - [X] Docs [Aditya]: Update CLI reference with skill command examples and output formats. + - [X] Tests (Behave) [Aditya]: Add CLI scenarios for skill add/remove/list/show/tools. + - [X] Tests (Robot) [Aditya]: Add Robot CLI test for skill show/tools outputs. + - [X] Tests (ASV) [Aditya]: Add `benchmarks/skill_cli_bench.py` for CLI parsing overhead. + - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Aditya]: `git add .` + - [X] Git [Aditya]: `git commit -m "feat(cli): add skill commands"` + - [X] Forgejo PR [Aditya]: Open PR from `feature/m3-skill-cli` to `master` with description "Add skill CLI commands with tests and docs updates.". + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git branch -d feature/m3-skill-cli` + - [X] 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%, if not repeat this task as many times as is needed until coverage reaches >=97%. + +**Parallel Group C3: Actor Registry + CLI (M3)** + **PARALLEL SUBTRACK C3.registry [Luis]**: Actor registry persistence alignment + **PARALLEL SUBTRACK C3.cli [Jeff]**: Actor CLI alignment to YAML-first config + **SEQUENTIAL MERGE NOTE**: Depends on C1.schema/C1.examples + C2.loader/C2.compiler; provider actors are in C8.providers. + +- [X] **COMMIT (Owner: Aditya | Group: C3.schema | Branch: feature/m3-actor-schema | Done: Day 1, February 9, 2026 20:23:33 +0530) - Commit message: "docs(actor): update schema.py module docstring"** + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git pull origin master` + - [X] Git [Aditya]: `git checkout -b feature/m3-actor-schema` + - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Docs [Aditya]: Author `docs/schema/actor.schema.yaml` with graph nodes, tool nodes, and skill references. + - [X] Docs [Aditya]: Add hierarchical actor examples under `examples/actors/` (single LLM, graph with tool nodes, nested actor). + - [X] Code [Aditya]: Add schema loader in `src/cleveragents/actor/schema.py` with validation and clear errors. + - [X] Tests (Behave) [Aditya]: Add `features/actor_schema.feature` scenarios for valid/invalid YAML. + - [X] Tests (Robot) [Aditya]: Add `robot/actor_schema.robot` to load and validate examples. + - [X] Tests (ASV) [Aditya]: Add `benchmarks/actor_schema_bench.py` for schema validation throughput. + - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Aditya]: `git add .` + - [X] Git [Aditya]: `git commit -m "docs(actor): update schema.py module docstring"` + - [X] Forgejo PR [Aditya]: Open PR from `feature/m3-actor-schema` to `master` with description "Add actor YAML schema, examples, loader, and tests.". + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git branch -d feature/m3-actor-schema` + - [X] 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%. + +- [X] **COMMIT (Owner: Jeff | Group: C3.compiler | Branch: feature/m3-actor-compiler | Done: commit not found) - Commit message: "feat(actor): compile actor YAML to runtime graphs"** + - [X] Git [Jeff]: `git checkout master` + - [X] Git [Jeff]: `git pull origin master` + - [X] Git [Jeff]: `git checkout -b feature/m3-actor-compiler` + - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Jeff]: Implement ActorCompiler that converts actor YAML into LangGraph nodes and tool nodes. + - [X] Code [Jeff]: Resolve skill references into tool lists for tool nodes. + - [X] Docs [Jeff]: Add `docs/reference/actor_compiler.md` with compilation flow and error cases. + - [X] Tests (Behave) [Jeff]: Add scenarios for compile success, missing tool errors, and invalid graph wiring. + - [X] Tests (Robot) [Jeff]: Add Robot test that compiles a sample actor and executes a dry-run. + - [X] Tests (ASV) [Jeff]: Add `benchmarks/actor_compiler_bench.py` for compile latency baseline. + - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Jeff]: `git add .` + - [X] Git [Jeff]: `git commit -m "feat(actor): compile actor YAML to runtime graphs"` + - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-compiler` to `master` with description "Add actor compiler for YAML → runtime graphs with tests/docs.". + - [X] Git [Jeff]: `git checkout master` + - [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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m3-skill-registry` + - [ ] Git [Luis]: `git checkout -b feature/m3-actor-registry` - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add `skills` and `skill_items` tables (namespaced name PK, description, source, yaml_text, timestamps) with indexes on namespace/name. - - [ ] Code [Luis]: Implement `SkillRepository` CRUD + list filters and `SkillRegistryService` with add/update/remove/show/list. - - [ ] Code [Luis]: Enforce referential integrity for included skills and tool references at registration time. - - [ ] Docs [Luis]: Add `docs/reference/skill_registry.md` with registration and update behavior. - - [ ] Tests (Behave) [Luis]: Add `features/skill_registry.feature` for add/update/remove and invalid include cases. - - [ ] Tests (Robot) [Luis]: Add `robot/skill_registry.robot` CLI/service smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/skill_registry_bench.py` for registry list 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(skill): add skill registry persistence"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-skill-registry` to `master` with description "Add skill registry persistence and service with tests.". + - [ ] Code [Luis]: Update actor persistence to store YAML text, compiled metadata, and namespaced names. + - [ ] Docs [Luis]: Update `docs/reference/database_schema.md` for actor YAML fields. + - [ ] Tests (Behave) [Luis]: Add scenarios for actor registry add/update/remove with YAML text retention. + - [ ] Tests (Robot) [Luis]: Add Robot test that lists actors and shows YAML metadata. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/actor_registry_bench.py` for registry list 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(actor): align actor registry persistence"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-actor-registry` to `master` with description "Align actor registry persistence with YAML text + metadata.". - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m3-skill-registry` -- [ ] **COMMIT (Owner: Aditya | Group: C0.skill.cli | Branch: feature/m3-skill-cli) - Commit message: "feat(cli): add skill commands"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m3-skill-cli` - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Aditya]: Implement `agents skill add/remove/list/show/tools` with YAML config input, schema validation, and `--namespace` filter. - - [ ] Code [Aditya]: Add `--update` to `skill add` and emit clear errors for name mismatches. - - [ ] Code [Aditya]: Ensure `skill tools` shows resolved tool list, inline tool IDs, validation nodes, and capability summaries. - - [ ] Code [Aditya]: Add `--format json/yaml` outputs for list/show/tools with stable field ordering. - - [ ] Docs [Aditya]: Update CLI reference with skill commands, examples, and output fields. - - [ ] Tests (Behave) [Aditya]: Add CLI scenarios for skill add/show/tools/list/remove and invalid include cycles. - - [ ] Tests (Robot) [Aditya]: Add `robot/skill_cli.robot` for end-to-end CLI flows. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/skill_cli_bench.py` for config parsing overhead. - - [ ] 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(cli): add skill commands"`. - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-skill-cli` to `master` with description "Add skill CLI commands, formats, and tests.". - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git branch -d feature/m3-skill-cli` + - [ ] 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%. -**Parallel Group C0.runtime: Tool Lifecycle Runtime [Jeff]** (depends on C0.domain + C0.registry; must land before C3.context) -- [ ] **COMMIT (Owner: Jeff | Group: C0.runtime | Branch: feature/m3-tool-runtime) - Commit message: "feat(tool): add tool lifecycle runtime"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-runtime` + - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-cli` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Align `agents actor add/remove/list/show` to YAML-first configs and namespaced names. + - [ ] Docs [Jeff]: Update CLI reference with actor YAML usage and examples. + - [ ] Tests (Behave) [Jeff]: Add CLI scenarios for actor add/list/show/remove. + - [ ] Tests (Robot) [Jeff]: Add Robot CLI test for actor show output fields. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_cli_bench.py` for CLI parsing 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(cli): align actor commands to YAML"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-cli` to `master` with description "Align actor CLI commands to YAML-first configs with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m3-actor-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%. + +- [X] **COMMIT (Owner: Aditya | Group: C3.builtins | Branch: feature/m3-provider-actors | Done: commit not found) - Commit message: "feat(actor): add built-in provider actors"** + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git pull origin master` + - [X] Git [Aditya]: `git checkout -b feature/m3-provider-actors` + - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Aditya]: Add built-in actor configs for `openai/`, `anthropic/`, `openrouter/`, and `google/` (if configured). + - [X] Code [Aditya]: Add built-in actors for invariant reconciliation and estimation roles (provider defaults). + - [X] Docs [Aditya]: Add `docs/reference/provider_actors.md` with provider defaults and env var mapping. + - [X] Tests (Behave) [Aditya]: Add `features/provider_actors.feature` for built-in actor loading. + - [X] Tests (Robot) [Aditya]: Add `robot/provider_actors.robot` for registry visibility. + - [X] Tests (ASV) [Aditya]: Add `benchmarks/provider_actor_load_bench.py` for registry load cost. + - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Aditya]: `git add .` + - [X] Git [Aditya]: `git commit -m "feat(actor): add built-in provider actors"` + - [X] Forgejo PR [Aditya]: Open PR from `feature/m3-provider-actors` to `master` with description "Add built-in provider actor configs with defaults and tests.". + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git branch -d feature/m3-provider-actors` + - [X] 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 C4: MCP / Agent Skills Standard Integration (M3)** + **PARALLEL SUBTRACK C4.adapter [Jeff]**: MCP adapter runtime + **PARALLEL SUBTRACK C4.config [Aditya]**: MCP config + examples + **SEQUENTIAL MERGE NOTE**: C4.adapter lands before C4.config examples used in tests. + +- [X] **COMMIT (Owner: Jeff | Group: C4.adapter | Branch: feature/m3-mcp-adapter | Done: commit not found) - Commit message: "feat(tool): add MCP adapter runtime"** + - [X] Git [Jeff]: `git checkout master` + - [X] Git [Jeff]: `git pull origin master` + - [X] Git [Jeff]: `git checkout -b feature/m3-mcp-adapter` + - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Jeff]: Implement MCP tool source adapter that registers tools into ToolRegistry with source metadata. + - [X] Docs [Jeff]: Add `docs/reference/mcp_adapter.md` with connection settings and allowlist rules. + - [X] Tests (Behave) [Jeff]: Add scenarios for MCP adapter registration and tool listing. + - [X] Tests (Robot) [Jeff]: Add Robot test that loads MCP adapter with a mock server. + - [X] Tests (ASV) [Jeff]: Add `benchmarks/mcp_adapter_bench.py` for adapter initialization cost. + - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Jeff]: `git add .` + - [X] Git [Jeff]: `git commit -m "feat(tool): add MCP adapter runtime"` + - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-mcp-adapter` to `master` with description "Add MCP adapter runtime for external tool sources with tests/docs.". + - [X] Git [Jeff]: `git checkout master` + - [X] Git [Jeff]: `git branch -d feature/m3-mcp-adapter` + - [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: Aditya | Group: C4.config | Branch: feature/m3-mcp-config | Done: commit not found) - Commit message: "docs(tool): add MCP config examples"** + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git pull origin master` + - [X] Git [Aditya]: `git checkout -b feature/m3-mcp-config` + - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Docs [Aditya]: Add MCP config examples under `examples/tools/` with allowlist and connection settings. + - [X] Tests (Behave) [Aditya]: Add scenarios that load MCP configs and assert schema validation passes. + - [X] Tests (Robot) [Aditya]: Add Robot test that loads MCP config examples. + - [X] Tests (ASV) [Aditya]: Add `benchmarks/mcp_config_bench.py` for config parsing overhead. + - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [X] Git [Aditya]: `git add .` + - [X] Git [Aditya]: `git commit -m "docs(tool): add MCP config examples"` + - [X] Forgejo PR [Aditya]: Open PR from `feature/m3-mcp-config` to `master` with description "Add MCP config examples with tests for schema validation.". + - [X] Git [Aditya]: `git checkout master` + - [X] Git [Aditya]: `git branch -d feature/m3-mcp-config` + - [X] 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 C5: Tool Lifecycle Runtime [Jeff]** (M2; depends on C0.runtime + C1.tool.domain) +- [ ] **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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m2-tool-runtime` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - [ ] Code [Jeff]: Implement `ToolRuntime`/`ToolInstance` interfaces with `discover/activate/execute/deactivate` hooks and lifecycle state tracking. - [ ] Code [Jeff]: Add `ToolExecutionContext` with resolved resource bindings, sandbox paths, plan metadata, and cancellation token. @@ -2606,21 +2724,22 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Code [Jeff]: Validate tool inputs/outputs against JSON schema before/after execution; surface schema errors clearly. - [ ] Code [Jeff]: Add tool execution tracing (start/end timestamps, duration, result size) for diagnostics. - [ ] Code [Jeff]: Add cancellation propagation so long-running tools are interrupted on plan cancel. - - [ ] Docs [Jeff]: Add `docs/reference/tool_lifecycle.md` describing hook ordering and failure handling. + - [ ] Docs [Jeff]: Add `docs/reference/tool_lifecycle.md` describing hook ordering, capability enforcement, and failure handling. - [ ] Docs [Jeff]: Document schema validation behavior and error payload format for tool failures. - [ ] Tests (Behave) [Jeff]: Add lifecycle scenarios for activate/execute/deactivate ordering and error propagation. - [ ] Tests (Robot) [Jeff]: Add `robot/tool_lifecycle.robot` runtime smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/tool_lifecycle_bench.py` for lifecycle overhead. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/tool_lifecycle_bench.py` for lifecycle 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) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [Jeff]: `git commit -m "feat(tool): add tool lifecycle runtime"`. - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-runtime` to `master` with description "Add tool lifecycle runtime, context, and tests.". + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-tool-runtime` to `master` with description "Add tool lifecycle runtime, context, and tests.". - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git branch -d feature/m3-tool-runtime` + - [ ] Git [Jeff]: `git branch -d feature/m2-tool-runtime` + - [ ] 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) - 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 14) - 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` @@ -2635,7 +2754,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Aditya]: Add graph validation examples (valid/invalid) and error messages. - [ ] Tests (Behave) [Aditya]: Add `features/actor_schema.feature` scenarios for validation and topology errors. - [ ] Tests (Robot) [Aditya]: Add `robot/actor_schema.robot` YAML load smoke test. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/actor_schema_bench.py` for YAML validation cost. + - [ ] 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) @@ -2643,7 +2762,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "docs(actor): add actor yaml 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"** - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git pull origin master` - [ ] Git [Aditya]: `git checkout -b feature/m3-actor-schema-examples` @@ -2653,7 +2772,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Aditya]: Store example YAML files under `examples/actors/` for automated tests. - [ ] Tests (Behave) [Aditya]: Add `features/actor_examples.feature` to ensure all examples validate. - [ ] Tests (Robot) [Aditya]: Add `robot/actor_examples.robot` to load each example. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/actor_examples_load_bench.py` for YAML load throughput. + - [ ] 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) @@ -2665,7 +2784,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil **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) - 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 15) - 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` @@ -2678,7 +2797,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Aditya]: Add `docs/reference/actors_loading.md` with discovery rules and namespaces. - [ ] Tests (Behave) [Aditya]: Add `features/actor_loading.feature` for discovery, duplicates, and namespace lookup. - [ ] Tests (Robot) [Aditya]: Add `robot/actor_loading.robot` for loader smoke tests. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/actor_loading_bench.py` for registry load performance. + - [ ] 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) @@ -2686,7 +2805,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "feat(actor): compile actor configs to LangGraph"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-compiler` @@ -2699,15 +2818,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add `docs/reference/actors_compilation.md` covering compile outputs and error modes. - [ ] Tests (Behave) [Jeff]: Add `features/actor_compilation.feature` for LLM/GRAPH compilation and tool node wiring. - [ ] Tests (Robot) [Jeff]: Add `robot/actor_compilation.robot` smoke test compiling all examples. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/actor_compilation_bench.py` for compilation speed. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(actor): resolve actor references and subgraphs"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-refs` @@ -2719,16 +2838,16 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Update `docs/reference/actors_compilation.md` with reference semantics. - [ ] Tests (Behave) [Jeff]: Add `features/actor_reference_resolution.feature` for missing/recursive refs. - [ ] Tests (Robot) [Jeff]: Add `robot/actor_reference_resolution.robot` for subgraph wiring. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/actor_reference_bench.py` for reference resolution performance. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` -- [ ] **COMMIT (Owner: Jeff | Group: C2.legacy | Branch: feature/m3-actor-legacy-cleanup) - 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 18) - 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` @@ -2739,17 +2858,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Update `docs/reference/actors_loading.md` with v3-only note and migration guidance. - [ ] Tests (Behave) [Jeff]: Add scenarios that reject v2 actor config files. - [ ] Tests (Robot) [Jeff]: Add Robot tests that attempt to load v2 configs and assert failure. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/actor_schema_reject_bench.py` for validation overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` **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) - Commit message: "feat(cli): add actor context commands"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-context` @@ -2762,17 +2881,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Update CLI reference with actor context examples and file format notes. - [ ] Tests (Behave) [Jeff]: Add `features/actor_context_cli.feature` covering list/show/export/import/clear/remove. - [ ] Tests (Robot) [Jeff]: Add `robot/actor_context_cli.robot` for context command smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/actor_context_cli_bench.py` for command overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` **Parallel Group C3: Skill Protocol & Context [Jeff]** (critical path; depends on C1) -- [ ] **COMMIT (Owner: Jeff | Group: C3.protocol | Branch: feature/m3-skill-protocol) - 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 18) - 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` @@ -2785,15 +2904,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add `docs/reference/skills_protocol.md` describing metadata, tool composition, and JSON schema rules. - [ ] Tests (Behave) [Jeff]: Add `features/skill_protocol.feature` for metadata validation and error capture. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_protocol.robot` smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/skill_protocol_bench.py` for validation throughput. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(skill): add skill context and registry"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-protocol` @@ -2806,15 +2925,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add `docs/reference/skills_context.md` with context fields and helper methods. - [ ] Tests (Behave) [Jeff]: Add `features/skill_context.feature` for sandboxed access and registry resolution. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_context.robot` for registry smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/skill_context_bench.py` for registry resolution overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(skill): add inline tool executor"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-protocol` @@ -2826,17 +2945,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add `docs/reference/skills_inline.md` with safety constraints. - [ ] Tests (Behave) [Jeff]: Add `features/skill_inline.feature` for execution and timeout handling. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_inline.robot` for inline tool smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/inline_tool_bench.py` for execution overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` **Parallel Group C4: Built-in Skills [Jeff + Luis]** (depends on C3) -- [ ] **COMMIT (Owner: Jeff | Group: C4.file | Branch: feature/m3-skill-file-search) - 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 20) - 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` @@ -2852,7 +2971,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Document file size limits and binary file behavior. - [ ] Tests (Behave) [Jeff]: Add `features/skill_file_ops.feature` for read/write/edit/delete flows. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_file_ops.robot` for file ops integration. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/file_tool_bench.py` for read/write throughput. + - [ ] 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) @@ -2860,7 +2979,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "feat(skill): add directory and search skills"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-skill-file-search` @@ -2875,7 +2994,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Document grep regex behavior and binary file skipping. - [ ] Tests (Behave) [Jeff]: Add `features/skill_search.feature` for listing/globbing/searching. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_search.robot` for search integration. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/search_tool_bench.py` for search performance. + - [ ] 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) @@ -2883,7 +3002,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "feat(skill): add git operation skills"** +- [ ] **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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` - [ ] Git [Luis]: `git checkout -b feature/m3-skill-git` @@ -2898,17 +3017,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Document environment variables and safety settings for git tool execution. - [ ] Tests (Behave) [Luis]: Add `features/skill_git.feature` for git tool outputs. - [ ] Tests (Robot) [Luis]: Add `robot/skill_git.robot` for git tool integration. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/git_tool_bench.py` for diff/log performance. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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` **Parallel Group C5: Tool Routing & Change Tracking [Luis + Jeff]** (depends on C3/C4) -- [ ] **COMMIT (Owner: Luis | Group: C5.model | Branch: feature/m3-change-model) - 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 22) - 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` @@ -2924,15 +3043,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Add `docs/reference/change_tracking.md` describing tool-to-change mapping. - [ ] Tests (Behave) [Luis]: Add `features/change_tracking.feature` for ChangeSet aggregation. - [ ] Tests (Robot) [Luis]: Add `robot/change_tracking.robot` for tracker smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/change_tracking_bench.py` for invocation tracking overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(change): add tool router for providers"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-tool-router` @@ -2949,7 +3068,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add `docs/reference/tool_router.md` with provider-specific mappings. - [ ] Tests (Behave) [Jeff]: Add `features/tool_router.feature` for schema mapping. - [ ] Tests (Robot) [Jeff]: Add `robot/tool_router.robot` for routing smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/tool_router_bench.py` for routing performance. + - [ ] 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) @@ -2957,7 +3076,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "feat(change): add diff review artifacts"** +- [ ] **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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` - [ ] Git [Luis]: `git checkout -b feature/m3-diff-review` @@ -2973,17 +3092,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Add `docs/reference/diff_review.md` with output format. - [ ] Tests (Behave) [Luis]: Add `features/diff_review.feature` for diff generation. - [ ] Tests (Robot) [Luis]: Add `robot/diff_review.robot` for review artifacts. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/diff_review_bench.py` for diff building performance. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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` **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) - 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 23) - 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` @@ -3002,15 +3121,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Document concurrency limits and output normalization rules. - [ ] Tests (Behave) [Luis]: Add `features/validation_pipeline.feature` for pass/fail paths and required/informational modes. - [ ] Tests (Robot) [Luis]: Add `robot/validation_pipeline.robot` for pipeline smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/validation_pipeline_bench.py` for pipeline runtime. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(validation): support wrapped tools and transforms"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-wraps` @@ -3027,7 +3146,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add transform error handling examples (schema failure, timeout). - [ ] Tests (Behave) [Jeff]: Add wrapped-validation scenarios with transform success/fail paths. - [ ] Tests (Robot) [Jeff]: Add `robot/validation_wraps.robot` for wrapped validation end-to-end. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/validation_wraps_bench.py` for transform overhead. + - [ ] 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) @@ -3035,7 +3154,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] 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) - Commit message: "feat(validation): integrate validation with apply gating"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-gating` @@ -3044,14 +3163,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Code [Jeff]: Ensure informational validation failures do not block apply but are logged in plan status. - [ ] Code [Jeff]: Add CLI status output for validation summary (required vs informational counts). - [ ] Code [Jeff]: Ensure automation profile gates (manual/review/full-auto) influence whether apply can proceed automatically. - - [ ] Code [Jeff]: Add explicit error when apply is attempted without Execute completion (phase/state guard). + - [ ] Code [Jeff]: Add explicit error when apply is attempted without Execute completion (phase/processing_state guard). - [ ] Code [Jeff]: Add `plan status` fields for validation result IDs and last validation timestamp. - [ ] Code [Jeff]: Add apply gating hook that checks DoD evaluation before validations (fail fast). - [ ] Docs [Jeff]: Update `docs/reference/plan_actor_integration.md` with validation gating behavior. - [ ] Docs [Jeff]: Add gating flow diagram with manual/review/full-auto branches. - [ ] Tests (Behave) [Jeff]: Add `features/validation_gating.feature` for apply blocking. - [ ] Tests (Robot) [Jeff]: Add `robot/validation_gating.robot` for end-to-end gating. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/validation_gating_bench.py` for gating overhead. + - [ ] 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) @@ -3060,8 +3179,8 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m3-validation-gating` -**Parallel Group C7: MCP Adapter [Aditya]** (depends on C3) -- [ ] **COMMIT (Owner: Aditya | Group: C7.mcp | Branch: feature/m3-mcp-adapter) - Commit message: "feat(skill): add MCP adapter for external tools"** +**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"** - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git pull origin master` - [ ] Git [Aditya]: `git checkout -b feature/m3-mcp-adapter` @@ -3076,19 +3195,22 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Code [Aditya]: Add local-only guard to prevent MCP execution in read-only plans unless tool is read-only. - [ ] Docs [Aditya]: Add `docs/reference/skills_mcp.md` with server connection examples. - [ ] Docs [Aditya]: Document allowlist config keys and refresh behavior. + - [ ] Docs [Aditya]: Add MCP config examples under `examples/tools/` with allowlist and connection settings. + - [ ] Tests (Behave) [Aditya]: Add scenarios that load MCP config examples and assert schema validation passes. + - [ ] Tests (Robot) [Aditya]: Add Robot test that loads MCP config examples. - [ ] Tests (Behave) [Aditya]: Add `features/skill_mcp.feature` for MCP tool calls. - [ ] Tests (Robot) [Aditya]: Add `robot/skill_mcp.robot` for MCP adapter smoke test. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/mcp_adapter_bench.py` for tool invocation latency. + - [ ] 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 coverage check passes) + - [ ] Git [Aditya]: `git add .` (only after nox passes) - [ ] Commit [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` -**Parallel Group C8: Built-in Provider Actors [Aditya]** (depends on C1/C2) -- [ ] **COMMIT (Owner: Aditya | Group: C8.providers | Branch: feature/m3-provider-actors) - Commit message: "feat(actor): add built-in provider actors"** +**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"** - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git pull origin master` - [ ] Git [Aditya]: `git checkout -b feature/m3-provider-actors` @@ -3103,17 +3225,17 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Aditya]: Add environment variable mapping table for provider API keys and model defaults. - [ ] Tests (Behave) [Aditya]: Add `features/provider_actors.feature` for built-in actor loading. - [ ] Tests (Robot) [Aditya]: Add `robot/provider_actors.robot` for registry visibility. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/provider_actor_load_bench.py` for registry load cost. + - [ ] 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 coverage check passes) + - [ ] Git [Aditya]: `git add .` (only after nox passes) - [ ] Commit [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` **Parallel Group C9: Plan-Actor Integration [Jeff + Luis]** (depends on C2/C5/C6) -- [ ] **COMMIT (Owner: Jeff | Group: C9.execute | Branch: feature/m3-plan-execute) - 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 25) - 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` @@ -3132,15 +3254,15 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add error handling and retry notes for Strategize/Execute phases. - [ ] Tests (Behave) [Jeff]: Add `features/plan_actor_integration.feature` for strategy/execute flows. - [ ] Tests (Robot) [Jeff]: Add `robot/plan_actor_integration.robot` for end-to-end actor execution. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/plan_actor_integration_bench.py` for execution overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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) - Commit message: "feat(plan): integrate change review and apply flow"** +- [ ] **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m3-plan-apply` @@ -3156,10 +3278,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add apply error cases and recovery steps (re-run execute, fix validation). - [ ] Tests (Behave) [Jeff]: Add `features/plan_review_apply.feature` for review gate behavior. - [ ] Tests (Robot) [Jeff]: Add `robot/plan_review_apply.robot` for review-before-apply path. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/plan_apply_bench.py` for apply throughput. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3179,129 +3301,316 @@ Merge points and acceptance checks are tracked as checklist items under each mil --- -### Section 6: Execution Pipeline, Decisions & Invariants [M3-M4] +### Section 6: Execution Pipeline, Decisions & Invariants [M1-M4] -**Target: Milestone M4 (+21 days)** -**Week 3 focus**: decision capture, correction, invariants, and DoD gating. +**Parallel Group D0: ChangeSet + Apply MVP (M1-critical)** + **PARALLEL SUBTRACK D0.alpha [Jeff]**: ChangeSet model + tool change capture + **PARALLEL SUBTRACK D0.beta [Luis]**: Apply pipeline + validation gate + **PARALLEL SUBTRACK D0.tests [Brent]**: ChangeSet/apply test coverage + **SEQUENTIAL MERGE NOTE**: D0.alpha must land before D0.beta; D0.tests runs after both. -**Parallel Group D1: Decision Domain [Hamza]** (foundation for D2-D5; tests supported by Brent when Rui is unavailable) -- [ ] **COMMIT (Owner: Hamza | Group: D1.domain | Branch: feature/m4-decision-domain) - Commit message: "feat(domain): add decision model and context snapshots"** +- [ ] **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"** + - [ ] 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). + - [ ] 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. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/changeset_capture_bench.py` for change capture 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(execute): add changeset model and change capture"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-changeset-core` to `master` with description "Add ChangeSet domain model + change capture hooks for built-in file tools.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] 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"** + - [ ] 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. + - [ ] 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. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/apply_pipeline_bench.py` for apply runtime 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(apply): add validation-gated apply pipeline"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-apply-pipeline` to `master` with description "Add validation-gated apply pipeline and PlanLifecycleService integration.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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"** + - [ ] Git [Brent]: `git checkout master` + - [ ] Git [Brent]: `git pull origin master` + - [ ] Git [Brent]: `git checkout -b feature/m1-apply-tests` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Tests (Behave) [Brent]: Add ChangeSet/apply scenarios for multiple file changes and rollback on validation failure. + - [ ] Tests (Behave) [Brent]: Add scenarios asserting apply summary fields in `plan status` output. + - [ ] Tests (Robot) [Brent]: Add Robot suite that exercises sandbox → changeset → apply flow. + - [ ] Docs [Brent]: Update `docs/development/testing.md` with apply pipeline suites. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/apply_tests_bench.py` for test runtime baseline. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` + - [ ] Git [Brent]: `git commit -m "test(apply): cover changeset and apply pipeline"` + - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-apply-tests` to `master` with description "Add Behave/Robot coverage for ChangeSet capture and apply pipeline.". + - [ ] Git [Brent]: `git checkout master` + - [ ] Git [Brent]: `git branch -d feature/m1-apply-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 D0b: Plan Execute/Apply Wiring (M1-M2)** + **PARALLEL SUBTRACK D0b.execute [Jeff]**: Strategize/Execute actor integration + **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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m1-plan-execute` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Connect PlanLifecycleService to actor execution for Strategize and Execute phases. + - [ ] Code [Jeff]: Ensure Execute phase uses ToolRunner and captures ChangeSet IDs in plan metadata. + - [ ] Docs [Jeff]: Add execute/strategize integration notes and failure handling to `docs/reference/plan_execute.md`. + - [ ] Tests (Behave) [Jeff]: Add `features/plan_actor_integration.feature` for strategy/execute flows. + - [ ] 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), fix any errors if needed ensuring nox passes. + - [ ] Git [Jeff]: `git add .` + - [ ] Git [Jeff]: `git commit -m "feat(plan): execute strategize and execute via actors"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-execute` to `master` with description "Integrate actor execution for strategize/execute phases with ChangeSet capture.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m2-plan-apply-review` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add `plan diff` output using ChangeSet summaries and resource diffs. + - [ ] Code [Jeff]: Add `plan artifacts` output including ChangeSet ID, sandbox refs, and apply summary. + - [ ] Docs [Jeff]: Update CLI reference for `plan diff`/`plan artifacts` output formats. + - [ ] Tests (Behave) [Jeff]: Add `features/plan_diff_artifacts.feature` for diff/artifact output fields. + - [ ] Tests (Robot) [Jeff]: Add `robot/plan_diff_artifacts.robot` for end-to-end diff/artifacts. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/plan_diff_bench.py` for diff rendering 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(plan): add diff review and apply integration"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m2-plan-apply-review` to `master` with description "Add plan diff/artifacts outputs wired to ChangeSet summaries with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m2-plan-apply-review` + - [ ] 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 D1: Validation Attachments (M3)** + **PARALLEL SUBTRACK D1.apply [Luis]**: Run validations during Apply + **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"** + - [ ] Git [Luis]: `git checkout master` + - [ ] Git [Luis]: `git pull origin master` + - [ ] Git [Luis]: `git checkout -b feature/m3-validation-apply` + - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Luis]: Add `ValidationRunner` integration that executes attached validations before Apply. + - [ ] Code [Luis]: Block Apply on `required` validation failures and record results in plan metadata. + - [ ] Docs [Luis]: Add `docs/reference/validation_pipeline.md` with required vs informational behavior. + - [ ] Tests (Behave) [Luis]: Add scenarios for required failure blocking and informational pass-through. + - [ ] Tests (Robot) [Luis]: Add Robot test that attaches a validation and verifies apply gating. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/validation_pipeline_bench.py` for validation runtime 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(apply): run validation attachments"` + - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-validation-apply` to `master` with description "Add validation attachment execution during Apply with tests/docs.". + - [ ] Git [Luis]: `git checkout master` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m3-validation-status` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add validation summary output to `plan status` and `plan list`. + - [ ] Docs [Jeff]: Update CLI reference with validation summary fields. + - [ ] Tests (Behave) [Jeff]: Add scenarios for validation summary rendering. + - [ ] Tests (Robot) [Jeff]: Add Robot test that shows validation results in plan status. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/validation_status_bench.py` for output rendering 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(cli): surface validation summaries"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-validation-status` to `master` with description "Surface validation summaries in plan status/list outputs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m3-validation-status` + - [ ] 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 D2: Invariants + Reconciliation (M4)** + **PARALLEL SUBTRACK D2.model [Hamza]**: Invariant model + persistence + **PARALLEL SUBTRACK D2.reconcile [Jeff]**: Invariant Reconciliation Actor integration + **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"** + - [ ] Git [Hamza]: `git checkout master` + - [ ] Git [Hamza]: `git pull origin master` + - [ ] Git [Hamza]: `git checkout -b feature/m4-invariant-model` + - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Hamza]: Add `Invariant` model with scope (global/project/action/plan), text, and source references. + - [ ] Code [Hamza]: Add persistence tables for invariants with precedence ordering. + - [ ] Docs [Hamza]: Add `docs/reference/invariants.md` with precedence rules. + - [ ] Tests (Behave) [Hamza]: Add scenarios for invariant validation and precedence ordering. + - [ ] Tests (Robot) [Hamza]: Add Robot test that lists invariants by scope. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/invariant_model_bench.py` for validation throughput. + - [ ] 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(domain): add invariant model and storage"` + - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-invariant-model` to `master` with description "Add invariant model + storage with precedence rules.". + - [ ] Git [Hamza]: `git checkout master` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m4-invariant-reconcile` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add Invariant Reconciliation Actor invocation at the start of Strategize. + - [ ] Code [Jeff]: Record `invariant_enforced` decisions and persist resolved invariants into plan metadata. + - [ ] Docs [Jeff]: Add `docs/reference/invariant_reconciliation.md` describing conflict resolution. + - [ ] Tests (Behave) [Jeff]: Add scenarios for precedence resolution and decision recording. + - [ ] Tests (Robot) [Jeff]: Add Robot test that reconciles invariants during plan use. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/invariant_reconcile_bench.py` for reconciliation 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(plan): reconcile invariants in strategize"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-invariant-reconcile` to `master` with description "Add invariant reconciliation actor and decision recording in Strategize.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] 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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m4-invariant-cli` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Implement `agents invariant add/list/remove` with scope flags and namespaced filters. + - [ ] Docs [Jeff]: Update CLI reference with invariant command examples. + - [ ] Tests (Behave) [Jeff]: Add scenarios for add/list/remove across scopes. + - [ ] Tests (Robot) [Jeff]: Add Robot CLI test for invariant list output. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/invariant_cli_bench.py` for CLI parsing 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(cli): add invariant commands"` + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-invariant-cli` to `master` with description "Add invariant CLI commands with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git branch -d feature/m4-invariant-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%. + +**Parallel Group D3: Decision Tree (M4)** + **PARALLEL SUBTRACK D3.domain [Hamza]**: Decision model + context snapshots + **PARALLEL SUBTRACK D3.service [Hamza]**: Decision recording service + **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"** - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git pull origin master` - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-domain` - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add `DecisionType`, `ContextSnapshot`, and `Decision` models with correction fields and helpers. - - [ ] Code [Hamza]: Include required fields: question, chosen option, alternatives, confidence score, rationale, dependencies, and context hash. - - [ ] Code [Hamza]: Add identifiers (`decision_id` ULID, `plan_id`, `parent_decision_id`, `root_decision_id`) and supersession markers (`superseded_by`, `superseded_at`). - - [ ] Code [Hamza]: Add `ContextSnapshot` fields for `detail_level`, `token_count`, `source_refs`, and `created_at` with hash-based dedupe helper. - - [ ] Code [Hamza]: Add validators to enforce `confidence_score` in 0.0–1.0 range and non-empty question text. - - [ ] Code [Hamza]: Add `DecisionSummary` helper for compact CLI rendering (question, choice, confidence, decision_id). + - [ ] Code [Hamza]: Add `DecisionType`, `ContextSnapshot`, and `Decision` models with correction fields. - [ ] Docs [Hamza]: Add `docs/reference/decision_model.md` with examples and schema notes. - [ ] Tests (Behave) [Hamza]: Add `features/decision_model.feature` for validation and helpers. - [ ] Tests (Robot) [Hamza]: Add `robot/decision_model.robot` smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/decision_model_bench.py` for decision validation throughput. - - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(domain): add decision model and context snapshots"`. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_model_bench.py` for decision validation throughput. + - [ ] 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(domain): add decision model and context snapshots"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-domain` to `master` with description "Add decision domain models and context snapshot helpers.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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%. -**Parallel Group D2: Decision Recording Service [Hamza]** (depends on D1) -- [ ] **COMMIT (Owner: Hamza | Group: D2.service | Branch: feature/m4-decision-service) - 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 24) - 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` - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `DecisionService` with `record_decision`, sequence numbers, tree queries, and downstream linking. - - [ ] Code [Hamza]: Add `ContextSnapshotStore` interface with a file-backed MVP implementation and hash dedupe. - - [ ] Code [Hamza]: Integrate decision recording into strategize/execute phases (prompt/strategy/subplan/tool decisions). - - [ ] Code [Hamza]: Add `DecisionType` mapping for `prompt_definition`, `invariant_enforced`, `strategy_choice`, `subplan_spawn`, and `subplan_parallel_spawn`. - - [ ] Code [Hamza]: Persist context snapshot references with each decision and store snapshots under data dir by hash. - - [ ] Code [Hamza]: Add `DecisionService.record_context_snapshot()` helper to avoid duplicate snapshot writes. - - [ ] Code [Hamza]: Add structured logging for decision recording (plan_id, decision_id, type, confidence). + - [ ] Code [Hamza]: Implement `DecisionService` with record/list/tree helpers and snapshot storage. - [ ] Docs [Hamza]: Add `docs/reference/decision_service.md` covering recording and snapshots. - [ ] Tests (Behave) [Hamza]: Add `features/decision_recording.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add `robot/decision_recording.robot` integration smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/decision_recording_bench.py` for record throughput. - - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(service): add decision recording and snapshot store"`. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_recording_bench.py` for record throughput. + - [ ] 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(service): add decision recording and snapshot store"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-service` to `master` with description "Add decision recording service and snapshot store with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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%. -**Parallel Group D3: Decision CLI & Viewing [Hamza]** (depends on D1/D2) -- [ ] **COMMIT (Owner: Hamza | Group: D3.cli | Branch: feature/m4-decision-cli) - 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 25) - 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` - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement `plan tree` and `plan explain` with rich/json/flat formats and `--show-superseded`/`--show-context`. - - [ ] Code [Hamza]: Add `--show-reasoning` to include confidence and alternatives in explain output per spec. - - [ ] Code [Hamza]: Add `--depth` and `--type` filters for tree output to reduce large plan noise. - - [ ] Code [Hamza]: Add deterministic tree ordering (by sequence number, then decision_id) to stabilize snapshots. - - [ ] Code [Hamza]: Add `plan explain --format json/yaml` output schema with decision fields and context snapshot refs. + - [ ] Code [Hamza]: Implement `plan tree` and `plan explain` with `--show-superseded`, `--show-context`, and `--show-reasoning`. - [ ] Docs [Hamza]: Update CLI reference for decision viewing commands. - - [ ] Docs [Hamza]: Include output field mapping table for `plan tree` and `plan explain`. - [ ] Tests (Behave) [Hamza]: Add tree/explain scenarios including superseded handling. - [ ] Tests (Robot) [Hamza]: Add `robot/decision_cli.robot` smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/decision_cli_bench.py` for tree rendering overhead. - - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add plan tree and explain commands"`. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_cli_bench.py` for tree rendering overhead. + - [ ] 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(cli): add plan tree and explain commands"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-cli` to `master` with description "Add plan tree/explain commands and decision viewing outputs.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-decision-cli` + - [ ] 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 D4: Decision Correction [Jeff + Luis]** (depends on D2/D3) -- [ ] **COMMIT (Owner: Jeff | Group: D4.revert | Branch: feature/m4-decision-revert) - Commit message: "feat(service): add decision correction revert flow"** +**Parallel Group D4: Decision Correction (M4)** + **PARALLEL SUBTRACK D4.revert [Jeff]**: Revert corrections + **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"** - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git pull origin master` - [ ] Git [Jeff]: `git checkout -b feature/m4-decision-revert` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement correction impact analysis and dry-run reporting. - - [ ] Code [Jeff]: Revert flow with checkpoint rollback, supersede downstream decisions, and subtree re-exec. - - [ ] Code [Jeff]: Persist correction attempt IDs and link them to superseded decisions. - - [ ] Code [Jeff]: Record correction attempts with user guidance text and timestamp for audit trail. - - [ ] Code [Jeff]: Re-run validations after re-exec and update plan status with correction outcome summary. - - [ ] Code [Jeff]: Add `plan correct --dry-run` output schema (affected decisions, affected subplans, estimated re-exec count). - - [ ] Code [Jeff]: Add correction state machine (pending -> running -> applied/failed) and store in plan metadata. - - [ ] Code [Jeff]: Ensure corrections cannot run when plan is in APPLY/APPLIED (explicit error message). - - [ ] Docs [Jeff]: Add `docs/reference/decision_correction.md` for revert behavior. - - [ ] Docs [Jeff]: Include dry-run output example and correction state transitions. + - [ ] Code [Jeff]: Implement correction impact analysis, dry-run report, and revert execution. + - [ ] Docs [Jeff]: Add `docs/reference/decision_correction.md` for revert behavior and dry-run output. - [ ] Tests (Behave) [Jeff]: Add revert + dry-run scenarios. - [ ] Tests (Robot) [Jeff]: Add revert integration tests with checkpoint rollback. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/decision_correction_revert_bench.py` for correction 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(service): add decision correction revert flow"`. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/decision_correction_revert_bench.py` for correction 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): add decision correction revert flow"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-decision-revert` to `master` with description "Add decision correction revert flow with dry-run and tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m4-decision-revert` -- [ ] **COMMIT (Owner: Jeff | Group: D4.append | Branch: feature/m4-decision-append) - Commit message: "feat(service): add decision correction append 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: D4.append | Branch: feature/m4-decision-append | Planned: Day 25 | Expected: Day 27) - 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` - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Append flow creating fix subplan without rewriting history; link correction attempt + decision tree updates. - - [ ] Code [Jeff]: Record append corrections as separate subtree with explicit lineage. - - [ ] Code [Jeff]: Enforce that append corrections do not modify prior decisions; they only add a new branch and mark prior branch as superseded. - - [ ] Code [Jeff]: Add plan metadata linking correction attempt to spawned subplan IDs. - - [ ] Code [Jeff]: Add `plan correct --mode=append` dry-run output with proposed subplan count. - - [ ] Docs [Jeff]: Extend correction docs for append mode and guidance-file usage. - - [ ] Docs [Jeff]: Add sample append correction flow with resulting decision tree snippet. + - [ ] Code [Jeff]: Implement append corrections as new subtree with lineage and subplan spawning. + - [ ] Docs [Jeff]: Extend correction docs for append mode and guidance usage. - [ ] Tests (Behave) [Jeff]: Add append correction scenarios. - [ ] Tests (Robot) [Jeff]: Add append correction smoke test. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/decision_correction_append_bench.py` for append 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(service): add decision correction append flow"`. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/decision_correction_append_bench.py` for append 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): add decision correction append flow"` - [ ] 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` @@ -3318,10 +3627,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Hamza]: Update `docs/reference/database_schema.md` with decision tables. - [ ] Tests (Behave) [Hamza]: Add migration verification scenarios. - [ ] Tests (Robot) [Hamza]: Add DB migration smoke test. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/decision_migration_bench.py` for migration baseline. + - [ ] 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 coverage check passes) + - [ ] Git [Hamza]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3337,10 +3646,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Hamza]: Document repository interfaces in `docs/reference/repositories.md`. - [ ] Tests (Behave) [Hamza]: Add decision persistence scenarios (create/query/superseded). - [ ] Tests (Robot) [Hamza]: Add repository integration smoke test. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/decision_repository_bench.py` for tree query performance. + - [ ] 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 coverage check passes) + - [ ] Git [Hamza]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3355,10 +3664,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Update DI docs for decision wiring. - [ ] Tests (Behave) [Luis]: Add DI wiring scenarios for decision commands. - [ ] Tests (Robot) [Luis]: Add CLI smoke test using persisted decisions. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/decision_di_bench.py` for DI resolution overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3373,7 +3682,7 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Tests (Behave) [Brent]: Add output snapshots for `plan explain --format json` and `plan tree --format yaml`. - [ ] Tests (Robot) [Brent]: Add `robot/decision_persistence.robot` E2E coverage. - [ ] Docs [Brent]: Update `docs/development/testing.md` with decision suites. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/decision_persistence_bench.py` for DB persistence throughput. + - [ ] 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) @@ -3397,10 +3706,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Include a template rendering example with plan args and a failure output example. - [ ] Tests (Behave) [Luis]: Add DoD pass/fail scenarios. - [ ] Tests (Robot) [Luis]: Add DoD integration smoke test. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/dod_evaluation_bench.py` for evaluation overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3422,10 +3731,10 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add examples for scope precedence and reconciliation actor outputs. - [ ] Tests (Behave) [Jeff]: Add invariant merge + violation scenarios. - [ ] Tests (Robot) [Jeff]: Add invariant CLI integration tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/invariant_merge_bench.py` for merge overhead. + - [ ] 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 coverage check passes) + - [ ] Git [Jeff]: `git add .` (only after nox passes) - [ ] Commit [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` @@ -3438,36 +3747,34 @@ Merge points and acceptance checks are tracked as checklist items under each mil **Week 3-4 focus**: subplan spawning, parallel execution, and result merging. **Parallel Group E1: Subplan Domain [Luis]** (tests supported by Brent while Rui is unavailable) -- [ ] **COMMIT (Owner: Luis | Group: E1.domain | Branch: feature/m5-subplan-domain) - Commit message: "feat(domain): add subplan config and status models"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m5-subplan-domain` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add `ExecutionMode` enum (sequential, parallel, hybrid) with validation guards. - - [ ] Code [Luis]: Add `MergeStrategy` enum (three_way, sequential, json) with defaults. - - [ ] Code [Luis]: Add `SubplanConfig` model fields: parent_plan_id, spawn_decision_id, dependencies, max_parallel, merge_strategy, automation_profile_override, invariants_override, context_view_override. - - [ ] Code [Luis]: Add `SubplanStatus` model fields: subplan_id, state, started_at, completed_at, error_message, changeset_id. - - [ ] Code [Luis]: Add `SubplanAttempt` model fields: attempt_id (ULID), subplan_id, attempt_number, started_at, completed_at, error_details. - - [ ] Code [Luis]: Add `SubplanState` enum (queued/processing/errored/complete/cancelled) and validators to align with ProcessingState semantics. - - [ ] Code [Luis]: Add `SubplanConfig` validation for `max_parallel >= 1`, `merge_strategy` compatibility, and non-empty dependency IDs. - - [ ] Code [Luis]: Add `SubplanConfig.to_decision_payload()`/`from_decision_payload()` helpers for strategy actor handoff. - - [ ] Code [Luis]: Add `Plan.link_child_subplan(child_id, decision_id)` helper to keep deterministic child ordering. - - [ ] Code [Luis]: Add serialization ordering rules so subplan configs render with stable field ordering (for snapshot tests). - - [ ] Code [Luis]: Extend `Plan` with `subplan_config`, `subplan_statuses`, `spawn_decision_id`, and helpers (`is_subplan`, `has_subplans`, `child_count`). - - [ ] Code [Luis]: Add DecisionType constants for `subplan_spawn` and `subplan_parallel_spawn` and ensure models reference them. - - [ ] Code [Luis]: Add dependency validation helper to reject cycles and missing dependency references. - - [ ] Docs [Luis]: Add `docs/reference/subplan_model.md`. - - [ ] Docs [Luis]: Include field-by-field table with defaults + example JSON payloads for decision emission. - - [ ] Tests (Behave) [Luis]: Add `features/subplan_model.feature` scenarios for config validation, dependency cycles, and parent/root helpers. - - [ ] Tests (Robot) [Luis]: Add `robot/subplan_model.robot` smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/subplan_model_bench.py` for model validation. - - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(domain): add subplan config and status models"`. - - [ ] Forgejo PR [Luis]: Open PR from `feature/m5-subplan-domain` to `master` with description "Add subplan domain models, enums, and tests.". - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git branch -d feature/m5-subplan-domain` +- [X] **COMMIT (Owner: Luis | Group: E1.domain | Branch: feature/m5-subplan-domain | Done: Day 2, February 10, 2026 17:16:10 +0000) - Commit message: "feat(core): add v3 lifecycle models, automation levels, subplan support, and security hardening"** + - [X] Git [Luis]: `git checkout master` + - [X] Git [Luis]: `git pull origin master` + - [X] Git [Luis]: `git checkout -b feature/m5-subplan-domain` + - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [X] Code [Luis]: Align `ExecutionMode` enum to spec (sequential, parallel, dependency_ordered) with validation guards. + - [X] Code [Luis]: Add `SubplanMergeStrategy` enum (git_three_way, sequential_apply, fail_on_conflict, last_wins). + - [X] Code [Luis]: Define `SubplanConfig` with execution_mode, merge_strategy, max_parallel, fail_fast, timeout_per_subplan_seconds, retry_failed, max_retries. + - [X] Code [Luis]: Add `SubplanStatus` and `SubplanAttempt` models (status, timing, error, changeset_summary, files_changed, retries). + - [X] Code [Luis]: Add `SubplanFailureHandler` plus retriable/non-retriable failure constants. + - [X] Code [Luis]: Extend `Plan` with `subplan_config`, `subplan_statuses`, `spawn_decision_id`, and helpers (`is_subplan`, `has_subplans`, `child_count`). + - [X] Code [Luis]: Add DecisionType constants for `subplan_spawn` and `subplan_parallel_spawn` and reference them in models. + - [X] Code [Luis]: Add dependency validation helper to reject cycles and missing dependency references. + - [X] Code [Luis]: Add serialization ordering rules so subplan configs render with stable field ordering (for snapshot tests). + - [X] Docs [Luis]: Add `docs/reference/subplan_model.md`. + - [X] Docs [Luis]: Include field-by-field table with defaults + example JSON payloads for decision emission. + - [X] Tests (Behave) [Luis]: Add `features/subplan_model.feature` scenarios for config validation, dependency cycles, and parent/root helpers. + - [X] Tests (Robot) [Luis]: Add `robot/subplan_model.robot` smoke tests. + - [X] Tests (ASV) [Luis]: Add `benchmarks/subplan_model_bench.py` for model validation. + - [X] Quality [Luis]: Run `nox` (all default sessions, including benchmark). + - [X] Git [Luis]: `git add .` (only after nox passes) + - [X] Git [Luis]: `git commit -m "feat(core): add v3 lifecycle models, automation levels, subplan support, and security hardening"` + - [X] Forgejo PR [Luis]: Open PR from `feature/m5-subplan-domain` to `master` with description "Add subplan domain models, enums, and tests.". + - [X] Git [Luis]: `git checkout master` + - [X] Git [Luis]: `git branch -d feature/m5-subplan-domain` + - [X] 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%. + +- [X] Traceability [Luis]: Updated E1.domain commit message to match git log entry (no history rewrite required). - [X] **Stage E1: Subplan Model** (Day 12) **[Luis]** @@ -3677,25 +3984,24 @@ Merge points and acceptance checks are tracked as checklist items under each mil } ``` - [X] Commit: "feat(domain): define retriable vs non-retriable failures" - - [ ] **E1.6** [Brent] Write Behave tests for subplan model: - - [ ] **E1.6a** [Brent] Plan hierarchy scenarios: - - [ ] Scenario: Plan with parent_plan_id has is_subplan=True - - [ ] Given Plan with parent_plan_id set - - [ ] Then is_subplan returns True - - [ ] And is_root_plan returns False - - [ ] Scenario: Root plan has is_subplan=False and is_root_plan=True - - [ ] Scenario: SubplanConfig validates max_parallel bounds - - [ ] Commit: "test(behave): add plan hierarchy scenarios" - - [ ] **E1.6b** [Brent] Execution mode scenarios: - - [ ] Scenario: ExecutionMode enum has all required values - - [ ] Scenario: MergeStrategy enum has all required values - - [ ] Scenario: SubplanConfig defaults are applied - - [ ] Commit: "test(behave): add execution mode scenarios" - - [ ] **E1.6c** [Brent] SubplanStatus scenarios: - - [ ] Scenario: SubplanStatus tracks state correctly - - [ ] Scenario: SubplanAttempt records retry history - - [ ] Scenario: Failure handler respects fail_fast setting - - [ ] Commit: "test(behave): add SubplanStatus scenarios" + - [ ] **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%. **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"** @@ -3718,14 +4024,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Document idempotency, naming convention, and spawn audit log format. - [ ] Tests (Behave) [Jeff]: Add subplan spawn scenarios (inheritance, overrides, dependency ordering). - [ ] Tests (Robot) [Jeff]: Add subplan spawn integration tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/subplan_spawn_bench.py` for spawn throughput. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/subplan_spawn_bench.py` for spawn 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(service): add subplan service and spawn workflow"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(service): add subplan service and spawn workflow"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m5-subplan-service` to `master` with description "Add subplan service, spawn workflows, and tests.". - [ ] 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"** - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git pull origin master` @@ -3742,14 +4048,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Aditya]: Add a minimal `plan_subplan` tool payload example and a parallel spawn example with dependencies. - [ ] Tests (Behave) [Aditya]: Add scenarios for subplan decision emission (parallel + dependencies). - [ ] Tests (Robot) [Aditya]: Add actor tool integration smoke tests. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/subplan_actor_tool_bench.py` for tool invocation overhead. + - [ ] Tests (ASV) [Aditya]: Add `benchmarks/subplan_actor_tool_bench.py` for tool invocation overhead. - [ ] 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 plan_subplan tool and decision emission"`. + - [ ] Git [Aditya]: `git add .` (only after nox passes) + - [ ] Git [Aditya]: `git commit -m "feat(actor): add plan_subplan tool and decision emission"` - [ ] Forgejo PR [Aditya]: Open PR from `feature/m5-subplan-actor` to `master` with description "Add plan_subplan tool emission rules with tests and examples.". - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git branch -d feature/m5-subplan-actor` + - [ ] 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"** @@ -3770,14 +4076,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Document scheduler ordering, retry policy, and cancellation propagation. - [ ] Tests (Behave) [Luis]: Add parallel + dependency execution scenarios. - [ ] Tests (Robot) [Luis]: Add parallel execution integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/subplan_scheduler_bench.py` for scheduler overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/subplan_scheduler_bench.py` for scheduler 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(service): add subplan scheduler and execution"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(service): add subplan scheduler and execution"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m5-subplan-exec` to `master` with description "Add subplan scheduler and execution with dependency ordering and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m5-subplan-exec` + - [ ] 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"** @@ -3797,14 +4103,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Include conflict artifact schema and sample output for `plan diff`. - [ ] Tests (Behave) [Jeff]: Add merge + conflict scenarios. - [ ] Tests (Robot) [Jeff]: Add merge integration tests for multi-subplan plans. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/subplan_merge_bench.py` for merge performance. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/subplan_merge_bench.py` for merge 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(merge): add subplan merge strategies"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(merge): add subplan merge strategies"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m5-subplan-merge` to `master` with description "Add subplan merge strategies and conflict artifacts with tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m5-subplan-merge` + - [ ] 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"** @@ -3823,14 +4129,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Hamza]: Add examples for multi-project `plan use` and explain alias resolution. - [ ] Tests (Behave) [Hamza]: Add multi-project subplan scenarios. - [ ] Tests (Robot) [Hamza]: Add multi-project integration tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/multi_project_bench.py` for multi-project overhead. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/multi_project_bench.py` for multi-project overhead. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(plan): add multi-project subplan support"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(plan): add multi-project subplan support"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m5-multi-project` to `master` with description "Add multi-project subplan support and per-project summaries.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m5-multi-project` + - [ ] 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%. ### Section 8: Large Project Autonomy & Context [M6] @@ -3858,14 +4164,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Document config keys, default thresholds, and example decomposition outputs. - [ ] Tests (Behave) [Jeff]: Add deep hierarchy + dependency closure scenarios. - [ ] Tests (Robot) [Jeff]: Add large-project decomposition integration tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/large_project_decompose_bench.py` for decomposition runtime. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/large_project_decompose_bench.py` for decomposition runtime. - [ ] 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(plan): add large-project decomposition and dependency closure"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(plan): add large-project decomposition and dependency closure"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-large-decompose` to `master` with description "Add large-project decomposition, dependency closure, and tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m6-large-decompose` + - [ ] 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"** @@ -3886,14 +4192,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Include checkpoint retention defaults and rollback error cases. - [ ] Tests (Behave) [Luis]: Add checkpoint/rollback scenarios. - [ ] Tests (Robot) [Luis]: Add rollback integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/checkpoint_rollback_bench.py` for rollback latency. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/checkpoint_rollback_bench.py` for rollback 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 .` (only after coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(checkpoint): add checkpointing and rollback"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(checkpoint): add checkpointing and rollback"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-checkpoint` to `master` with description "Add checkpointing and rollback support with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m6-checkpoint` + - [ ] 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"** @@ -3914,14 +4220,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Luis]: Add section on required vs informational validation attachment modes. - [ ] Tests (Behave) [Luis]: Add semantic validation scenarios. - [ ] Tests (Robot) [Luis]: Add semantic validation integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/semantic_validation_bench.py` for validation cost. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/semantic_validation_bench.py` for validation cost. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(validation): add semantic validation service"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(validation): add semantic validation service"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-semantic-validation` to `master` with description "Add semantic validation service and attachments with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m6-semantic-validation` + - [ ] 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"** @@ -3943,14 +4249,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Hamza]: Document tier budgets, eviction rules, and summarization policy. - [ ] Tests (Behave) [Hamza]: Add context tier scenarios. - [ ] Tests (Robot) [Hamza]: Add context tier integration tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/context_tiers_bench.py` for tier lookup performance. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/context_tiers_bench.py` for tier lookup 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(context): add hot/warm/cold tiers and actor views"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(context): add hot/warm/cold tiers and actor views"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-context-tiers` to `master` with description "Add context tiers, actor views, and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m6-context-tiers` + - [ ] 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"** @@ -3968,14 +4274,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Hamza]: Add CLI examples showing estimate fields in `plan status` output. - [ ] Tests (Behave) [Hamza]: Add estimation scenarios. - [ ] Tests (Robot) [Hamza]: Add estimation integration smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/estimation_actor_bench.py` for estimation runtime. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/estimation_actor_bench.py` for estimation runtime. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(estimation): add cost and risk estimation actor"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(estimation): add cost and risk estimation actor"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-estimation` to `master` with description "Add cost/risk estimation actor and plan outputs.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m6-estimation` + - [ ] 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"** @@ -3993,14 +4299,14 @@ Merge points and acceptance checks are tracked as checklist items under each mil - [ ] Docs [Jeff]: Add a CLI output contract section in `docs/reference/cli_output.md`. - [ ] Tests (Behave) [Jeff]: Add `features/cli_output_formats.feature` covering rich/plain/json/yaml formatting for core commands. - [ ] Tests (Robot) [Jeff]: Add CLI UX smoke tests for critical commands. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/cli_render_bench.py` for output rendering overhead. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/cli_render_bench.py` for output 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 .` (only after coverage check passes) - - [ ] Commit [Jeff]: `git commit -m "chore(cli): polish help and output"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "chore(cli): polish help and output"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-cli-polish` to `master` with description "Polish CLI help/output formats and add tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m6-cli-polish` + - [ ] 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%. **--- MERGE POINT 2: Day 30 - Large Project Autonomy Target (LOCAL MODE ONLY) ---** @@ -4036,14 +4342,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Tests (Behave) [Luis]: Add stub behavior scenarios. - [ ] Tests (Behave) [Luis]: Add scenarios for env var override and config precedence order. - [ ] Tests (Robot) [Luis]: Add CLI stub smoke test. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/server_stub_bench.py` (baseline no-op). + - [ ] Tests (ASV) [Luis]: Add `benchmarks/server_stub_bench.py` (baseline no-op). - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(interfaces): add server client stubs"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(interfaces): add server client stubs"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-server-stubs` to `master` with description "Add server client stubs and config wiring with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m6-server-stubs` + - [ ] 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%. **M7 SUCCESS CRITERIA** (Post-Day 30): - `agents [--data-dir PATH] [--config-path PATH] connect ` establishes connection to an external server. @@ -4077,14 +4383,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Document async config defaults and job retention policy. - [ ] Tests (Behave) [Luis]: Add `features/async_execution.feature` for async command handling (enqueue, worker pick-up, cancel). - [ ] Tests (Robot) [Luis]: Add `robot/async_execution.robot` smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/async_execution_bench.py` for worker scheduling overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/async_execution_bench.py` for worker scheduling 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(async): add async command execution and workers"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(async): add async command execution and workers"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-async-infra` to `master` with description "Add async command execution, workers, and tests.". - [ ] 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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` @@ -4102,14 +4408,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add examples of per-service override config and expected logs. - [ ] Tests (Behave) [Luis]: Add retry/circuit breaker behavior scenarios. - [ ] Tests (Robot) [Luis]: Add resilience smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/retry_policy_bench.py` for retry overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/retry_policy_bench.py` for retry 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(async): wire retry policies into services"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(async): wire retry policies into services"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-async-infra` to `master` with description "Wire retry/circuit breaker policies into services with tests.". - [ ] 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%. **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"** @@ -4126,14 +4432,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Brent]: Add a required test matrix section for reviewers (nox sessions + coverage). - [ ] Tests (Behave) [Brent]: Add scenarios validating review playbook references exist. - [ ] Tests (Robot) [Brent]: Add docs build smoke test covering the new guide. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/docs_build_bench.py` for docs build baseline. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/docs_build_bench.py` for docs build baseline. - [ ] 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 "docs(qa): add review playbook and priority matrix"`. + - [ ] Git [Brent]: `git add .` (only after nox passes) + - [ ] Git [Brent]: `git commit -m "docs(qa): add review playbook and priority matrix"` - [ ] Forgejo PR [Brent]: Open PR from `feature/m6-review-playbook` to `master` with description "Add review playbook, priority matrix, and tests.". - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git branch -d feature/m6-review-playbook` + - [ ] 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"** @@ -4148,14 +4454,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Brent]: Update `docs/development/testing.md` with validation test catalog. - [ ] Tests (Behave) [Brent]: Add edge-case scenarios for concurrency, conflicts, rollbacks, and timeouts. - [ ] Tests (Robot) [Brent]: Add integration coverage for edge-case suites. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/validation_edge_bench.py` for edge-case runtime. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/validation_edge_bench.py` for edge-case runtime. - [ ] 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(validation): add edge case suites"`. + - [ ] Git [Brent]: `git add .` (only after nox passes) + - [ ] Git [Brent]: `git commit -m "test(validation): add edge case suites"` - [ ] Forgejo PR [Brent]: Open PR from `feature/m6-validation-edge` to `master` with description "Add validation edge-case suites and fixtures.". - [ ] 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"** - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git pull origin master` @@ -4168,14 +4474,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Document semantic validation coverage expectations. - [ ] Tests (Behave) [Luis]: Add semantic validation scenarios. - [ ] Tests (Robot) [Luis]: Add semantic validation integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/semantic_validation_suite_bench.py` for suite runtime. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/semantic_validation_suite_bench.py` for suite 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "test(validation): add semantic validation suites"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "test(validation): add semantic validation suites"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-validation-semantic` to `master` with description "Add semantic validation test suites and fixtures.". - [ ] 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"** - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git pull origin master` @@ -4188,14 +4494,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Brent]: Add scale test runbook and environment notes. - [ ] Tests (Behave) [Brent]: Add scale test scenarios validating thresholds. - [ ] Tests (Robot) [Brent]: Add large-project Robot tests for performance runs. - - [ ] Tests (ASV) [Brent]: Add `asv/benchmarks/scale_fixture_bench.py` for baseline performance. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/scale_fixture_bench.py` for baseline performance. - [ ] 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(perf): add scale test fixtures"`. + - [ ] Git [Brent]: `git add .` (only after nox passes) + - [ ] Git [Brent]: `git commit -m "test(perf): add scale test fixtures"` - [ ] Forgejo PR [Brent]: Open PR from `feature/m6-perf-scale` to `master` with description "Add scale test fixtures and performance baselines.". - [ ] Git [Brent]: `git checkout master` - [ ] Git [Brent]: `git branch -d feature/m6-perf-scale` + - [ ] 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%. --- @@ -4218,14 +4524,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add `docs/reference/security_eval.md` with replacement patterns. - [X] Tests (Behave) [Luis]: Add `features/security_eval.feature` scenarios. (completed by Luis) - [ ] Tests (Robot) [Luis]: Add `robot/security_eval.robot` smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/security_eval_bench.py` for config parsing baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/security_eval_bench.py` for config parsing baseline. - [ ] 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%. (Code review by Brent still pending) - - [ ] Git [Luis]: `git add .` (only after coverage check passes) - - [ ] Commit [Luis]: `git commit -m "fix(security): remove eval-based config parsing"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "fix(security): remove eval-based config parsing"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-eval` to `master` with description "Remove eval-based config parsing and add security checks.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-security-eval` + - [ ] 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"** @@ -4241,14 +4547,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add `docs/reference/template_security.md` with safe patterns. - [ ] Tests (Behave) [Luis]: Add `features/security_templates.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add `robot/security_templates.robot` smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/security_template_bench.py` for render baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/security_template_bench.py` for render baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "fix(security): harden template rendering"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "fix(security): harden template rendering"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-template` to `master` with description "Harden template rendering and add tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-security-template` + - [ ] 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"** @@ -4264,14 +4570,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Document error propagation standards and logging rules. - [ ] Tests (Behave) [Luis]: Add `features/security_exceptions.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add exception handling integration smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/security_exception_bench.py` for error path overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/security_exception_bench.py` for error path overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "fix(security): enforce explicit exception handling"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "fix(security): enforce explicit exception handling"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-exceptions` to `master` with description "Enforce explicit exception handling and error mapping with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-security-exceptions` + - [ ] 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"** @@ -4287,14 +4593,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add `docs/reference/async_safety.md` on cleanup rules. - [ ] Tests (Behave) [Luis]: Add `features/security_async.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add async cleanup integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/security_async_cleanup_bench.py` for cleanup overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/security_async_cleanup_bench.py` for cleanup overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "fix(security): close async resources and leaks"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "fix(security): close async resources and leaks"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-async-cleanup` to `master` with description "Add async lifecycle cleanup and leak prevention with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-security-async-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 SEC5: Secrets Management [Hamza]** - [ ] **COMMIT (Owner: Hamza | Group: SEC5.secrets | Branch: feature/m4-security-secrets) - Commit message: "feat(security): add secrets masking and validation"** @@ -4311,14 +4617,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Include examples of masked outputs and `--show-secrets` usage. - [ ] Tests (Behave) [Hamza]: Add `features/security_secrets.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add secrets handling integration smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/security_secrets_bench.py` for masking overhead baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/security_secrets_bench.py` for masking overhead 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(security): add secrets masking and validation"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(security): add secrets masking and validation"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-security-secrets` to `master` with description "Add secrets masking/validation and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-security-secrets` + - [ ] 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"** @@ -4334,14 +4640,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add `docs/reference/read_only_actions.md`. - [ ] Tests (Behave) [Luis]: Add `features/security_readonly.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add read-only enforcement integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/security_readonly_bench.py` for enforcement overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/security_readonly_bench.py` for enforcement overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(security): enforce read-only actions"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(security): enforce read-only actions"` - [ ] 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. **Parallel Group SEC7: Audit Logging [Hamza]** @@ -4359,14 +4665,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Document audit retention settings and CLI filter semantics. - [ ] Tests (Behave) [Hamza]: Add `features/security_audit.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add audit logging integration tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/security_audit_bench.py` for log write overhead baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/security_audit_bench.py` for log write overhead 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(security): add audit logging for apply"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(security): add audit logging for apply"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-security-audit` to `master` with description "Add audit logging for apply with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-security-audit` + - [ ] 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%. ### Section 12: Provider Fixes & Runtime Tweaks [WORKSTREAM G - Hamza] @@ -4388,14 +4694,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add migration note for removing FakeListLLM fallback and mock flag usage. - [ ] Tests (Behave) [Luis]: Add `features/provider_fixes.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add provider detection smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/provider_selection_bench.py` for provider resolution baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/provider_selection_bench.py` for provider resolution baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "fix(provider): remove FakeListLLM defaults"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "fix(provider): remove FakeListLLM defaults"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-provider-fixes` to `master` with description "Fix provider defaults and enforce configuration validation.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-provider-fixes` + - [ ] 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"** @@ -4413,14 +4719,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add `docs/reference/cost_controls.md` with config keys and thresholds. - [ ] Tests (Behave) [Luis]: Add `features/cost_controls.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add cost control integration smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/cost_controls_bench.py` for cost check overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/cost_controls_bench.py` for cost check 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(provider): add cost controls and fallback"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(provider): add cost controls and fallback"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-provider-costs` to `master` with description "Add cost controls, budgets, and provider fallback with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-provider-costs` + - [ ] 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%. --- @@ -4442,14 +4748,58 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Add diagnostics check list and expected remediation steps. - [ ] Tests (Behave) [Hamza]: Add `features/cli_core.feature` scenarios for each command output. - [ ] Tests (Robot) [Hamza]: Add core command smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/cli_core_bench.py` for command runtime baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/cli_core_bench.py` for command runtime 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(cli): add version/info/diagnostics"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(cli): add version/info/diagnostics"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-cli-core` to `master` with description "Add core CLI system commands and diagnostics with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-cli-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%. + +**Parallel Group CLI1: Plan/Action CLI Extensions (M4)** + **PARALLEL SUBTRACK CLI1.alpha [Jeff]**: Automation profile/invariant flags + actor overrides + **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"** + - [ ] Git [Jeff]: `git checkout master` + - [ ] Git [Jeff]: `git pull origin master` + - [ ] Git [Jeff]: `git checkout -b feature/m4-cli-extensions` + - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Code [Jeff]: Add `--automation-profile` and `--invariant` flags to `plan use` and persist to plan metadata. + - [ ] Code [Jeff]: Add actor override flags (`--strategy-actor`, `--execution-actor`, `--estimation-actor`, `--invariant-actor`) with namespaced validation. + - [ ] Code [Jeff]: Update `plan status/list` output to include automation_profile + invariants when present. + - [ ] Code [Jeff]: Extend `action show` output with optional actors, invariants, and inputs_schema when present. + - [ ] Docs [Jeff]: Update `docs/reference/plan_cli.md` and `docs/reference/action_cli.md` with extended flags + examples. + - [ ] Tests (Behave) [Jeff]: Add scenarios for automation_profile/invariant flags and actor override validation. + - [ ] Tests (Robot) [Jeff]: Add Robot flow for `plan use` with invariants + automation profile. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/cli_extensions_bench.py` for parsing overhead. + - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Jeff]: `git add .` (run after the coverage check below passes) + - [ ] Git [Jeff]: `git commit -m "feat(cli): add action and plan CLI extensions"` (run after the coverage check below passes) + - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-cli-extensions` to `master` with description "Add plan use automation/invariant flags, actor overrides, and extended outputs with tests/docs.". + - [ ] Git [Jeff]: `git checkout master` (post-merge cleanup) + - [ ] 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"** + - [ ] Git [Brent]: `git checkout master` + - [ ] Git [Brent]: `git pull origin master` + - [ ] Git [Brent]: `git checkout -b feature/m4-cli-extension-tests` + - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) + - [ ] Tests (Behave) [Brent]: Add scenarios for automation_profile resolution, invariant ordering, and actor override errors. + - [ ] Tests (Behave) [Brent]: Add output snapshot assertions for extended fields in JSON/YAML/table formats. + - [ ] Tests (Robot) [Brent]: Add Robot test that validates `action show` includes optional actors/invariants when set. + - [ ] Docs [Brent]: Update `docs/development/testing.md` with CLI extension fixtures. + - [ ] Tests (ASV) [Brent]: Add `benchmarks/cli_extension_tests_bench.py` for extended scenario runtime baseline. + - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. + - [ ] Git [Brent]: `git add .` (run after the coverage check below passes) + - [ ] Git [Brent]: `git commit -m "test(cli): cover action and plan extensions"` (run after the coverage check below passes) + - [ ] Forgejo PR [Brent]: Open PR from `feature/m4-cli-extension-tests` to `master` with description "Add Behave/Robot coverage for action/plan CLI extensions with updated fixtures.". + - [ ] Git [Brent]: `git checkout master` (post-merge cleanup) + - [ ] Git [Brent]: `git branch -d feature/m4-cli-extension-tests` (post-merge cleanup) + - [ ] 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%. --- @@ -4472,14 +4822,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Document lock TTL defaults and renewal strategy. - [ ] Tests (Behave) [Luis]: Add `features/concurrency.feature` scenarios for lock contention and expiry. - [ ] Tests (Robot) [Luis]: Add lock integration smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/concurrency_lock_bench.py` for lock overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/concurrency_lock_bench.py` for lock overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(concurrency): add plan and project locks"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(concurrency): add plan and project locks"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-concurrency-locks` to `master` with description "Add plan/project locking and diagnostics with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-concurrency-locks` + - [ ] 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"** @@ -4497,14 +4847,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add resume flow example and error cases. - [ ] Tests (Behave) [Luis]: Add `features/plan_resume.feature` scenarios. - [ ] Tests (Robot) [Luis]: Add resume integration tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/plan_resume_bench.py` for resume overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/plan_resume_bench.py` for resume overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(concurrency): add plan resume"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(concurrency): add plan resume"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-concurrency-resume` to `master` with description "Add plan resume workflow and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m4-concurrency-resume` + - [ ] 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"** @@ -4522,14 +4872,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Include example `cleanup --dry-run` output and warnings. - [ ] Tests (Behave) [Hamza]: Add `features/garbage_collection.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add cleanup integration smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/cleanup_bench.py` for cleanup overhead baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/cleanup_bench.py` for cleanup overhead 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(ops): add cleanup commands"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(ops): add cleanup commands"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-concurrency-cleanup` to `master` with description "Add cleanup commands and retention policies with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-concurrency-cleanup` + - [ ] 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%. --- @@ -4554,14 +4904,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Add a minimal example ontology snippet and parsing walkthrough. - [ ] Tests (Behave) [Hamza]: Add `features/uko_ontology.feature` for URI parsing and inheritance checks. - [ ] Tests (Robot) [Hamza]: Add `robot/uko_ontology.robot` smoke tests for ontology load. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/uko_load_bench.py` for load throughput. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/uko_load_bench.py` for load throughput. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(uko): add UKO ontology scaffolding"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(uko): add UKO ontology scaffolding"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-uko-schema` to `master` with description "Add UKO ontology scaffolding and loaders with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m6-acms-uko-schema` + - [ ] 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"** @@ -4579,14 +4929,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Jeff]: Document `DetailLevelMap` resolution rules and defaults. - [ ] Tests (Behave) [Jeff]: Add `features/crp_models.feature` for validation and serialization ordering. - [ ] Tests (Robot) [Jeff]: Add `robot/crp_models.robot` smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/crp_model_bench.py` for validation throughput. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/crp_model_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 coverage check passes) - - [ ] Commit [Jeff]: `git commit -m "feat(acms): add context request protocol models"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(acms): add context request protocol models"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-crp-models` to `master` with description "Add context request protocol models and tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m6-acms-crp-models` + - [ ] 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"** @@ -4604,14 +4954,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Document strategy config keys (timeouts, max fragments, enable/disable). - [ ] Tests (Behave) [Hamza]: Add `features/context_strategy_registry.feature` for registration and selection. - [ ] Tests (Robot) [Hamza]: Add `robot/context_strategy_registry.robot` smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/context_strategy_bench.py` for registry lookup. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/context_strategy_bench.py` for registry lookup. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(acms): add context strategy registry"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(acms): add context strategy registry"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-strategy-registry` to `master` with description "Add context strategy registry and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m6-acms-strategy-registry` + - [ ] 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"** @@ -4629,14 +4979,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Jeff]: Document StrategyCoordinator execution order and error handling. - [ ] Tests (Behave) [Jeff]: Add `features/acms_fusion.feature` for dedupe and budget enforcement. - [ ] Tests (Robot) [Jeff]: Add `robot/acms_fusion.robot` integration smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/acms_fusion_bench.py` for fusion runtime. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/acms_fusion_bench.py` for fusion runtime. - [ ] 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(acms): add strategy coordinator and fusion engine"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(acms): add strategy coordinator and fusion engine"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-fusion-engine` to `master` with description "Add strategy coordinator and fusion engine with tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m6-acms-fusion-engine` + - [ ] 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"** @@ -4654,14 +5004,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Add examples of allowlist/denylist configurations. - [ ] Tests (Behave) [Hamza]: Add `features/scoped_view.feature` for cross-project isolation. - [ ] Tests (Robot) [Hamza]: Add `robot/scoped_view.robot` smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/scoped_view_bench.py` for filter overhead. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/scoped_view_bench.py` for filter overhead. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(acms): add scoped backend view filtering"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(acms): add scoped backend view filtering"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-scoped-view` to `master` with description "Add scoped backend view filtering with tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m6-acms-scoped-view` + - [ ] 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"** @@ -4679,14 +5029,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Jeff]: Add example of skeleton output for a multi-decision plan. - [ ] Tests (Behave) [Jeff]: Add `features/skeleton_compressor.feature` for compression thresholds. - [ ] Tests (Robot) [Jeff]: Add `robot/skeleton_compressor.robot` smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/skeleton_compressor_bench.py` for compression overhead. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/skeleton_compressor_bench.py` for compression 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(acms): add skeleton compressor"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(acms): add skeleton compressor"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-skeleton-compress` to `master` with description "Add skeleton compressor and tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] Git [Jeff]: `git branch -d feature/m6-acms-skeleton-compress` + - [ ] 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%. --- @@ -4710,14 +5060,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Document index storage schema and refresh behavior. - [ ] Tests (Behave) [Hamza]: Add `features/context_indexing.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add indexing integration tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/context_indexing_bench.py` for indexing throughput baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/context_indexing_bench.py` for indexing throughput 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(context): add repo indexing service"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(context): add repo indexing service"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-context-indexing` to `master` with description "Add repository indexing service and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-context-indexing` + - [ ] 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"** @@ -4736,21 +5086,21 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Hamza]: Document embedding storage format and cache invalidation rules. - [ ] Tests (Behave) [Hamza]: Add `features/embedding_search.feature` scenarios. - [ ] Tests (Robot) [Hamza]: Add embedding search integration tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/embedding_search_bench.py` for search runtime baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/embedding_search_bench.py` for search runtime 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(context): add optional embedding search"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(context): add optional embedding search"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-context-embedding` to `master` with description "Add optional embedding search and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/m4-context-embedding` + - [ ] 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%. --- ### Section 17: Skill Registry [Days 17-18] **Target: Days 17-18 (after Tool/Skill base registry work in C0/C3)** -**Dependencies**: C0.skill.domain + C0.skill.registry + C0.tool.registry + C3.context; MCP refresh depends on C7.mcp. +**Dependencies**: C0.skill.domain + C0.skill.registry + C1.tool.registry + C3.context; MCP refresh depends on C7.mcp. **Parallel Group SK: Skill Registry Completion [Jeff + Luis + Rui + Aditya]** **PARALLEL SUBTRACK SK1.core [Jeff]**: Flattened tool sets, includes, capability summary @@ -4775,14 +5125,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Jeff]: Add example of flattened output with inline tools and includes. - [ ] Tests (Behave) [Jeff]: Add `features/skill_registry.feature` scenarios for includes, overrides, cycle detection, and missing tool refs. - [ ] Tests (Robot) [Jeff]: Add `robot/skill_registry.robot` for add/list/show/tools flows. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/skill_flatten_bench.py` for flattening throughput. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/skill_flatten_bench.py` for flattening 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 registry flattening and capability summaries"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(skill): add registry flattening and capability summaries"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-skill-registry-core` to `master` with description "Add skill registry flattening and capability summaries.". - [ ] Git [Jeff]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -4798,14 +5148,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Luis]: Add mapping table of persistence fields to domain model properties. - [ ] Tests (Behave) [Luis]: Add `features/skill_registry_persistence.feature` scenarios for add/update/refresh persistence. - [ ] Tests (Robot) [Luis]: Add repository persistence smoke tests for skills. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/skill_registry_persist_bench.py` for persistence overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/skill_registry_persist_bench.py` for persistence 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(skill): persist flattened tool sets"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(skill): persist flattened tool sets"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-skill-registry-db` to `master` with description "Persist flattened skill tool sets and summaries.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Aditya]: `git checkout master` @@ -4821,14 +5171,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Aditya]: Document refresh side effects and caching behavior. - [ ] Tests (Behave) [Aditya]: Add `features/skill_cli.feature` scenarios for tools/refresh and list/show output. - [ ] Tests (Robot) [Aditya]: Add `robot/skill_cli.robot` for CLI smoke tests. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/skill_cli_bench.py` for CLI overhead baseline. + - [ ] Tests (ASV) [Aditya]: Add `benchmarks/skill_cli_bench.py` for CLI overhead baseline. - [ ] 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(cli): add skill tools and refresh commands"`. + - [ ] Git [Aditya]: `git add .` (only after nox passes) + - [ ] Git [Aditya]: `git commit -m "feat(cli): add skill tools and refresh commands"` - [ ] Forgejo PR [Aditya]: Open PR from `feature/m4-skill-registry-cli` to `master` with description "Add skill tools/refresh CLI commands and tests.". - [ ] Git [Aditya]: `git checkout master` - [ ] 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"** - [ ] Git [Aditya]: `git checkout master` @@ -4844,14 +5194,14 @@ By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is - [ ] Docs [Aditya]: Document debounce defaults and manual refresh usage. - [ ] Tests (Behave) [Aditya]: Add `features/skill_refresh.feature` scenarios for MCP update propagation. - [ ] Tests (Robot) [Aditya]: Add `robot/skill_refresh.robot` for refresh smoke tests. - - [ ] Tests (ASV) [Aditya]: Add `asv/benchmarks/skill_refresh_bench.py` for refresh overhead. + - [ ] Tests (ASV) [Aditya]: Add `benchmarks/skill_refresh_bench.py` for refresh overhead. - [ ] 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(skill): add MCP refresh hooks"`. + - [ ] Git [Aditya]: `git add .` (only after nox passes) + - [ ] Git [Aditya]: `git commit -m "feat(skill): add MCP refresh hooks"` - [ ] Forgejo PR [Aditya]: Open PR from `feature/m4-skill-registry-refresh` to `master` with description "Add MCP refresh hooks and registry updates.". - [ ] Git [Aditya]: `git checkout master` - [ ] Git [Aditya]: `git branch -d feature/m4-skill-registry-refresh` + - [ ] 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%. --- @@ -4859,6 +5209,27 @@ 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"** + - [ ] 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]: 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. + - [ ] Docs [Hamza]: Update `docs/reference/resource_types_builtin.md` with virtual type descriptions and link semantics. + - [ ] Tests (Behave) [Hamza]: Add scenarios ensuring virtual built-ins exist and cannot be user-added. + - [ ] Tests (Robot) [Hamza]: Add Robot test that lists resource types and asserts virtual built-ins are present. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_virtual_core_bench.py` for registry performance. + - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). + - [ ] Git [Hamza]: `git add .` + - [ ] Git [Hamza]: `git commit -m "feat(resource): add virtual core resource types"` + - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-virtual-core` to `master` with description "Add virtual core resource types (file/directory/git objects) with docs and tests.". + - [ ] Git [Hamza]: `git checkout master` + - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git pull origin master` @@ -4870,10 +5241,10 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Update `docs/reference/resource_types_builtin.md` with deferred physical type flags, parent/child rules, and discovery notes. - [ ] Tests (Behave) [Hamza]: Add scenarios ensuring deferred physical types register and validate parent/child constraints. - [ ] Tests (Robot) [Hamza]: Add Robot test that lists resource types and asserts the git object taxonomy types. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_type_deferred_physical_bench.py` for registry load overhead. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_deferred_physical_bench.py` for registry load overhead. - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Hamza]: `git add .` (only after coverage check passes) - - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred physical resource types"` (only after coverage check passes) + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred physical resource types"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-physical` to `master` with description "Add deferred physical resource types (git object taxonomy + fs link types) with discovery rules, docs, and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/post-resource-types-physical` @@ -4889,10 +5260,10 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Update `docs/reference/resource_types_builtin.md` with deferred virtual type descriptions and equivalence notes. - [ ] Tests (Behave) [Hamza]: Add scenarios ensuring deferred virtual types exist and remain non-user-addable. - [ ] Tests (Robot) [Hamza]: Add Robot test that lists resource types and asserts deferred virtual types. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/resource_type_deferred_virtual_bench.py` for registry load overhead. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_type_deferred_virtual_bench.py` for registry load overhead. - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Hamza]: `git add .` (only after coverage check passes) - - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred virtual resource types"` (only after coverage check passes) + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred virtual resource types"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-virtual` to `master` with description "Add deferred virtual resource types (remote/submodule/symlink) with docs and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] Git [Hamza]: `git branch -d feature/post-resource-types-virtual` @@ -4909,14 +5280,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Document safety profile schema, defaults, and stub enforcement behavior in `docs/reference/safety_profile.md`. - [ ] Tests (Behave) [Luis]: Add model validation scenarios for safety profile field parsing and constraint validation. - [ ] Tests (Robot) [Luis]: Add Robot smoke test that loads a safety profile from YAML and prints serialized output. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/safety_profile_model_bench.py` for validation overhead. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/safety_profile_model_bench.py` for validation 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 .` + - [ ] Git [Luis]: `git add .` (only after nox passes) - [ ] Git [Luis]: `git commit -m "feat(security): add safety profile model and enforcement stubs"` - [ ] Forgejo PR [Luis]: Open PR from `feature/post-safety-profile` to `master` with description "Add SafetyProfile model + schema wiring with enforcement stubs for post-30 work.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Rui]: `git checkout master` @@ -4927,14 +5298,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Tests (Behave) [Rui]: Add scenarios for cost/retry bounds validation on action creation. - [ ] Tests (Robot) [Rui]: Add Robot test that verifies safety profile appears in `action show` output. - [ ] Docs [Rui]: Add test fixture notes for safety profile YAML examples in `docs/development/testing.md`. - - [ ] Tests (ASV) [Rui]: Add `asv/benchmarks/safety_profile_tests_bench.py` for scenario runtime baseline. + - [ ] Tests (ASV) [Rui]: Add `benchmarks/safety_profile_tests_bench.py` for scenario runtime baseline. - [ ] Quality [Rui]: Run `nox` (all default sessions, including benchmark). - - [ ] 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%. 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 [Rui]: `git add .` + - [ ] Git [Rui]: `git add .` (only after nox passes) - [ ] Git [Rui]: `git commit -m "test(security): cover safety profile enforcement"` - [ ] Forgejo PR [Rui]: Open PR from `feature/post-safety-profile-tests` to `master` with description "Add Behave/Robot coverage for safety profile validation + stub enforcement.". - [ ] Git [Rui]: `git checkout master` - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` @@ -4952,14 +5323,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Add CLI examples for equivalence list/add/remove. - [ ] Tests (Behave) [Hamza]: Add scenarios for linking/unlinking physical resources to virtual resources and divergence updates. - [ ] Tests (Robot) [Hamza]: Add Robot test that creates two identical physical resources and verifies a shared virtual resource. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/virtual_resource_bench.py` for equivalence update overhead. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/virtual_resource_bench.py` for equivalence update overhead. - [ ] 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(resource): add virtual resource equivalence tracking"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(resource): add virtual resource equivalence tracking"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-equivalence` to `master` with description "Add virtual resource equivalence tracking and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -4977,14 +5348,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Add examples for health check and version negotiation failures. - [ ] Tests (Behave) [Luis]: Add scenarios for connection errors and version mismatch handling. - [ ] Tests (Robot) [Luis]: Add mock-server connection tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/server_http_client_bench.py` for connection overhead baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/server_http_client_bench.py` for connection overhead baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(client): add server http client"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(client): add server http client"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with description "Add server HTTP client with health checks and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -5001,14 +5372,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Add examples for `agents sync --dry-run` outputs. - [ ] Tests (Behave) [Luis]: Add scenarios for sync conflicts and retry behavior. - [ ] Tests (Robot) [Luis]: Add mock-server sync tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/server_sync_bench.py` for sync throughput baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/server_sync_bench.py` for sync throughput baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(client): add plan sync and remote execution"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(client): add plan sync and remote execution"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with description "Add plan sync and remote execution with tests.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -5025,14 +5396,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Add examples of event payloads and resume behavior. - [ ] Tests (Behave) [Luis]: Add scenarios for reconnect and event ordering. - [ ] Tests (Robot) [Luis]: Add WebSocket mock tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/server_ws_bench.py` for message handling baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/server_ws_bench.py` for message handling baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(client): add websocket updates"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(client): add websocket updates"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with description "Add WebSocket updates for server plan events.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` @@ -5049,14 +5420,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Add examples for `project list --remote` and `plan use --remote`. - [ ] Tests (Behave) [Hamza]: Add scenarios for remote project selection errors. - [ ] Tests (Robot) [Hamza]: Add remote execution mock tests. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/server_remote_project_bench.py` for request overhead baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/server_remote_project_bench.py` for request overhead 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(client): add remote project support"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(client): add remote project support"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-server` to `master` with description "Add remote project support and CLI scaffolding.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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"** - [ ] Git [Rui]: `git checkout master` @@ -5073,14 +5444,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Rui]: Document history file location and privacy considerations. - [ ] Tests (Behave) [Rui]: Add REPL behavior scenarios (history on/off, unknown command, exit). - [ ] Tests (Robot) [Rui]: Add REPL smoke tests for command dispatch. - - [ ] Tests (ASV) [Rui]: Add `asv/benchmarks/repl_bench.py` for REPL startup baseline. + - [ ] Tests (ASV) [Rui]: Add `benchmarks/repl_bench.py` for REPL startup baseline. - [ ] Quality [Rui]: Run `nox` (all default sessions, including benchmark). - - [ ] 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%. 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 [Rui]: `git add .` (only after coverage check passes) - - [ ] Commit [Rui]: `git commit -m "feat(cli): add interactive repl"`. + - [ ] Git [Rui]: `git add .` (only after nox passes) + - [ ] Git [Rui]: `git commit -m "feat(cli): add interactive repl"` - [ ] Forgejo PR [Rui]: Open PR from `feature/m7-post-repl` to `master` with description "Add interactive REPL with history and tests.". - [ ] Git [Rui]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -5097,14 +5468,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Add examples for login/logout/status and token storage notes. - [ ] Tests (Behave) [Luis]: Add auth/team CLI scenarios (stubbed responses, missing server errors). - [ ] Tests (Robot) [Luis]: Add auth/team integration smoke tests. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/auth_cli_bench.py` for auth command baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/auth_cli_bench.py` for auth command baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(cli): add auth and team commands"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(cli): add auth and team commands"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-auth` to `master` with description "Add auth and team CLI commands with stubs and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Jeff]: `git checkout master` @@ -5118,14 +5489,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Jeff]: Add UI usage guide with navigation and data-refresh behavior. - [ ] Tests (Behave) [Jeff]: Add UI behavior scenarios (list, detail, diff, refresh). - [ ] Tests (Robot) [Jeff]: Add UI smoke tests for route loading and TUI navigation. - - [ ] Tests (ASV) [Jeff]: Add `asv/benchmarks/ui_render_bench.py` for UI render baseline. + - [ ] Tests (ASV) [Jeff]: Add `benchmarks/ui_render_bench.py` for UI render baseline. - [ ] 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(ui): add TUI/Web interface"`. + - [ ] Git [Jeff]: `git add .` (only after nox passes) + - [ ] Git [Jeff]: `git commit -m "feat(ui): add TUI/Web interface"` - [ ] Forgejo PR [Jeff]: Open PR from `feature/m7-post-tui` to `master` with description "Add TUI/Web UI stubs with tests.". - [ ] Git [Jeff]: `git checkout master` - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` @@ -5138,14 +5509,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Document database resource configuration and supported auth options. - [ ] Tests (Behave) [Hamza]: Add database resource scenarios (connection validation, read-only enforcement). - [ ] Tests (Robot) [Hamza]: Add database resource integration tests (local sqlite/duckdb only). - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/db_resource_bench.py` for resource registration baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/db_resource_bench.py` for resource registration 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(resource): add database resources"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(resource): add database resources"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-db` to `master` with description "Add database resource types and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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"** - [ ] Git [Hamza]: `git checkout master` @@ -5158,14 +5529,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Hamza]: Document cloud resource configuration and local-only stub behavior. - [ ] Tests (Behave) [Hamza]: Add cloud resource scenarios (schema validation, stub errors). - [ ] Tests (Robot) [Hamza]: Add cloud resource integration tests with stubbed responses. - - [ ] Tests (ASV) [Hamza]: Add `asv/benchmarks/cloud_resource_bench.py` for resource registration baseline. + - [ ] Tests (ASV) [Hamza]: Add `benchmarks/cloud_resource_bench.py` for resource registration 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 coverage check passes) - - [ ] Commit [Hamza]: `git commit -m "feat(resource): add cloud infrastructure resources"`. + - [ ] Git [Hamza]: `git add .` (only after nox passes) + - [ ] Git [Hamza]: `git commit -m "feat(resource): add cloud infrastructure resources"` - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-cloud` to `master` with description "Add cloud infrastructure resource stubs and tests.". - [ ] Git [Hamza]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -5178,14 +5549,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Document permission model, role matrix, and server-only behavior. - [ ] Tests (Behave) [Luis]: Add permission scenarios (allow/deny, missing role, server disabled). - [ ] Tests (Robot) [Luis]: Add permission integration tests with stubbed server client. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/permission_check_bench.py` for enforcement baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/permission_check_bench.py` for enforcement baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(security): add permission system"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(security): add permission system"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-permissions` to `master` with description "Add permission system stubs and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] 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"** - [ ] Git [Luis]: `git checkout master` @@ -5198,14 +5569,14 @@ Deferred items remain planned but are not part of the 30-day MVP scope. - [ ] Docs [Luis]: Document safety profile options, defaults, and server-only behavior. - [ ] Tests (Behave) [Luis]: Add safety profile enforcement scenarios (deny/allow paths). - [ ] Tests (Robot) [Luis]: Add safety profile integration tests with stubbed server client. - - [ ] Tests (ASV) [Luis]: Add `asv/benchmarks/safety_profile_bench.py` for enforcement baseline. + - [ ] Tests (ASV) [Luis]: Add `benchmarks/safety_profile_bench.py` for enforcement baseline. - [ ] 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 coverage check passes) - - [ ] Commit [Luis]: `git commit -m "feat(security): add safety profile enforcement"`. + - [ ] Git [Luis]: `git add .` (only after nox passes) + - [ ] Git [Luis]: `git commit -m "feat(security): add safety profile enforcement"` - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-safety` to `master` with description "Add safety profile enforcement stubs and tests.". - [ ] Git [Luis]: `git checkout master` - [ ] Git [Luis]: `git branch -d feature/m7-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%, if not repeat this task as many times as is needed until coverage reaches >=97%. --- @@ -5226,7 +5597,7 @@ Deferred items remain planned but are not part of the 30-day MVP scope. ### Week 1 (Days 1-7) - MVP Target (Source Code Only) | Day | Morning Focus | Owner | Afternoon Focus | Owner | |-----|---------------|-------|-----------------|-------| -| 1 | A5.alpha + A5.action_arguments DB migrations + ORM models | Jeff + Luis | B1.core Project/Resource models | Hamza | +| 1 | A5.alpha + A5.action_arguments DB migrations + ORM models | Hamza + Luis | B1.core Project/Resource models | Hamza | | 2 | A5.gamma repos/services + A5.tests + B3.cleanup (legacy project CLI) | Jeff + Brent (tests) | B2.persistence/B2.service + B3.cli Resource CLI | Hamza + Brent (tests) | | 3 | B4.sandbox git_worktree | Jeff + Hamza | B4.sandbox manager + tests | Luis + Brent (tests) | | 4 | C1.schema/C1.examples Actor YAML | Aditya | C2.loader/C2.compiler + C2.legacy v2 removal | Aditya + Jeff | @@ -5364,7 +5735,7 @@ execution_actor: openai/gpt-4 definition_of_done: "All files created successfully" EOF agents [--data-dir PATH] [--config-path PATH] action create --config /tmp/test_action.yaml -agents [--data-dir PATH] [--config-path PATH] action available local/test-action +# Action is available on create (no separate "available" step) # 2. Register a git resource (built-in git-checkout type) agents [--data-dir PATH] [--config-path PATH] resource add git-checkout local/main-repo \ @@ -5395,7 +5766,7 @@ cd /path/to/repo && git log -1 # Shows CleverAgents commit **Technical Criteria:** - Plan and Action records persist to SQLite database. -- Phase transitions (ACTION → STRATEGIZE → EXECUTE → APPLY → APPLIED) work correctly. +- Phase transitions (STRATEGIZE → EXECUTE → APPLY → APPLIED) work correctly. - Git worktree sandbox creates isolated working directory. - Changes in sandbox do not affect original until Apply. - At least 3 automation levels work (manual mode minimum). @@ -5418,7 +5789,7 @@ system_prompt: "You are a helpful coding assistant." EOF # Load actor -agents [--data-dir PATH] [--config-path PATH] actor add --file ./my_actor.yaml +agents [--data-dir PATH] [--config-path PATH] actor add --config ./my_actor.yaml # Create action using custom actor cat > /tmp/custom_action.yaml < @@ -5611,7 +5982,7 @@ WEEK 1 CRITICAL PATH: DAY 1-2: DATA LAYER ┌─────────────────────────────────────────────────────────────────┐ -│ [Jeff] A5.alpha DB migrations ═══► [Luis] A5.beta ORM models │ +│ [Hamza] A5.alpha DB migrations ═══► [Luis] A5.beta ORM models │ │ │ │ │ │ └───────────⊕───────────────┘ │ │ │ │