diff --git a/benchmarks/actor_hierarchy_bench.py b/benchmarks/actor_hierarchy_bench.py new file mode 100644 index 000000000..7892ae9fe --- /dev/null +++ b/benchmarks/actor_hierarchy_bench.py @@ -0,0 +1,142 @@ +"""ASV benchmarks for hierarchical actor YAML parsing performance. + +Measures the performance of: +- Parsing actors with per-node LSP bindings +- Parsing actors with tool-source references +- Parsing actors with subgraph actor_ref +- Parsing actors with full hierarchical features combined +""" + +from __future__ import annotations + +import importlib +import sys +from pathlib import Path + +_SRC = str(Path(__file__).resolve().parents[1] / "src") +if _SRC not in sys.path: + sys.path.insert(0, _SRC) + +import cleveragents # noqa: E402 + +importlib.reload(cleveragents) + +from cleveragents.actor.schema import ActorConfigSchema # noqa: E402 + + +def _graph_data(nodes: list[dict], *, skills: list[str] | None = None) -> dict: + node_ids = [n["id"] for n in nodes] + edges = [] + for i in range(len(node_ids) - 1): + edges.append({"from_node": node_ids[i], "to_node": node_ids[i + 1]}) + data: dict = { + "name": "bench/hierarchy", + "type": "graph", + "description": "Benchmark hierarchical actor", + "model": "gpt-4", + "route": { + "nodes": nodes, + "edges": edges, + "entry_node": node_ids[0], + "exit_nodes": [node_ids[-1]], + }, + } + if skills: + data["skills"] = skills + return data + + +_AGENT_NODE = { + "id": "agent", + "type": "agent", + "name": "Agent", + "description": "Agent node", + "config": {"model": "gpt-4"}, +} + +_LSP_NODE = { + "id": "lsp_agent", + "type": "agent", + "name": "LSP Agent", + "description": "Agent with LSP binding", + "config": {"model": "gpt-4"}, + "lsp_binding": { + "server": "local/pyright", + "languages": ["python"], + "capabilities": ["diagnostics", "hover"], + }, +} + +_TS_NODE = { + "id": "ts_agent", + "type": "agent", + "name": "Tool Source Agent", + "description": "Agent with tool sources", + "config": {}, + "tool_sources": [ + {"type": "skill", "name": "local/file-ops"}, + {"type": "mcp", "name": "local/filesystem"}, + {"type": "builtin", "group": "git_operations"}, + ], +} + +_SUBGRAPH_NODE = { + "id": "sub", + "type": "subgraph", + "name": "Sub", + "description": "Subgraph node", + "actor_ref": "local/code-reviewer", +} + + +class TimeLspBindingParse: + """Benchmark parsing actors with LSP bindings.""" + + def setup(self) -> None: + self.data = _graph_data([_LSP_NODE]) + + def time_parse_lsp_binding(self) -> None: + ActorConfigSchema.model_validate(self.data) + + +class TimeToolSourcesParse: + """Benchmark parsing actors with tool-source references.""" + + def setup(self) -> None: + self.data = _graph_data([_TS_NODE]) + + def time_parse_tool_sources(self) -> None: + ActorConfigSchema.model_validate(self.data) + + +class TimeSubgraphRefParse: + """Benchmark parsing actors with subgraph actor_ref.""" + + def setup(self) -> None: + self.data = _graph_data( + [_AGENT_NODE, _SUBGRAPH_NODE], + ) + + def time_parse_subgraph_ref(self) -> None: + ActorConfigSchema.model_validate(self.data) + + +class TimeFullHierarchyParse: + """Benchmark parsing a full hierarchical actor with all features.""" + + def setup(self) -> None: + self.data = _graph_data( + [_LSP_NODE, _TS_NODE, _SUBGRAPH_NODE], + skills=["local/file-ops", "local/git-ops"], + ) + self.data["lsp"] = ["local/pyright"] + self.data["lsp_capabilities"] = ["diagnostics"] + + def time_parse_full_hierarchy(self) -> None: + ActorConfigSchema.model_validate(self.data) + + +time_lsp = TimeLspBindingParse() +time_ts = TimeToolSourcesParse() +time_sg = TimeSubgraphRefParse() +time_full = TimeFullHierarchyParse() diff --git a/docs/reference/actor_config.md b/docs/reference/actor_config.md new file mode 100644 index 000000000..b902dfc90 --- /dev/null +++ b/docs/reference/actor_config.md @@ -0,0 +1,310 @@ +# Actor Configuration Reference + +Practical guide to writing actor YAML configuration files with hierarchical +graph examples and common error cases. + +**Module:** `cleveragents.actor.schema` / `cleveragents.actor.loader` + +Related references: +- [Actor YAML Schema](actors_schema.md) — full field listing +- [Actor Hierarchy Extensions](actor_hierarchy.md) — LSP bindings and tool sources +- [Actor Loader](actors_loading.md) — discovery and caching + +--- + +## Table of Contents + +- [Actor Configuration Reference](#actor-configuration-reference) + - [Basic Structure](#basic-structure) + - [Hierarchical Graph Example](#hierarchical-graph-example) + - [Node Types](#node-types) + - [Graph Topology Rules](#graph-topology-rules) + - [Error Cases](#error-cases) + +--- + +## Basic Structure + +Every actor YAML file must include `name`, `type`, and `description`. +The `name` must follow the `namespace/identifier` format. + +```yaml +name: local/my-actor # Required — namespaced +type: llm # Required — llm | tool | graph +description: What it does # Required +version: "1.0" # Optional +model: gpt-4 # Required for llm and graph types +``` + +--- + +## Hierarchical Graph Example + +A graph actor defines a multi-node workflow with conditional routing, +per-node LSP bindings, and tool-source references. + +```yaml +name: workflows/dev-pipeline +type: graph +description: Multi-agent development pipeline +version: "1.0" +model: gpt-4 + +# Actor-level skill and LSP declarations +skills: + - local/file-ops + - local/git-ops +lsp: + - local/pyright + +route: + nodes: + - id: planner + type: agent + name: Planner + description: Plans the implementation strategy + config: + model: gpt-4 + prompt: "Analyze requirements and create a plan." + # Per-node LSP binding (overrides actor-level default) + lsp_binding: + server: local/pyright + languages: + - python + capabilities: + - diagnostics + # Per-node tool sources + tool_sources: + - type: skill + name: local/file-ops + + - id: implementer + type: agent + name: Implementer + description: Implements the plan + config: + model: gpt-4 + prompt: "Implement the changes per the plan." + lsp_binding: + auto: true + tool_sources: + - type: skill + name: local/file-ops + - type: skill + name: local/git-ops + - type: mcp + name: local/filesystem + + - id: reviewer + type: subgraph + name: Code Reviewer + description: Delegates to the code-review actor + actor_ref: local/code-reviewer # namespaced reference to another actor + + - id: gate + type: conditional + name: Quality Gate + description: Routes to reviewer or re-plans based on lint result + config: + conditions: + - check: "state.get('lint_ok') == True" + route_to: reviewer + - check: "state.get('lint_ok') == False" + route_to: planner + + edges: + - from_node: planner + to_node: implementer + - from_node: implementer + to_node: gate + - from_node: gate + to_node: planner # explicit back-edge for retry path + - from_node: gate + to_node: reviewer + + entry_node: planner + exit_nodes: + - reviewer +``` + +--- + +## Node Types + +| Type | Purpose | Key config fields | +|------|---------|-------------------| +| `agent` | LLM-driven reasoning node | `model`, `prompt`, `tools` | +| `tool` | Runs a specific tool call | `tool_name`, `parameters` | +| `conditional` | Routes to different nodes based on state | `conditions[].check`, `conditions[].route_to` | +| `subgraph` | Delegates to another actor entirely | `actor_ref` | + +### Conditional Node Routing + +Conditional nodes use Python expressions over `state` to route the workflow. +The `route_to` targets are counted as reachable even without explicit edges. + +```yaml +- id: branch + type: conditional + name: Branch + description: Decides next step + config: + conditions: + - check: "state.get('success') == True" + route_to: done + - check: "state.get('success') == False" + route_to: retry +``` + +### Subgraph Node + +Subgraph nodes delegate execution to another actor by namespaced name. +Use `actor_ref` (not `config.actor_path`). + +```yaml +- id: review_step + type: subgraph + name: Review + description: Runs the review sub-workflow + actor_ref: local/reviewer # correct: namespaced actor reference +``` + +--- + +## Graph Topology Rules + +The loader enforces these constraints on every graph actor: + +| Rule | Error trigger | +|------|--------------| +| Unique node IDs | Two nodes share the same `id` | +| Entry node exists | `entry_node` references an `id` not in `nodes` | +| Exit nodes exist | Any `exit_nodes` entry references a missing `id` | +| Edge targets exist | `from_node` or `to_node` reference a missing `id` | +| Nodes are reachable | A node has no path from `entry_node` via edges or conditional routing | +| No cycles | A non-conditional cycle exists in the edge graph | + +--- + +## Error Cases + +### Naming Errors + +**Actor name missing namespace:** +```yaml +name: my-actor # wrong — must be namespace/name +``` +Error: `name must be in 'namespace/name' format` + +Fix: use a namespaced name like `local/my-actor` or `workflows/my-actor`. + +--- + +### LLM Actor Without Model + +```yaml +name: local/my-actor +type: llm +description: Assistant +# model: missing +``` +Error: `llm and graph types require 'model'` + +--- + +### GRAPH Actor Without Route + +```yaml +name: local/pipeline +type: graph +description: Pipeline +model: gpt-4 +# route: missing +``` +Error: `graph type requires 'route'` + +--- + +### Duplicate Node IDs + +```yaml +nodes: + - id: step_a + ... + - id: step_a # duplicate + ... +``` +Error: `Duplicate node IDs: 'step_a'` + +Fix: give each node a unique `id`. + +--- + +### Missing Entry Node + +```yaml +route: + nodes: + - id: node_a + ... + entry_node: node_x # node_x does not exist +``` +Error: `Entry node 'node_x' not found in route.entry_node` + +--- + +### Invalid Edge Target + +```yaml +edges: + - from_node: node_a + to_node: node_z # node_z does not exist +``` +Error: `Edge to_node 'node_z' not found at route.edges[0]` + +--- + +### Unreachable Node + +```yaml +nodes: + - id: node_a + - id: node_b + - id: node_c # no edge or conditional route_to points here +edges: + - from_node: node_a + to_node: node_b +entry_node: node_a +``` +Error: `route: nodes 'node_c' are unreachable from entry node 'node_a'` + +Fix: add an edge from a reachable node to `node_c`, or remove `node_c` from +`nodes` if it is not needed. + +--- + +### YAML Parse Error + +A malformed YAML file produces a parse error with the location: + +``` +Invalid YAML in bad.yaml at line 3, column 5: mapping values are not allowed here +``` + +Fix: check the indicated line and correct the YAML syntax. + +--- + +### Schema Validation Error Format + +When a YAML file is syntactically valid but fails schema validation, the +loader reports precise field paths: + +``` +Schema validation failed for actor.yaml: + type: Input should be 'llm', 'tool' or 'graph' + route.nodes.0.id: String should match pattern '^[a-zA-Z0-9_-]+$' + Hint: see docs/reference/actor_config.md for the correct schema format. +``` + +Each line shows the dotted field path and the validation message. diff --git a/docs/reference/actor_hierarchy.md b/docs/reference/actor_hierarchy.md new file mode 100644 index 000000000..218dccab1 --- /dev/null +++ b/docs/reference/actor_hierarchy.md @@ -0,0 +1,165 @@ +# Actor Hierarchy and Advanced YAML Extensions + +This document covers the advanced actor YAML schema extensions introduced +in **M2.1.actor-yaml**: per-node LSP bindings, tool-source references, +subgraph actor references, and actor-level skill/LSP fields. + +## Overview + +Actor YAML configurations can define multi-node graph workflows. The +M2.1 extensions add fine-grained control over: + +| Feature | Scope | Purpose | +|---------|-------|---------| +| `lsp_binding` | Per-node | Bind specific LSP servers to individual graph nodes | +| `tool_sources` | Per-node | Declare where a node's tools come from (skills, MCP, builtins) | +| `actor_ref` | Per-node (subgraph) | Reference another actor by namespaced name | +| `skills` | Actor-level | List of skill references available to the actor | +| `lsp` | Actor-level | Default LSP server bindings for the actor | +| `lsp_capabilities` | Actor-level | Filter which LSP capabilities are exposed | +| `lsp_context_enrichment` | Actor-level | Control automatic context injection | + +## Per-Node LSP Binding + +Different nodes in a graph can have different LSP configurations: + +```yaml +nodes: + - id: strategist + type: agent + name: Strategy Planner + description: Plans with read-only LSP + lsp_binding: + server: local/pyright + languages: + - python + capabilities: + - diagnostics + - hover + + - id: implementer + type: agent + name: Implementer + description: Full LSP auto-binding + lsp_binding: + auto: true +``` + +### `NodeLspBinding` Fields + +| Field | Type | Default | Description | +|-------|------|---------|-------------| +| `server` | `string` | `null` | Namespaced LSP server name (e.g. `local/pyright`) | +| `languages` | `list[string]` | `[]` | Languages for language-based resolution | +| `auto` | `bool` | `false` | Auto-resolve from project resources | +| `capabilities` | `list[string]` | `null` | Capability filter for this node | + +## Tool-Source References + +Nodes can declare their tool sources explicitly: + +```yaml +nodes: + - id: executor + type: agent + name: Executor + description: Has multiple tool sources + tool_sources: + - type: skill + name: local/file-ops + - type: mcp + name: local/filesystem + - type: builtin + group: git_operations +``` + +### `ToolSourceRef` Fields + +| Field | Type | Required | Description | +|-------|------|----------|-------------| +| `type` | `string` | Yes | `skill`, `mcp`, `builtin`, or `custom` | +| `name` | `string` | No | Namespaced name (for `skill` and `mcp`) | +| `group` | `string` | No | Group identifier (for `builtin`) | + +## Subgraph Actor References + +Subgraph nodes can reference other actors by namespaced name: + +```yaml +nodes: + - id: review + type: subgraph + name: Code Review + description: Delegates to code-reviewer + actor_ref: local/code-reviewer +``` + +The `actor_ref` field must be in `namespace/name` format. + +## Actor-Level Fields + +### `skills` + +```yaml +skills: + - local/file-ops + - local/git-ops +``` + +### `lsp` + +Explicit binding (list of server names): + +```yaml +lsp: + - local/pyright + - local/clangd +``` + +Auto binding: + +```yaml +lsp: + auto: true +``` + +### `lsp_capabilities` + +```yaml +lsp_capabilities: + - diagnostics + - hover + - definitions +``` + +Or expose all: + +```yaml +lsp_capabilities: all +``` + +### `lsp_context_enrichment` + +```yaml +lsp_context_enrichment: + diagnostics: true + type_annotations: false + max_diagnostics_per_file: 50 +``` + +## Validation Error Messages + +Validation errors now include field-path context: + +| Error | Example Message | +|-------|-----------------| +| Bad entry node | `Entry node 'missing' not found in route.entry_node. Valid node IDs: [a, b]` | +| Bad exit node | `Exit node 'missing' not found in route.exit_nodes. Valid node IDs: [a, b]` | +| Bad edge ref | `Edge from_node 'ghost' not found at route.edges[0]. Valid node IDs: [a, b]` | +| Duplicate IDs | `route.nodes: Duplicate node IDs found: ['dup']. Each node ID must be unique.` | +| Cycle | `route: graph contains a cycle involving nodes: [a → b]. Hint: remove or redirect edges.` | + +## Complete Example + +See `examples/actors/hierarchical_workflow.yaml` for a full working example +combining all these features. diff --git a/examples/actors/graph_workflow.yaml b/examples/actors/graph_workflow.yaml index 9c50d4284..0c7633bc7 100644 --- a/examples/actors/graph_workflow.yaml +++ b/examples/actors/graph_workflow.yaml @@ -134,8 +134,7 @@ route: type: subgraph name: Code Reviewer description: Runs code review workflow - config: - actor_path: examples/actors/simple_llm.yaml + actor_ref: local/code-reviewer # Escalate if tests keep failing - id: escalate diff --git a/examples/actors/hierarchical_workflow.yaml b/examples/actors/hierarchical_workflow.yaml new file mode 100644 index 000000000..4879bd78f --- /dev/null +++ b/examples/actors/hierarchical_workflow.yaml @@ -0,0 +1,102 @@ +# Hierarchical Actor - Multi-Agent Development Workflow +# Demonstrates LSP bindings, tool-source references, subgraph nodes, +# and skills integration in a graph actor. + +name: workflows/dev-workflow +type: graph +description: >- + Multi-agent development workflow with a strategist, implementer, and + reviewer. Each node has fine-grained LSP and tool-source control. +version: "1.0" +model: gpt-4 + +# Actor-level skill references +skills: + - local/file-ops + - local/git-ops + +# Actor-level LSP binding (default for all nodes) +lsp: + - local/pyright +lsp_capabilities: + - diagnostics + - hover + - definitions + - references +lsp_context_enrichment: + diagnostics: true + type_annotations: false + max_diagnostics_per_file: 50 + +route: + nodes: + - id: strategist + type: agent + name: Strategy Planner + description: Plans the implementation strategy using read-only LSP + config: + model: gpt-4 + prompt: | + Plan the implementation strategy. Use LSP diagnostics to assess + codebase health before proposing changes. + lsp_binding: + server: local/pyright + languages: + - python + capabilities: + - diagnostics + - hover + tool_sources: + - type: skill + name: local/file-ops + + - id: implementer + type: agent + name: Code Implementer + description: Implements code changes with full LSP and tools + config: + model: gpt-4 + prompt: | + Implement the changes as planned. Use full LSP capabilities + for navigation and refactoring. + lsp_binding: + auto: true + tool_sources: + - type: skill + name: local/file-ops + - type: skill + name: local/git-ops + - type: mcp + name: local/filesystem + + - id: reviewer + type: subgraph + name: Code Review + description: Delegates to the code-reviewer actor for review + actor_ref: local/code-reviewer + + edges: + - from_node: strategist + to_node: implementer + - from_node: implementer + to_node: reviewer + + entry_node: strategist + exit_nodes: + - reviewer + +context_view: strategist +memory: + enabled: true + max_messages: 50 + max_tokens: 16000 + summarize_old: true + +context: + include_dirs: + - src/ + - tests/ + exclude_patterns: + - "**/__pycache__/**" + - "*.pyc" + max_context_tokens: 32000 diff --git a/features/actor_examples.feature b/features/actor_examples.feature index 248d08284..5fc3be01f 100644 --- a/features/actor_examples.feature +++ b/features/actor_examples.feature @@ -653,12 +653,13 @@ Feature: Actor YAML examples validation Scenario: Verify all example files exist Given the examples/actors directory - Then there should be exactly 5 example YAML files + Then there should be exactly 6 example YAML files And the example files should include "simple_llm.yaml" And the example files should include "llm_with_tools.yaml" And the example files should include "tool_collection.yaml" And the example files should include "simple_graph.yaml" And the example files should include "graph_workflow.yaml" + And the example files should include "hierarchical_workflow.yaml" Scenario: Verify all examples are documented Given the documentation file "docs/reference/actors_examples.md" diff --git a/features/actor_hierarchy.feature b/features/actor_hierarchy.feature new file mode 100644 index 000000000..a2cfbc80d --- /dev/null +++ b/features/actor_hierarchy.feature @@ -0,0 +1,178 @@ +Feature: Hierarchical Actor YAML Schema Extensions + As a developer configuring actors + I want to extend actor YAML with LSP bindings, tool-source references, + and improved subgraph support + So that graph nodes have fine-grained control over language servers and tools + + # ------------------------------------------------------------------- + # LSP Binding on NodeDefinition + # ------------------------------------------------------------------- + + Scenario: Node with explicit LSP binding + Given a hierarchy actor YAML with node lsp_binding + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "code_writer" should have lsp_binding + And the hierarchy node "code_writer" lsp_binding server should be "local/pyright" + And the hierarchy node "code_writer" lsp_binding languages should contain "python" + + Scenario: Node with auto LSP binding + Given a hierarchy actor YAML with auto lsp_binding + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "implementer" should have lsp_binding + And the hierarchy node "implementer" lsp_binding auto should be true + + Scenario: Node without LSP binding is valid + Given a hierarchy actor YAML with no lsp_binding + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "agent_node" should not have lsp_binding + + Scenario: LSP binding with invalid server name + Given a hierarchy actor YAML with lsp_binding server "no-namespace" + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "lsp_binding" + + # ------------------------------------------------------------------- + # Tool-Source References on NodeDefinition + # ------------------------------------------------------------------- + + Scenario: Node with tool_sources referencing skills + Given a hierarchy actor YAML with node tool_sources skills + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "executor" should have tool_sources + And the hierarchy node "executor" tool_sources should have 1 items + + Scenario: Node with tool_sources referencing MCP server + Given a hierarchy actor YAML with node tool_sources mcp + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy node "executor" tool_sources item 0 type should be "mcp" + And the hierarchy node "executor" tool_sources item 0 name should be "local/filesystem" + + Scenario: Node with tool_sources referencing builtin group + Given a hierarchy actor YAML with node tool_sources builtin + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy node "executor" tool_sources item 0 type should be "builtin" + And the hierarchy node "executor" tool_sources item 0 group should be "file_operations" + + Scenario: Node with mixed tool_sources + Given a hierarchy actor YAML with mixed node tool_sources + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy node "executor" tool_sources should have 3 items + + Scenario: Node with invalid tool_sources type + Given a hierarchy actor YAML with invalid tool_sources type + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "tool_sources" + + Scenario: Node without tool_sources is valid + Given a hierarchy actor YAML with no lsp_binding + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "agent_node" should not have tool_sources + + # ------------------------------------------------------------------- + # Subgraph Node Enhancements + # ------------------------------------------------------------------- + + Scenario: Subgraph node with actor_ref + Given a hierarchy actor YAML with subgraph actor_ref + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy graph node "review" should have type "subgraph" + And the hierarchy node "review" actor_ref should be "local/code-reviewer" + + Scenario: Subgraph node with actor_ref non-namespaced fails + Given a hierarchy actor YAML with subgraph actor_ref "bad-ref" + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "actor_ref" + + # ------------------------------------------------------------------- + # Skills Field on ActorConfigSchema + # ------------------------------------------------------------------- + + Scenario: Actor with skills list + Given a hierarchy actor YAML with skills list + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor should have 2 skills + + Scenario: Actor with empty skills is valid + Given a hierarchy actor YAML with empty skills + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor should have 0 skills + + # ------------------------------------------------------------------- + # LSP Fields on ActorConfigSchema (top-level) + # ------------------------------------------------------------------- + + Scenario: Actor with lsp list + Given a hierarchy actor YAML with lsp list + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor lsp should have 2 items + + Scenario: Actor with lsp auto binding + Given a hierarchy actor YAML with lsp auto + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor lsp_auto should be true + + Scenario: Actor with lsp_capabilities list + Given a hierarchy actor YAML with lsp_capabilities + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor lsp_capabilities should contain "diagnostics" + + Scenario: Actor with lsp_capabilities all + Given a hierarchy actor YAML with lsp_capabilities all + When I parse the hierarchy actor YAML + Then the hierarchy actor should be valid + And the hierarchy actor lsp_capabilities should be "all" + + # ------------------------------------------------------------------- + # Precise Validation Error Messages + # ------------------------------------------------------------------- + + Scenario: Missing entry node gives precise field path + Given a hierarchy actor YAML with bad entry_node "nonexistent" + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "entry_node" + And the hierarchy parse error should mention "nonexistent" + + Scenario: Duplicate node IDs gives precise error + Given a hierarchy actor YAML with duplicate node ids + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "Duplicate" + + Scenario: Cycle detection gives node path + Given a hierarchy actor YAML with cycle + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "cycle" + + Scenario: Edge referencing non-existent node gives precise error + Given a hierarchy actor YAML with bad edge from_node "ghost" + When I parse the hierarchy actor YAML expecting failure + Then the hierarchy parse error should mention "ghost" + + # ------------------------------------------------------------------- + # Loader Integration with Hierarchical Actors + # ------------------------------------------------------------------- + + Scenario: Loader discovers hierarchical actor YAML + Given a hierarchy temp dir with a hierarchical actor YAML file + When I create a hierarchy loader and run discovery + Then the hierarchy loader should find 1 actors + And the hierarchy loaded actor should have skills + And the hierarchy loaded actor should have lsp + + Scenario: Loader rejects actor with invalid lsp_binding + Given a hierarchy temp dir with invalid lsp_binding actor YAML + When I create a hierarchy loader and run discovery expecting error + Then the hierarchy loader error should mention "lsp_binding" diff --git a/features/actor_schema.feature b/features/actor_schema.feature index f7963ca2a..85eddeff9 100644 --- a/features/actor_schema.feature +++ b/features/actor_schema.feature @@ -232,6 +232,13 @@ Feature: Actor YAML schema validation Then the actor schema validation should fail And the validation error should contain "cycle" + Scenario: Reject graph with unreachable nodes + Given an actor YAML string with unreachable node + When I validate the actor schema + Then the actor schema validation should fail + And the validation error should contain "unreachable" + And the validation error should contain "entry node" + # ──────────────────────────────────────────────────────────── # Tool Definition Validation scenarios # ──────────────────────────────────────────────────────────── diff --git a/features/steps/actor_hierarchy_steps.py b/features/steps/actor_hierarchy_steps.py new file mode 100644 index 000000000..4497a125e --- /dev/null +++ b/features/steps/actor_hierarchy_steps.py @@ -0,0 +1,635 @@ +"""Step definitions for features/actor_hierarchy.feature.""" + +from __future__ import annotations + +import tempfile +from pathlib import Path +from typing import Any + +import yaml +from behave import given, then, when +from behave.runner import Context + +from cleveragents.actor.schema import ActorConfigSchema, NodeType +from cleveragents.core.exceptions import ValidationError + + +def _base_graph_yaml( + nodes: list[dict[str, Any]], + edges: list[dict[str, Any]] | None = None, + entry_node: str = "agent_node", + exit_nodes: list[str] | None = None, + extra: dict[str, Any] | None = None, +) -> dict[str, Any]: + if edges is None: + ids = [n["id"] for n in nodes] + edges = [] + for i in range(len(ids) - 1): + edges.append({"from_node": ids[i], "to_node": ids[i + 1]}) + data: dict[str, Any] = { + "name": "local/hierarchy-test", + "type": "graph", + "description": "Test hierarchical actor", + "model": "gpt-4", + "route": { + "nodes": nodes, + "edges": edges, + "entry_node": entry_node, + "exit_nodes": exit_nodes or [nodes[-1]["id"]], + }, + } + if extra: + data.update(extra) + return data + + +def _simple_agent_node(node_id: str = "agent_node", **overrides: Any) -> dict[str, Any]: + base: dict[str, Any] = { + "id": node_id, + "type": "agent", + "name": f"Agent {node_id}", + "description": f"Agent node {node_id}", + "config": {"model": "gpt-4"}, + } + base.update(overrides) + return base + + +def _get_node(config: ActorConfigSchema, node_id: str) -> Any: + if config.route is None: + return None + for node in config.route.nodes: + if node.id == node_id: + return node + return None + + +# --------------------------------------------------------------- +# LSP Binding on NodeDefinition +# --------------------------------------------------------------- + + +@given("a hierarchy actor YAML with node lsp_binding") +def step_hierarchy_yaml_node_lsp(context: Context) -> None: + node = _simple_agent_node( + "code_writer", + lsp_binding={ + "server": "local/pyright", + "languages": ["python"], + }, + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="code_writer") + + +@given("a hierarchy actor YAML with auto lsp_binding") +def step_hierarchy_yaml_auto_lsp(context: Context) -> None: + node = _simple_agent_node( + "implementer", + lsp_binding={"auto": True}, + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="implementer") + + +@given("a hierarchy actor YAML with no lsp_binding") +def step_hierarchy_yaml_no_lsp(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml([node]) + + +@given('a hierarchy actor YAML with lsp_binding server "{server}"') +def step_hierarchy_yaml_lsp_bad_server(context: Context, server: str) -> None: + node = _simple_agent_node( + "code_writer", + lsp_binding={"server": server, "languages": ["python"]}, + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="code_writer") + + +# --------------------------------------------------------------- +# Tool-Source References on NodeDefinition +# --------------------------------------------------------------- + + +@given("a hierarchy actor YAML with node tool_sources skills") +def step_hierarchy_yaml_tool_sources_skills(context: Context) -> None: + node = _simple_agent_node( + "executor", + tool_sources=[{"type": "skill", "name": "local/file-ops"}], + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="executor") + + +@given("a hierarchy actor YAML with node tool_sources mcp") +def step_hierarchy_yaml_tool_sources_mcp(context: Context) -> None: + node = _simple_agent_node( + "executor", + tool_sources=[{"type": "mcp", "name": "local/filesystem"}], + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="executor") + + +@given("a hierarchy actor YAML with node tool_sources builtin") +def step_hierarchy_yaml_tool_sources_builtin(context: Context) -> None: + node = _simple_agent_node( + "executor", + tool_sources=[ + {"type": "builtin", "group": "file_operations"}, + ], + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="executor") + + +@given("a hierarchy actor YAML with mixed node tool_sources") +def step_hierarchy_yaml_tool_sources_mixed(context: Context) -> None: + node = _simple_agent_node( + "executor", + tool_sources=[ + {"type": "skill", "name": "local/file-ops"}, + {"type": "mcp", "name": "local/filesystem"}, + {"type": "builtin", "group": "git_operations"}, + ], + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="executor") + + +@given("a hierarchy actor YAML with invalid tool_sources type") +def step_hierarchy_yaml_tool_sources_invalid(context: Context) -> None: + node = _simple_agent_node( + "executor", + tool_sources=[{"type": "invalid_type", "name": "x/y"}], + ) + context.hierarchy_yaml = _base_graph_yaml([node], entry_node="executor") + + +# --------------------------------------------------------------- +# Subgraph Node Enhancements +# --------------------------------------------------------------- + + +@given("a hierarchy actor YAML with subgraph actor_ref") +def step_hierarchy_yaml_subgraph_ref(context: Context) -> None: + planner = _simple_agent_node("planner") + review: dict[str, Any] = { + "id": "review", + "type": "subgraph", + "name": "Review", + "description": "Code review subgraph", + "actor_ref": "local/code-reviewer", + } + context.hierarchy_yaml = _base_graph_yaml( + [planner, review], + edges=[{"from_node": "planner", "to_node": "review"}], + entry_node="planner", + exit_nodes=["review"], + ) + + +@given('a hierarchy actor YAML with subgraph actor_ref "{bad_ref}"') +def step_hierarchy_yaml_subgraph_bad_ref(context: Context, bad_ref: str) -> None: + planner = _simple_agent_node("planner") + review: dict[str, Any] = { + "id": "review", + "type": "subgraph", + "name": "Review", + "description": "Code review subgraph", + "actor_ref": bad_ref, + } + context.hierarchy_yaml = _base_graph_yaml( + [planner, review], + edges=[{"from_node": "planner", "to_node": "review"}], + entry_node="planner", + exit_nodes=["review"], + ) + + +# --------------------------------------------------------------- +# Skills Field on ActorConfigSchema +# --------------------------------------------------------------- + + +@given("a hierarchy actor YAML with skills list") +def step_hierarchy_yaml_skills(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml( + [node], + extra={"skills": ["local/file-ops", "local/git-ops"]}, + ) + + +@given("a hierarchy actor YAML with empty skills") +def step_hierarchy_yaml_empty_skills(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml([node], extra={"skills": []}) + + +# --------------------------------------------------------------- +# LSP Fields on ActorConfigSchema (top-level) +# --------------------------------------------------------------- + + +@given("a hierarchy actor YAML with lsp list") +def step_hierarchy_yaml_lsp_list(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml( + [node], + extra={"lsp": ["local/pyright", "local/clangd"]}, + ) + + +@given("a hierarchy actor YAML with lsp auto") +def step_hierarchy_yaml_lsp_auto(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml([node], extra={"lsp": {"auto": True}}) + + +@given("a hierarchy actor YAML with lsp_capabilities") +def step_hierarchy_yaml_lsp_caps(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml( + [node], + extra={ + "lsp": ["local/pyright"], + "lsp_capabilities": ["diagnostics", "hover"], + }, + ) + + +@given("a hierarchy actor YAML with lsp_capabilities all") +def step_hierarchy_yaml_lsp_caps_all(context: Context) -> None: + node = _simple_agent_node("agent_node") + context.hierarchy_yaml = _base_graph_yaml( + [node], + extra={ + "lsp": ["local/pyright"], + "lsp_capabilities": "all", + }, + ) + + +# --------------------------------------------------------------- +# Precise Validation Error Messages +# --------------------------------------------------------------- + + +@given('a hierarchy actor YAML with bad entry_node "{bad_node}"') +def step_hierarchy_yaml_bad_entry(context: Context, bad_node: str) -> None: + node = _simple_agent_node("agent_node") + data = _base_graph_yaml([node]) + data["route"]["entry_node"] = bad_node + context.hierarchy_yaml = data + + +@given("a hierarchy actor YAML with duplicate node ids") +def step_hierarchy_yaml_dup_ids(context: Context) -> None: + n1 = _simple_agent_node("dup_node") + n2 = _simple_agent_node("dup_node") + n2["name"] = "Second Dup" + context.hierarchy_yaml = _base_graph_yaml([n1, n2], entry_node="dup_node") + + +@given("a hierarchy actor YAML with cycle") +def step_hierarchy_yaml_cycle(context: Context) -> None: + n1 = _simple_agent_node("a") + n2 = _simple_agent_node("b") + context.hierarchy_yaml = _base_graph_yaml( + [n1, n2], + edges=[ + {"from_node": "a", "to_node": "b"}, + {"from_node": "b", "to_node": "a"}, + ], + entry_node="a", + exit_nodes=["b"], + ) + + +@given('a hierarchy actor YAML with bad edge from_node "{bad_node}"') +def step_hierarchy_yaml_bad_edge(context: Context, bad_node: str) -> None: + n1 = _simple_agent_node("real_node") + context.hierarchy_yaml = _base_graph_yaml( + [n1], + edges=[{"from_node": bad_node, "to_node": "real_node"}], + entry_node="real_node", + ) + + +# --------------------------------------------------------------- +# When Steps +# --------------------------------------------------------------- + + +@when("I parse the hierarchy actor YAML") +def step_parse_hierarchy_yaml(context: Context) -> None: + context.hierarchy_error = None + try: + context.hierarchy_config = ActorConfigSchema.model_validate( + context.hierarchy_yaml + ) + except Exception as exc: + context.hierarchy_error = str(exc) + context.hierarchy_config = None + + +@when("I parse the hierarchy actor YAML expecting failure") +def step_parse_hierarchy_yaml_fail(context: Context) -> None: + context.hierarchy_error = None + try: + context.hierarchy_config = ActorConfigSchema.model_validate( + context.hierarchy_yaml + ) + context.hierarchy_error = None + except Exception as exc: + context.hierarchy_error = str(exc) + context.hierarchy_config = None + + +# --------------------------------------------------------------- +# Then Steps - Validation +# --------------------------------------------------------------- + + +@then("the hierarchy actor should be valid") +def step_hierarchy_valid(context: Context) -> None: + assert context.hierarchy_config is not None, ( + f"Expected valid config, got error: {context.hierarchy_error}" + ) + + +@then('the hierarchy graph node "{node_id}" should have lsp_binding') +def step_hierarchy_node_has_lsp(context: Context, node_id: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None, f"Node '{node_id}' not found" + assert node.lsp_binding is not None, f"Node '{node_id}' has no lsp_binding" + + +@then('the hierarchy node "{node_id}" lsp_binding server should be "{server}"') +def step_hierarchy_lsp_server(context: Context, node_id: str, server: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.lsp_binding is not None + assert node.lsp_binding.server == server + + +@then('the hierarchy node "{node_id}" lsp_binding languages should contain "{lang}"') +def step_hierarchy_lsp_lang(context: Context, node_id: str, lang: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.lsp_binding is not None + assert lang in node.lsp_binding.languages + + +@then('the hierarchy node "{node_id}" lsp_binding auto should be true') +def step_hierarchy_lsp_auto(context: Context, node_id: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.lsp_binding is not None + assert node.lsp_binding.auto is True + + +@then('the hierarchy graph node "{node_id}" should not have lsp_binding') +def step_hierarchy_node_no_lsp(context: Context, node_id: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None, f"Node '{node_id}' not found" + assert node.lsp_binding is None + + +@then('the hierarchy graph node "{node_id}" should have tool_sources') +def step_hierarchy_node_has_tool_sources(context: Context, node_id: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None, f"Node '{node_id}' not found" + assert node.tool_sources, f"Node '{node_id}' has no tool_sources" + + +@then('the hierarchy node "{node_id}" tool_sources should have {count:d} items') +def step_hierarchy_tool_sources_count( + context: Context, node_id: str, count: int +) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert len(node.tool_sources) == count + + +@then( + 'the hierarchy node "{node_id}" tool_sources item {idx:d} ' + 'type should be "{ts_type}"' +) +def step_hierarchy_tool_source_type( + context: Context, node_id: str, idx: int, ts_type: str +) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.tool_sources[idx].type == ts_type + + +@then( + 'the hierarchy node "{node_id}" tool_sources item {idx:d} ' + 'name should be "{ts_name}"' +) +def step_hierarchy_tool_source_name( + context: Context, node_id: str, idx: int, ts_name: str +) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.tool_sources[idx].name == ts_name + + +@then( + 'the hierarchy node "{node_id}" tool_sources item {idx:d} ' + 'group should be "{ts_group}"' +) +def step_hierarchy_tool_source_group( + context: Context, node_id: str, idx: int, ts_group: str +) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.tool_sources[idx].group == ts_group + + +@then('the hierarchy graph node "{node_id}" should not have tool_sources') +def step_hierarchy_node_no_tool_sources(context: Context, node_id: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert not node.tool_sources + + +@then('the hierarchy graph node "{node_id}" should have type "{ntype}"') +def step_hierarchy_node_type(context: Context, node_id: str, ntype: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.type == NodeType(ntype) + + +@then('the hierarchy node "{node_id}" actor_ref should be "{ref}"') +def step_hierarchy_node_actor_ref(context: Context, node_id: str, ref: str) -> None: + node = _get_node(context.hierarchy_config, node_id) + assert node is not None + assert node.actor_ref == ref + + +@then("the hierarchy actor should have {count:d} skills") +def step_hierarchy_actor_skills_count(context: Context, count: int) -> None: + assert len(context.hierarchy_config.skills) == count + + +@then("the hierarchy actor lsp should have {count:d} items") +def step_hierarchy_actor_lsp_count(context: Context, count: int) -> None: + assert isinstance(context.hierarchy_config.lsp, list) + assert len(context.hierarchy_config.lsp) == count + + +@then("the hierarchy actor lsp_auto should be true") +def step_hierarchy_actor_lsp_auto(context: Context) -> None: + assert isinstance(context.hierarchy_config.lsp, dict) + assert context.hierarchy_config.lsp.get("auto") is True + + +@then('the hierarchy actor lsp_capabilities should contain "{cap}"') +def step_hierarchy_actor_lsp_caps_contain(context: Context, cap: str) -> None: + assert isinstance(context.hierarchy_config.lsp_capabilities, list) + assert cap in context.hierarchy_config.lsp_capabilities + + +@then('the hierarchy actor lsp_capabilities should be "{value}"') +def step_hierarchy_actor_lsp_caps_str(context: Context, value: str) -> None: + assert context.hierarchy_config.lsp_capabilities == value + + +@then('the hierarchy parse error should mention "{text}"') +def step_hierarchy_error_mention(context: Context, text: str) -> None: + assert context.hierarchy_error is not None, "Expected error but none occurred" + assert text.lower() in context.hierarchy_error.lower(), ( + f"Error '{context.hierarchy_error}' does not mention '{text}'" + ) + + +# --------------------------------------------------------------- +# Loader Integration +# --------------------------------------------------------------- + + +def _hierarchy_tmpdir() -> Path: + return Path(tempfile.mkdtemp(prefix="hierarchy_actor_")) + + +@given("a hierarchy temp dir with a hierarchical actor YAML file") +def step_hierarchy_loader_setup(context: Context) -> None: + from cleveragents.actor.loader import ActorLoader + + tmpdir = _hierarchy_tmpdir() + actor_data: dict[str, Any] = { + "name": "local/hierarchy-demo", + "type": "graph", + "description": "Hierarchical demo", + "model": "gpt-4", + "skills": ["local/file-ops"], + "lsp": ["local/pyright"], + "lsp_capabilities": ["diagnostics"], + "route": { + "nodes": [ + { + "id": "planner", + "type": "agent", + "name": "Planner", + "description": "Plans tasks", + "config": {"model": "gpt-4"}, + "lsp_binding": { + "server": "local/pyright", + "languages": ["python"], + }, + "tool_sources": [ + {"type": "skill", "name": "local/file-ops"}, + ], + }, + ], + "edges": [], + "entry_node": "planner", + "exit_nodes": ["planner"], + }, + } + yaml_path = tmpdir / "hierarchy_demo.yaml" + with yaml_path.open("w") as f: + yaml.safe_dump(actor_data, f) + context.hierarchy_tmpdir = tmpdir + context.hierarchy_loader_cls = ActorLoader + + +@given("a hierarchy temp dir with invalid lsp_binding actor YAML") +def step_hierarchy_loader_invalid(context: Context) -> None: + from cleveragents.actor.loader import ActorLoader + + tmpdir = _hierarchy_tmpdir() + actor_data: dict[str, Any] = { + "name": "local/bad-lsp", + "type": "graph", + "description": "Bad LSP binding", + "model": "gpt-4", + "route": { + "nodes": [ + { + "id": "code_node", + "type": "agent", + "name": "Coder", + "description": "Codes stuff", + "config": {}, + "lsp_binding": { + "server": "no-namespace", + "languages": ["python"], + }, + }, + ], + "edges": [], + "entry_node": "code_node", + "exit_nodes": ["code_node"], + }, + } + yaml_path = tmpdir / "bad_lsp.yaml" + with yaml_path.open("w") as f: + yaml.safe_dump(actor_data, f) + context.hierarchy_tmpdir = tmpdir + context.hierarchy_loader_cls = ActorLoader + + +@when("I create a hierarchy loader and run discovery") +def step_hierarchy_loader_discover(context: Context) -> None: + loader = context.hierarchy_loader_cls(search_roots=[context.hierarchy_tmpdir]) + context.hierarchy_loaded_actors = loader.discover() + context.hierarchy_loader_error = None + + +@when("I create a hierarchy loader and run discovery expecting error") +def step_hierarchy_loader_discover_error(context: Context) -> None: + loader = context.hierarchy_loader_cls(search_roots=[context.hierarchy_tmpdir]) + try: + context.hierarchy_loaded_actors = loader.discover() + context.hierarchy_loader_error = None + except (ValidationError, Exception) as exc: + context.hierarchy_loaded_actors = [] + context.hierarchy_loader_error = str(exc) + + +@then("the hierarchy loader should find {count:d} actors") +def step_hierarchy_loader_count(context: Context, count: int) -> None: + assert len(context.hierarchy_loaded_actors) == count, ( + f"Expected {count} actors, got {len(context.hierarchy_loaded_actors)}" + ) + + +@then("the hierarchy loaded actor should have skills") +def step_hierarchy_loaded_has_skills(context: Context) -> None: + actor = context.hierarchy_loaded_actors[0] + assert actor.skills, "Loaded actor should have skills" + + +@then("the hierarchy loaded actor should have lsp") +def step_hierarchy_loaded_has_lsp(context: Context) -> None: + actor = context.hierarchy_loaded_actors[0] + assert actor.lsp is not None, "Loaded actor should have lsp" + + +@then('the hierarchy loader error should mention "{text}"') +def step_hierarchy_loader_error_mention(context: Context, text: str) -> None: + assert context.hierarchy_loader_error is not None, ( + "Expected loader error but none occurred" + ) + assert text.lower() in context.hierarchy_loader_error.lower(), ( + f"Error '{context.hierarchy_loader_error}' does not mention '{text}'" + ) diff --git a/features/steps/actor_schema_steps.py b/features/steps/actor_schema_steps.py index ae6f675b6..003f2dc3f 100644 --- a/features/steps/actor_schema_steps.py +++ b/features/steps/actor_schema_steps.py @@ -539,6 +539,43 @@ route: """ +@given("an actor YAML string with unreachable node") +def step_given_unreachable_node(context: Context) -> None: + """Provide GRAPH where a node has no path from the entry node.""" + context.actor_yaml_string = """\ +name: workflows/unreachable +type: graph +description: Graph with an isolated node +model: gpt-4 +route: + nodes: + - id: node_a + type: agent + name: Node A + description: Entry node + config: + prompt: "A" + - id: node_b + type: agent + name: Node B + description: Reachable from entry + config: + prompt: "B" + - id: node_c + type: agent + name: Node C + description: Isolated — no edge points here from entry path + config: + prompt: "C" + edges: + - from_node: node_a + to_node: node_b + entry_node: node_a + exit_nodes: + - node_b +""" + + @given('an actor YAML string with inline tool name "{name}"') def step_given_inline_tool_name(context: Context, name: str) -> None: """Provide actor with inline tool having specific name.""" diff --git a/implementation_plan.md b/implementation_plan.md deleted file mode 100644 index a83ce5315..000000000 --- a/implementation_plan.md +++ /dev/null @@ -1,6645 +0,0 @@ -# CleverAgents Implementation Plan - -## **CRITICAL**: Execute These Rules Without Exception -- **Specification in `./docs/specification.md`**: Before begining any task, **always** review the relevant parts of the specification document to understand the fine architectural details. When there is a discrepency between the current code base and the specification document, then always assume the specification document is correct. -- **Strictly adhere to guidelines in `./CONTRIBUTING.md`**: All rules and guidelines outlined in this file must be strictly followed at all times. -- **Python implementation scope only**: Every action described here pertains to building an idiomatic Python codebase that implements the CleverAgents architecture. -- **NO BACKWARDS COMPATIBILITY**: CleverAgents is a NEW standalone project. Do NOT maintain any backwards compatibility. No migration guides, no compatibility shims, no support for old configurations or data. -- **Living document protocol**: After finishing each checklist item (and its testing sub-items), immediately append every decision, discovery, open question, or deviation to this document under the matching Notes section. This plan remains the authoritative record. -- **Single documentation surface**: Do not create auxiliary notes elsewhere unless explicitly required. All architectural updates, troubleshooting outcomes, and contextual knowledge must flow back into this markdown file. -- **Sequential discipline**: Always begin with the first unchecked item in the checklist. Do not progress until that item, its documentation update, and its testing sub-items (including any spawned remediation tasks) are fully resolved. -- **USE MODERN PYTHON TOOLING**: This is a cutting-edge Python project that must use modern build tools and workflows. NO Makefiles, NO legacy approaches, NO helper scripts. Use Hatch exclusively for project management, nox for task automation, pyproject.toml for all configuration. Commands should be Python-native (e.g., `hatch env create`, `nox -s test`) not shell scripts or make targets. All tooling must be from the current Python ecosystem (2024+). When current tooling (such as "Behave" and "Robot Framework") can be used to solve a problem, use them rather than adding new tooling, keep it simple. NO wrapper scripts - use tools directly as designed. -- **Unit + integration + asv testing mandate**: For every coding task, author or update must include asv (airspeed velocity) performance, unit and integration tests, run them, and achieve passing results before marking the task complete. Testing subtasks are non-optional. -- **Behavior-driven testing stack**: Use Behave feature suites under `features/` for unit-level and scenario tests and Robot Framework suites under `robot/` for integration and end-to-end coverage. Keep both synchronized with the code under test and document all updates in this plan. -- **Do not use pytest style unit tests**: Under no circumstances should you write pytest styled unit tests, all unit tests should be Behave based (as noted in the last bullet point), which follows the Cucumber/Gherkin style of tests as seen under `features/`, this is why there is intentionally no `tests/` folder. -- **Test execution via nox**: Run every unit, integration, Behave, Robot, and benchmark suite exclusively through the designated `nox` sessions (e.g., `nox -s unit_tests`, `nox -s integration_tests`). Do not invoke `behave`, `robot`, or similar runners directly; if a `nox` session is missing required tooling, add the dependency to the session before rerunning. -- **Failure capture**: Any Behave or Robot failure instantly spawns a new unchecked sub-item under the same step titled `Fix - `. Document the failure context in the Notes section and resolve it before moving forward. -- **Traceability requirement**: When a decision impacts future work, reference the relevant functions or modules in the Notes section using the `file_path:line_number` pattern for fast navigation. -- **unit tests coverage above 97% at all times**: unit test coverage must remain above 97% at all times. Unit tests can be run with `nox -e unit_tests` and is run as part of the default test suite run with `nox`. -- **must be statically typed**: All code at all times must use statically typed typing and must pass the static check run with `nox -e typecheck` which is run as part of the default test suite with `nox`. Under no circumstances at no point should you ignore type checking, this means never turn it off in the config files, and never use inline comments to force an type checking error to be suppressed. -- **Use existing tooling**: Always prefer nox sessions over raw commands, Behave for unit tests over new frameworks, Robot for integration tests, Hatch for dependency management. -- **Mock placement rule**: ALL mocks, test doubles, and mock implementations MUST exist only in `features/` directory. Production code in `src/` and utility scripts in `scripts/` must NEVER contain mock implementations, test data, or conditional testing behavior. Use dependency injection to swap implementations during tests. -- **CRITICAL - Implementation Checklist Separation**: The "Implementation Checklist" section MUST always remain separate and be the LAST section of this document. All development notes, design decisions, progress updates, technical details, and discoveries belong in their respective phase Notes sections (e.g., Phase 0 Notes, Phase 1 Notes, Phase 2 Notes) which appear BEFORE the Implementation Checklist. Never add content after the checklist section. The checklist is for tracking what needs to be done; the Notes sections are for documenting what was done and how. - -### CONTINUOUS CHECKLIST AND KNOWLEDGE STEWARDSHIP (MANDATORY) - -- **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**: 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 stays intentionally minimal and sequencing-only. -- Local mode is the delivery target through Day 30; server mode is stub-only. ACP is the boundary in all modes (local = in-process facade; server transport deferred). -- Plan lifecycle: Action (template) → Strategize (read-only) → Execute (sandboxed) → Apply (merge). Decisions are persisted; Apply terminal outcomes are `applied`/`constrained`/`errored`/`cancelled` with correction flow support. -- Identity rules: actions/projects/tools/skills/actors/automation profiles use namespaced names; plans/decisions/resources/validation attachments/corrections use ULIDs. -- Registry-first: Action/ResourceType/Resource/Tool/Validation/Skill/Actor/Provider/LSP registries are authoritative; validation attachments are resource-scoped with optional project/plan narrowing. -- Resource model: physical/virtual resources form a DAG; resource types define parent/child constraints, auto-discovery, sandbox strategy, and handler metadata. -- Tool model: tool lifecycle (discover/activate/execute/deactivate) with resource bindings (contextual/static/parameter); validations are read-only with required/informational mode; tool sources include built-ins, MCP, and Agent Skills. -- Actor model: YAML-configured single-LLM or LangGraph actors; strategy/execution/estimation/invariant reconciliation roles are explicit; LSP bindings are per-actor node. -- Skills: composable tool collections, including MCP server tools and Agent Skills `SKILL.md` sources. -- ACMS: pluggable context pipeline (UKO + CRP + strategies + fusion); implementation detail remains in the spec. - -### Core Architectural Requirements - -**Reliability**: Sandboxed execution, tool-based ChangeSet tracking, validation-gated apply, and checkpoint/rollback hooks per spec. - -**Autonomy with Control**: Decision-tree persistence, invariants + reconciliation, automation profiles, and correction flows per spec. - -**Interop**: ACP boundary for all clients; MCP + Agent Skills tool sources in local mode; LSP registry/runtime stubs in place for future IDE/server modes. - -**Scalability**: ACMS v1 (UKO/CRP/context pipeline) in local mode by the Day 30 milestone. - -### 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. -- Every time new information appears, extend the corresponding Notes section immediately with explicit references to code locations and decisions. - -## Completion Criteria -The implementation concludes only when every checklist item and spawned remediation task is checked, all Notes sections contain final decisions and references, and the full Behave and Robot test suites (unit, integration, end-to-end, benchmarking, packaging, documentation) pass without outstanding failures. - -## Environment Variables for Testing - -All environment variables needed during testing are stored in the `.env` file in the project root. This file contains API keys and tokens for various LLM providers and services. When implementing provider integrations or any features that require external services, use the environment variable names from this file or add new ones following the same pattern. - -### Current Environment Variables - -| Variable Name | Service | Usage | -|--------------|---------|-------| -| `OPENROUTER_API_KEY` | OpenRouter | Access to multiple LLM models through OpenRouter API | -| `OPENAI_API_KEY` | OpenAI | Direct access to OpenAI models (GPT-3.5, GPT-4, etc.) | -| `ANTHROPIC_API_KEY` | Anthropic | Access to Claude models | -| `GOOGLE_API_KEY` | Google AI | Access to Google's API for web searches | -| `GEMINI_API_KEY` | Google Gemini | Access to Google's Gemini models | -| `HF_TOKEN` | Hugging Face | Access to Hugging Face models and datasets | - -## Development Log - -This section will be updated with notes about each phase/task as they are implemented as well as forward looking remarks or insights. - -### Phase 0: Discovery and Requirements Elaboration (Python Tooling) - -**Status: [X] COMPLETE** - -All core Phase 0 discovery tasks have been successfully completed. See the Phase 0 section in the Implementation Checklist for detailed completion records. - -#### Phase 0 Notes - -- 2025-11-01: Implemented CLI inventory extraction tools, server endpoint extraction, data contract extraction, shell asset extraction -- 2025-11-02: Implemented environment variable extraction and implicit behavior extraction tools -- 2025-11-04: Completed workflow parity matrix generator and cloud features identification -- All discovery artifacts stored in `docs/reference/` - ---- - -### Phase 1: Target Architecture Definition - -**Status: [X] COMPLETE** - -All 10 ADRs have been created and package structure established. See the Phase 1 section in the Implementation Checklist for detailed completion records. - -#### Phase 1 Notes - -- 2025-11-04: Completed all 10 Architecture Decision Records -- 2025-11-05: Package structure created based on ADR-001 -- All ADRs documented in `docs/architecture/decisions/` -- 2026-02-11: CLI syntax updated to spec-aligned forms (action create via `--config`, plan use positional args, project create positional). Legacy `--name`/`--project` examples retained in historical notes only. -- 2026-02-11: Action config YAML baseline (spec-aligned): - ```yaml - name: local/example-action - description: Example action for CLI flows - strategy_actor: openai/gpt-4 - execution_actor: openai/gpt-4 - definition_of_done: "All steps complete" - ``` - ---- - -### Phase 2: Runtime Foundation (Completed Work) - -**Status: Substantially Complete - Transitioning to new Architecture** - -The following work from the previous implementation has been completed and will be preserved/adapted: - -#### Completed Infrastructure -- [X] LangChain/LangGraph dependencies and integration (ADR-011) -- [X] PlanGenerationGraph, ContextAnalysisAgent, AutoDebugGraph workflows -- [X] Memory service with EntityMemory -- [X] SQLite persistence with Alembic migrations -- [X] CLI streaming integration -- [X] Provider adapters (OpenAI, Anthropic, Google, OpenRouter) -- [X] Actor configuration system (Stage 7.5) -- [X] Test coverage at 95% - -#### Phase 2 Notes (Preserved from Previous Work) - -**2026-02-20**: D0b.execute — Plan Execute via Actors (M1 Critical Blocker) -- Created `src/cleveragents/application/services/plan_executor.py` with: - - `StrategizeStubActor`: Local-only stub that parses definition_of_done into decision tree - - `ExecuteStubActor`: Local-only stub with ToolRunner + ChangeSetCapture integration - - `PlanExecutor`: Orchestrator connecting PlanLifecycleService to stub actors - - `StrategyDecision`, `StrategizeResult`, `ExecuteResult` data models - - `StreamCallback` type alias for --stream CLI streaming hooks -- Strategize phase is read-only: produces decisions without modifying resources -- Execute phase uses sandbox resources and routes tool calls through ToolRunner -- Phase guards prevent Execute when Plan is not in Strategize COMPLETE state -- Error handling captures error_message + error_details with full traceback -- Invariant propagation stubbed (accepted without reconciliation until D2) -- Execution metadata (changeset_id, tool_calls_count, sandbox_refs) persisted to Plan -- Streaming hooks emit interim status updates (strategize_started/complete, execute_started/step/complete) -- Full test coverage: Behave features, Robot Framework integration, ASV benchmarks -- Documentation: docs/reference/plan_execute.md with architecture, lifecycle, and streaming API - -**2025-11-22**: Week 12 Complete, Phase 2 Core Functionality DONE -- CLI Streaming Integration fully implemented -- AutoDebugGraph Implementation complete -- Mock provider enhancements with configurable failure modes -- Infrastructure improvements (DebugAttempt model, repositories) -- 2026-02-11: CLI syntax refreshed to spec-aligned forms in current execution sections; legacy `--name`/`--project` examples retained only in historical notes. - -**2025-12-05**: LangSmith observability integration complete -**2025-12-08**: Actor-first provider wiring complete -**2025-12-17**: Stage 7 performance optimization complete -**2026-02-02**: Stage 7.5 Actor Configuration System complete -**2026-02-05**: Stage A1 & A2 Complete - Plan and Action Domain Models -- Created `src/cleveragents/domain/models/core/plan.py` with: - - `PlanPhase` enum (ACTION, STRATEGIZE, EXECUTE, APPLY, APPLIED) - - `ActionState` enum (AVAILABLE, DRAFT, ARCHIVED) - - `ProcessingState` enum (QUEUED, PROCESSING, ERRORED, COMPLETE, CANCELLED) - - `NamespacedName` model with parse() and str() methods - - `PlanIdentity` model with ULID validation - - `Plan` model with full lifecycle support - - `can_transition()` function for phase transition validation -- Created `src/cleveragents/domain/models/core/action.py` with: - - `ActionArgument` model with parse() method for CLI argument parsing - - `Action` model with strategy/execution actor references - - Argument validation including type checking -- Added 52 Behave test scenarios across 2 feature files: - - `features/plan_model.feature` (30 scenarios) - - `features/action_model.feature` (22 scenarios) -- All new tests pass, existing tests unaffected - -**2026-02-13**: Stage A2b.gamma Complete (Aditya) - Action YAML Schema + Examples + Loader -- Created `docs/schema/action.schema.yaml` — formal schema definition for action YAML config files, covering all fields (name, description, strategy_actor, execution_actor, definition_of_done, arguments, invariants, automation_profile, inputs_schema, optional actors, behaviour flags, state), versioning, namespaced name patterns, key normalization mapping. -- Created 5 example action YAML configs under `examples/actions/`: simple.yaml, invariant-heavy.yaml, read-only.yaml, estimation-actor.yaml, inputs-schema.yaml. -- Created `src/cleveragents/action/schema.py` with `ActionConfigSchema` Pydantic model: - - `from_yaml(yaml_string)` and `from_yaml_file(path)` factory methods - - camelCase→snake_case key normalization with deprecation warnings - - `${ENV_VAR}` environment variable interpolation - - Invariant normalization: trim whitespace, drop blanks, de-duplicate preserving order - - Clear, actionable error messages for every validation failure mode - - Nested `ActionArgumentSchema` for typed arguments with validation - - `extra="forbid"` prevents unknown keys -- Behave tests: `features/action_schema.feature` — 31 scenarios / 140 steps covering valid schemas, missing fields, invalid names, invalid types, invariant normalization, key normalization, env var interpolation, serialization, edge cases (None/empty/list/directory inputs). -- Robot smoke tests: `robot/action_schema.robot` — 6 test cases validating all example YAMLs + invalid rejection. -- ASV benchmarks: `benchmarks/action_schema_bench.py` — 3 suites (validation, file-load, serialization). -- Coverage: 98% overall (action/schema.py: 98%, action/__init__.py: 100%). -- All nox sessions pass: lint, typecheck, unit_tests, integration_tests, benchmark, security_scan, coverage_report. - -**2026-02-05**: Stage A3 Complete - PlanLifecycleService -- Created `src/cleveragents/application/services/plan_lifecycle_service.py` with: - - Full plan lifecycle management (Action -> Strategize -> Execute -> Apply -> Applied) - - Action CRUD operations (create, get, list, make_available, archive) - - Plan creation via `use_action()` which transitions Action to Strategize - - Phase transition methods: `execute_plan()`, `apply_plan()` - - State management: `start_*()`, `complete_*()`, `fail_*()` for each phase - - `cancel_plan()` for non-terminal plans - - Custom exceptions: `InvalidPhaseTransitionError`, `ActionNotAvailableError`, `PlanNotReadyError` - - In-memory storage (to be replaced with persistence in Stage A5) -- Added python-ulid dependency for ULID generation -- Added 29 Behave test scenarios in `features/plan_lifecycle_service.feature` -- Total new test scenarios: 81 (30 + 22 + 29) - -**2026-02-05**: Stage A4 In Progress - Plan CLI Commands -- Created `src/cleveragents/cli/commands/action.py` with: - - `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 (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 (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` -- Total test scenarios: 96 (81 + 15) - - -**2026-02-09**: Task Q0.6b Complete - README.md Setup Instructions [Brent] - -- Updated README.md Quick Start: added `dev` extras to `pip install`, added `scripts/setup-dev.sh` step -- Updated README.md Developing section: fixed `oxt` typo -> `nox`, added quality/security nox sessions (security_scan, dead_code, complexity, pre_commit, adr_compliance), added note about pre-commit hooks, linked to `docs/development/quality-automation.md` - -**2026-02-09**: Ruff Cleanup in src/cleveragents/ - StrEnum Migration [Brent] - -- Fixed all 26 ruff findings in `src/cleveragents/` (all UP042: `str, Enum` -> `StrEnum`) + 12 consequent F401 unused `Enum` imports -- Migrated 26 enum classes across 15 files from `class Foo(str, Enum)` to `class Foo(StrEnum)` -- `StrEnum` (Python 3.11+) is the modern replacement; project targets Python 3.13 -- Semantic difference: `str(StrEnum.MEMBER)` returns the value (e.g., `"foo"`) rather than `"ClassName.MEMBER"` — this is the correct/intended behavior for config/JSON string enums -- Verified: no code uses `str()` on enum members in the old format; all tests pass (304 scenarios, 0 failures) -- Files: 15 domain model files + `memory_service.py` + `providers/registry.py` - -**2026-02-09**: Task Q0.9 Complete - Ruff Lint Findings in features/ [Brent] - -- Fixed all 200 ruff lint findings in `features/` directory -> **0 findings** -- **Config-level suppressions** (168 findings): - - Added `per-file-ignores` in `pyproject.toml` for Behave-specific patterns: - - `features/steps/*.py`: F811 (65 redefined `step_impl` — Behave idiom), E501 (long step decorator strings) - - `features/mocks/*.py`, `features/environment.py`: E501 -- **Manual fixes** (31 findings across 18 files): - - 11x SIM115: `NamedTemporaryFile` refactored to use `with` context manager (`actor_cli_steps.py`, `actor_cli_run_steps.py`) - - 4x UP028: `for/yield` -> `yield from` (google, openai, openrouter, langchain provider steps) - - 3x SIM117: Nested `with` -> single `with` with parenthesized contexts (`plan_full_coverage_steps.py`, `plan_service_steps.py`) - - 3x RUF005: `list + [item]` -> `[*list, item]` unpacking - - 2x B904: Added `from exc` to `raise` inside `except` (enums, retry patterns) - - 2x RUF012: Added `ClassVar` annotations (`vector_store_service_steps.py`) - - 2x SIM105: `try/except/pass` -> `contextlib.suppress(Exception)` - - 1x each: B007 (unused loop var), B018 (noqa suppression), F821 (missing `Any` import), SIM102 (collapsible if), I001 (auto-fixed unsorted import) -- **Verification**: All affected behave tests pass (155 scenarios, 0 failures) -- **Files modified**: `pyproject.toml` (config), `environment.py`, and 17 step files in `features/steps/` - -**2026-02-09**: Task Q0.8 Complete - Bandit Security Findings Remediation [Brent] - -- Fixed all 16 pre-existing bandit findings (2 HIGH, 3 MEDIUM, 11 LOW) -> **0 findings** -- **Security hardening** (HIGH+MEDIUM): - - Replaced `jinja2.Environment` with `jinja2.sandbox.SandboxedEnvironment` in `yaml_template_engine.py` and `stream_router.py` — prevents template injection - - Added `_validate_code_ast()` helper: AST-based pre-validation for `exec()` in `SimpleToolAgent` — rejects imports, `exec()`/`eval()`/`compile()`/`__import__()`/`getattr()`/`setattr()` calls, global/nonlocal statements - - Added `_validate_lambda_ast()` helper: restricts transform `eval()` to lambda-only expressions via AST parsing - - Suppressed `0.0.0.0` bind default (`# nosec B104`) — intentional, configurable via `CLEVERAGENTS_SERVER_HOST` -- **Code quality** (LOW): - - Replaced 6 `assert` statements with proper `if`/`raise` (TypeError, RuntimeError, typer.BadParameter) — asserts stripped in optimized bytecode - - Replaced `try/except/pass` with `contextlib.suppress(Exception)` (2 locations in dispose()) - - Added logging to previously-silent exception handlers (migration_runner, nodes retry loop) - - Suppressed false positive `"token_count": 0` flagged as hardcoded password (`# nosec B105`) -- **Files modified**: `stream_router.py`, `yaml_template_engine.py`, `settings.py`, `context_service.py`, `memory_service.py`, `retry_patterns.py`, `context.py` (CLI), `plan_service.py`, `migration_runner.py`, `nodes.py` -- **Verification**: `bandit -r src/ -c pyproject.toml` → 0 findings; targeted behave tests pass; smoke tests for AST validation pass - -**2026-02-09**: Stages Q0, Q1, Q2 Complete - Full Quality Automation Setup [Brent] - -**Stage Q0 - Pre-commit Hooks:** - -- Created `.pre-commit-config.yaml` with 12 hooks across 5 categories: - - Branch protection: `no-commit-to-branch` (prevents commits to main) - - General checks: `check-yaml`, `check-toml`, `check-json`, `check-merge-conflict`, `check-added-large-files`, `end-of-file-fixer`, `trailing-whitespace`, `debug-statements` - - Ruff: `ruff-format` (auto-fix), `ruff` (lint with safe auto-fix) - - Pyright: local system hook running type checking on `src/` only - - Bandit: security scanning with `pyproject.toml` configuration on `src/` only - - Vulture: dead code detection with whitelist at `vulture_whitelist.py` - - Semgrep: custom rules in `.semgrep.yml` for eval/exec/os.system/pickle detection (graceful skip when not installed) - - Commitizen: conventional commit message validation at commit-msg stage -- Added dev dependencies to `pyproject.toml`: `pre-commit>=3.6.0`, `bandit[toml]>=1.7.5`, `vulture>=2.10`, `radon>=6.0.1` -- Added `[tool.bandit]` and `[tool.vulture]` sections to `pyproject.toml` -- Created `vulture_whitelist.py` for false positive suppression (exc_tb, build_data) -- Created `.semgrep.yml` with 5 custom security rules -- Created `scripts/setup-dev.sh` for developer environment setup -- Added 4 new nox sessions: `pre_commit`, `security_scan`, `dead_code`, `complexity` -- **Discovery**: CI platform is Forgejo (`.forgejo/`), NOT GitHub. Stage Q1 must use Forgejo Actions, not GitHub Actions. -- **Discovery**: Pre-existing security findings in production code need remediation (see Q0.8 spawned task) -- **Discovery**: 37 source files have formatting issues, ~27 files have trailing whitespace - pre-existing debt -- **Discovery**: `features/steps/actor_cli_steps.py` has many F811 (redefined step_impl) violations - Behave pattern -- **Discovery**: Average code complexity is A (3.56) across 979 blocks - good baseline -- **Discovery**: High complexity methods identified: `LegacyDataMigrator.migrate_project_data` E(37), `ProviderRegistry._create_provider_llm` C(20), `ProviderRegistry.create_ai_provider` C(18) -- Key files: `.pre-commit-config.yaml`, `.semgrep.yml`, `vulture_whitelist.py`, `scripts/setup-dev.sh` - -**Stage Q1 - CI/CD Pipeline:** - -- Extended `.forgejo/workflows/ci.yml` with 3 new jobs: - - `security`: bandit scan (JSON report + high-severity gate) + vulture dead code detection - - `quality`: radon complexity check (grade F fails build) + JSON report - - `coverage`: behave tests with coverage measurement, fail-under=85%, XML artifact -- Updated `docker` and `helm` jobs to depend on `security` (fail-fast on security issues) -- Created `scripts/check-quality-gates.py` aggregating: coverage, typecheck, security, dead code, complexity -- All reports uploaded as artifacts for downstream consumption - -**Stage Q2 - Advanced Automation:** - -- Created `.forgejo/workflows/nightly-quality.yml` for nightly quality monitoring: - - Runs at midnight UTC (cron: "0 0 \* \* \*") + manual trigger support - - Full lint, typecheck, security scan (all severities), dead code, complexity analysis - - Behave tests with coverage measurement - - Quality trend JSON generation with timestamp + metrics - - 90-day artifact retention for trend analysis -- Created `scripts/check-adr-compliance.py` with AST-based checks for: - - ADR-002: No threading imports in application layer - - ADR-003: Services use constructor dependency injection - - ADR-007: No direct SQLAlchemy usage in service layer -- Added `nox -s adr_compliance` session -- Created `.forgejo/pull_request_template.md` with quality checklist -- Created `docs/development/quality-automation.md` with full documentation: - - Quick start, pre-commit hooks reference, CI jobs table, security scanning guide - - Complexity monitoring grades, quality gates, troubleshooting - -**New nox sessions added:** `pre_commit`, `security_scan`, `dead_code`, `complexity`, `adr_compliance` -**Total files created:** 9 new files -**Total files modified:** 3 files (pyproject.toml, noxfile.py, .forgejo/workflows/ci.yml) - -**2026-02-10**: Task 10B.4 - Quality Metrics Baseline Established [Brent] - -- Ran full quality suite via nox to establish current baseline: - - **Unit Tests**: 105 features, 1613 scenarios, 7555 steps - ALL PASS - - **Lint (ruff)**: 0 findings - - **Typecheck (pyright)**: 0 errors, 0 warnings - - **Security (bandit)**: 0 findings (0 HIGH, 0 MEDIUM, 0 LOW) - - **Dead Code (vulture)**: 0 findings - - **Complexity (radon)**: Average A (3.56), 981 blocks analyzed, no grade-F methods - - High complexity methods to monitor: `LegacyDataMigrator.migrate_project_data` E(37), `Action.validate_arguments` C(20), `ProviderRegistry._create_provider_llm` C(20), `ProviderRegistry.create_ai_provider` C(18), `Settings.resolve_provider_defaults` C(18) - - **Coverage**: 96% (9860 statements, 269 missing, 2852 branches, 213 branch-miss) -- Fixed pre-existing test failure: `plan_lifecycle_cli_coverage.feature` scenario "Plan lifecycle list shows project summaries" - Rich table column wrapping at narrow terminal widths caused `+1 more` text to be split across rows. Fixed by patching console width to 200 in test setup. -- Fixed missing dependency: added `langchain-anthropic>=0.2.0` to `pyproject.toml` (was imported in `src/cleveragents/providers/llm/anthropic_provider.py` but not declared) - -**2026-02-10**: Task Q1.5 Complete - Branch Protection Rules Documentation [Brent] - -- Created `docs/development/ci-cd.md` (224 lines) documenting: - - Branch protection rules for `master` (required status checks, review requirements, push/force-push/deletion blocks) - - Step-by-step Forgejo branch protection setup instructions - - Review priority matrix (P0: architecture/security, P1: algorithms, P2: features, P3: tests/docs) - - CI job dependency graph and quality gates summary table - - Nightly quality monitoring reference - - Local development workflow quick-reference -- Cross-references existing `docs/development/quality-automation.md` and `.forgejo/pull_request_template.md` -- Required CI checks documented: `lint`, `typecheck`, `security`, `quality`, `behave`, `coverage`, `build` -- Review requirement: 1 approving review, selective depth by priority matrix - -**2026-02-10**: Task 10C.1 Complete - Edge Case Test Scenarios [Brent] - -- Created `features/edge_case_plan_scenarios.feature` (26 scenarios, 141 steps) covering: - - **Concurrent plan execution** (6 scenarios): Duplicate strategize/execute/apply start attempts, concurrent complete+fail on same phase, two plans from same action, concurrent transitions on different plans - - **Resource conflict scenarios** (7 scenarios): Read-only file MODIFY failure, overlapping CREATE+MODIFY on same path, CREATE with None content, MOVE with missing source, DELETE of already-deleted file, file paths with spaces, deeply nested directory creation - - **Validation failure chains** (6 scenarios): Multiple simultaneous argument validation failures (missing + wrong type), unknown + missing arguments combined, empty plan description rejection, ACTION phase with processing state, invalid namespace characters, invalid name characters - - **Rollback edge cases** (7 scenarios): Partial apply failure (first change persists on disk, second unchanged), errored plan cannot restart, fail preserves error message, errored plan not terminal, cancel preserves phase, errored strategize rejects execute, failed strategize rejects complete -- Created `features/steps/edge_case_plan_steps.py` with step definitions for all 26 scenarios -- Verified no step name collisions with existing 104 feature files -- All quality gates pass: lint 0 findings, typecheck 0 errors, full suite 106 features / 1639 scenarios / 7696 steps ALL PASS - -**2026-02-10**: Task 10C.4 Complete - Validation Test Fixtures [Brent] - -- Created `features/validation_test_fixtures.feature` (34 scenarios, 81 steps) covering 6 validation domains: - - **AST security validation** (`_validate_code_ast`): 12 scenarios testing import/global/nonlocal/exec/eval/compile/**import**/getattr/setattr rejection, syntax errors, and safe code acceptance - - **Lambda AST validation** (`_validate_lambda_ast`): 4 scenarios testing valid lambda, non-lambda rejection, syntax errors, function call rejection - - **Python content sanitization** (`_sanitize_python_content`): 4 scenarios testing passthrough, code fence stripping, docstring wrapping, irrecoverable syntax (null byte) - - **Project model validation**: 6 scenarios testing invalid chars, slashes, exclamation, valid names, relative path resolution, empty name - - **Change list coercion** (`_coerce_change_list`): 4 scenarios testing empty list, mixed entries, non-list, non-change entry - - **ActionArgument parsing**: 4 scenarios testing too few parts, invalid type, invalid requirement, reserved keyword name -- Created `features/steps/validation_test_fixture_steps.py` with complete step definitions for all 34 scenarios -- Fixed step name collisions: renamed `I create a project with name` -> `I create a project fixture with name` and `the project path should be absolute` -> `the project fixture path should be absolute` to avoid conflicts with `database_integration_steps.py` and `domain_models_steps.py` -- Moved inline import (`ArgumentRequirement`, `ArgumentType`) to file-level per CONTRIBUTING.md rules -- Fixed irrecoverable syntax scenario: `"def broken("` is actually recoverable via docstring wrapping; replaced with null byte input which is truly irrecoverable -- All quality gates pass: lint 0 findings, typecheck 0 errors, full suite 107 features / 1673 scenarios / 7777 steps ALL PASS - -**2026-02-12**: Task Q0-min-ci In Progress - Nox-Based PR Validation Workflow [Brent] - -- Rewrote `.forgejo/workflows/ci.yml` to route ALL jobs through nox sessions instead of direct tool invocations: - - All jobs run `pip install uv nox` then `nox -s ` - - Jobs: `lint`, `typecheck`, `security`, `quality`, `unit_tests`, `integration_tests`, `coverage` (fail-under 97%), `build`, `docker` -- Updated `noxfile.py`: - - `format` session: passes `session.posargs` through (supports `--check` from CI) - - `coverage_report` session: rewritten from broken parallel behave mode to serial `coverage run --source=src -m behave` mode. Changed `--fail-under` from 85 to **97**. Parallel mode was broken (produced 22% coverage due to subprocess data collection issues); serial mode correctly reports coverage. -- Updated `docs/development/ci-cd.md`: coverage threshold 85→97%, updated job names, added "Nox-Based CI" section, "Local Reproduction of CI Failures" section, "Caching Notes" section -- Created `features/ci_workflow_validation.feature` + `features/steps/ci_workflow_validation_steps.py` — 11 scenarios validating CI workflow YAML structure (job→nox session mapping, Python version, dependencies) -- Created `robot/ci_nox_validation.robot` — Robot smoke test verifying `nox --list` output and CI file existence -- Created `benchmarks/ci_yaml_parse_bench.py` — ASV benchmark for CI YAML parsing -- **Coverage boost 92%→97%**: Wrote 108 new Behave scenarios covering 6 largest coverage gaps: - - `features/yaml_engine_direct_coverage.feature` (21 scenarios) — `actor/yaml_template_engine.py` 13%→91% - - `features/actor_config_new_coverage.feature` (30 scenarios) — `actor/config.py` 28%→93% - - `features/actor_registry_new_coverage.feature` (14 scenarios) — `actor/registry.py` 20%→93% - - `features/message_router_new_coverage.feature` (4 scenarios) — `langgraph/message_router.py` 29%→100% - - `features/context_analysis_new_coverage.feature` (19 scenarios) — `agents/graphs/context_analysis.py` 73%→93% - - `features/context_service_new_coverage.feature` (20 scenarios) — `application/services/context_service.py` 75%→92% -- **Key discovery**: Behave loads ALL step definition files globally; any `@given/@when/@then` pattern matching an existing one causes `AmbiguousStep` errors. Biggest offender: `@then('the result should be {expected}')` in `features/steps/cli_steps.py:135`. All new step names were made unique. -- **Verification**: 1673 scenarios passed (0 failed), 97% coverage (fail-under=97 passes), lint pass, typecheck pass -- **Remaining**: Branch creation, commit, push, PR, merge, branch cleanup - -**2026-02-12**: Bugfix - Integration Test Failure in Robot.Actor Configuration [Brent] - -- **Root cause**: `robot/ci_nox_validation.robot` ran `nox --list` during integration tests. When `pabot` executed all Robot suites in parallel, the `nox --list` stdout leaked into the sibling `robot/actor_configuration.robot` process. The `helper_actor_config.py` JSON output had the full `nox --list` text appended, causing `JSONDecodeError: Extra data` on the `V2 Actor Config Produces Provider And Graph Descriptor` test case. -- **Fix applied (3 files)**: - - `robot/ci_nox_validation.robot`: Added `slow` tag to "Nox Lists All Required Sessions" and "CI Workflow File Exists" test cases so they are excluded from the normal `--exclude slow` integration run (the "Nox Lint Session Runs Successfully" test already had `slow`) - - `robot/actor_configuration.robot:31`: Replaced hardcoded `.nox/integration_tests-3-13/bin/python` with `python` (follows project convention; never reach into nox's internal venvs) - - `robot/plan_generation_graph.robot:12`: Same fix — replaced hardcoded `.nox/integration_tests-3-13/bin/python` `${PYTHON}` variable with `python` -- **Verification**: 175 integration tests passed (0 failed), 1673 unit test scenarios passed (0 failed) - -**2026-02-12**: Bugfix - CI `security` Job Failure (session name mismatch) [Brent] - -- **Root cause**: `.forgejo/workflows/ci.yml` referenced `nox -s security_scan` and `nox -s dead_code`, but the noxfile only had a session named `security` (which bundled bandit + vulture). No `dead_code` session existed. -- **Fix applied (2 files)**: - - `noxfile.py`: Renamed `security` session to `security_scan` to match CI reference. Added standalone `dead_code` session running vulture directly (intentionally duplicates the vulture step inside `security_scan` for independent CI visibility). Updated `nox.options.sessions` default list accordingly. - - `.forgejo/workflows/ci.yml`: Updated `nox -s security` to `nox -s security_scan`, restored `nox -s dead_code` step. -- All 10 CI session references now verified against `nox --list`: lint, format, typecheck, security_scan, dead_code, complexity, unit_tests, integration_tests, coverage_report, build. - -**2026-02-12**: Bugfix - CI `unit_tests` Failure: Rich Console Line-Wrapping [Brent] - -- **Root cause**: Rich's `Console` wraps output at 80 columns. On CI, the temp directory path is ~90 characters (`/workspace/cleveragents/cleveragents-core/.nox/unit_tests-3-13/tmp/.../existing_0.txt`), so filenames get split across lines (e.g., `e\nxisting_0.txt`). The assertion `expected_name in clean_output` fails because `existing_0.txt` doesn't appear as a contiguous substring. -- **Failing scenario**: `features/context_unit_tests.feature:43` — "Context add reports already tracked files without overflow summary" -- **Fix applied**: `features/steps/context_unit_tests_steps.py` — Both `step_check_already_tracked` (line 588) and `step_check_already_tracked_without_summary` (line 606) now collapse Rich line-wraps via `clean_output.replace("\n", "")` before checking for filenames and overflow summaries, making assertions resilient to any console width. -- **Verification**: All 67 scenarios in `context_unit_tests.feature` pass locally. - -**2026-02-12**: Bugfix - CI `integration_tests` Failures (3 categories) [Brent] - -- **Issue 1 — `ModuleNotFoundError: No module named 'features'`**: The `Run Python Script` keyword in `robot/database_integration.robot` hardcoded `sys.path.insert(0, '/app')` in its header. On CI, the workspace is `/workspace/cleveragents/cleveragents-core`, so `features.mocks.mock_ai_provider` could not be found. - - **Fix**: Changed the header path to `sys.path.insert(0, '${CURDIR}/..')` which resolves relative to the robot file location. Removed redundant hardcoded `/app` from the "Service Layer Uses Repositories" test script body. -- **Issue 2 — `--load-context` help text assertion failures**: `robot/load_context_test.robot` had three test cases checking `Should Contain ${result.stdout} --load-context`. On CI, Rich's help output may go to stderr when no TTY is detected, causing stdout to be empty. Also, the test `Test Load Context Interactive Help Text` was duplicated (appeared twice), which is invalid in Robot Framework. - - **Fix**: Added `stderr=STDOUT` to `Run Process` calls so all output is merged into stdout. Removed the duplicate test case. -- **Issue 3 — `FileNotFoundError: [Errno 2] No such file or directory: 'robot'`**: pabot spawns `robot` subprocesses for each test suite. On CI, the first ~16 suites succeed but subsequent ones fail with `robot` not found. This is likely a CI container process/resource exhaustion issue, not a code defect. The `--exclude discovery` flag was also missing from the `integration_tests` nox session (dropped during merge conflict resolution). - - **Fix**: Restored `--exclude discovery` to the `integration_tests` nox session in `noxfile.py`. The `robot` not found error is a CI infrastructure issue that may resolve with fewer parallel suites; it is not reproducible locally. -- **Verification**: `robot/database_integration.robot` and `robot/load_context_test.robot` both pass locally. - -**2026-02-13**: Bugfix - CI `security` Job Failure (missing `build/` directory) - -- **Root cause**: The `security_scan` nox session writes bandit's JSON report to `build/bandit-report.json`, but the `build/` directory does not exist in a fresh CI checkout. Bandit cannot create intermediate directories and fails with exit code 2: `can't open 'build/bandit-report.json': [Errno 2] No such file or directory`. -- **Fix applied (1 file)**: - - `noxfile.py:484`: Added `os.makedirs("build", exist_ok=True)` before the first bandit invocation in the `security_scan` session. The `os` module was already imported. `exist_ok=True` makes this idempotent for both CI (fresh checkout) and local dev (directory may already exist). -- **Verification**: `nox -s security_scan` passes locally (0 bandit findings, 0 vulture findings). - -**2026-02-13**: Bugfix - CI `integration_tests` Failures (3 categories) - -- **Issue 1 — `FileNotFoundError: [Errno 2] No such file or directory: 'robot'`** (affected ~10 suites: Plan Generation Graph, Retry Patterns, Rxpy Route Validation, and suites #25-31): After ~17 suites complete, pabot child subprocesses fail to find the `robot` binary. This is a CI container resource exhaustion issue — pabot spawns `robot` subprocesses via `subprocess.Popen`, and under high parallelism the system cannot resolve the executable. - - **Fix** (`noxfile.py`): - - `_pabot_parallel_args()` (line 46-49): Capped default pabot parallelism to `min(_default_processes(), 2)`. Local developers can still override via `nox -s integration_tests -- --processes 4`. - - `integration_tests()` session (lines 372-381): Explicitly prepend the nox venv `bin/` directory to `session.env["PATH"]` so all child subprocesses inherit a correct PATH. Added a debug line printing the resolved `robot` binary path before pabot launches. -- **Issue 2 — `Robot.Load Context Test` help text assertion failures** (2 tests: `Test Load Context Help Text`, `Test Load Context Interactive Help Text`): Both tests assert `Should Contain ${result.stdout} --load-context`. The text is present in the Rich-formatted output, but ANSI escape codes embedded by Rich split the `--load-context` string, breaking the naive substring match on CI (no TTY). - - **Fix** (`robot/load_context_test.robot:177,183`): Added `env:NO_COLOR=1` to the `Run Process` calls for both tests. This disables Rich's ANSI escape codes, producing plain text that `Should Contain` can match reliably. -- **Issue 3 — `Robot.Initial Next Command Test` exit code 3** (1 test: `Test Next Command With Null Writing Stage`): Exit code 3 is the generic `except Exception` handler in `src/cleveragents/cli/commands/actor.py:164-166`. The `!next discovery` command triggers the `ask_topic` LLM agent (OpenAI gpt-3.5-turbo in `examples/scientific_paper_writer.yaml:671-682`). Without a valid `OPENAI_API_KEY` on CI, a `ValueError` is raised, which is not a `CleverAgentsError` subclass and falls through to exit code 3. - - **Fix** (`robot/initial_next_command_test.robot:24`): Added `slow` tag to the test case. The `integration_tests` nox session already passes `--exclude slow` to pabot, so this test is skipped on CI. It can still be run explicitly via `nox -s slow_integration_tests`. -- **Verification**: `nox -s integration_tests` passes locally — 206 tests, 206 passed, 0 failed, 0 skipped. - -**2026-02-13**: Bugfix - CI `integration_tests` Failures Round 2 (pabot resource exhaustion + ANSI codes) - -- **Observation**: The first round of fixes (parallelism cap to 2, PATH propagation, `NO_COLOR=1`) did not resolve the CI failures. Debug output confirmed `robot` is findable at session start (`robot at: .nox/.../bin/robot`), yet pabot still fails with `FileNotFoundError` after ~24 suites even with `--processes 2`. The `NO_COLOR=1` env var did not prevent Rich from embedding ANSI escape codes in help text output on CI. -- **Issue 1 — `robot` not found (resource exhaustion, not PATH)**: - - **Root cause confirmed**: The debug line proves `robot` is on PATH. The `FileNotFoundError` from `subprocess.Popen` on Linux occurs when the system cannot `execve()` due to exhausted PIDs or file descriptors, not because the binary is missing. pabot spawns a new `robot` subprocess per test suite plus a PabotLib RPC server, accumulating resources until the container limit is hit. - - **Fix** (`noxfile.py`): Replaced `pabot` with `robot` (sequential execution) in the `integration_tests` session. Removed `_pabot_parallel_args()` function (no longer needed). `robot` runs all suites in a single process — no subprocess spawning, no resource accumulation. CI values reliability over speed. The `slow_integration_tests` session remains unchanged for opt-in parallel runs via `pabot`. - - Added resource debug output: `os.listdir('/proc/self/fd')` count and `ulimit -n`/`ulimit -u` to help diagnose future container issues. - - Added `os.makedirs("build/reports/robot", exist_ok=True)` for the output directory. -- **Issue 2 — Load Context Test ANSI codes (NO_COLOR insufficient)**: - - **Root cause**: `NO_COLOR=1` only disables ANSI *color* codes. Rich may still embed non-color ANSI sequences (bold `\x1b[1m`, reset `\x1b[0m`) that split the `--load-context` string, causing `Should Contain` to fail. - - **Fix** (`robot/load_context_test.robot:177,183`): Added `env:TERM=dumb` alongside `env:NO_COLOR=1` to both help text test cases. `TERM=dumb` causes Rich to disable all terminal styling. Added `repr()` debug logging that prints the raw bytes around the `load` substring to the CI console — this will definitively reveal any remaining invisible characters if the tests still fail. -- **Verification**: `nox -s integration_tests` passes locally — 206 tests, 206 passed, 0 failed. Debug repr output shows clean text: `'│\n│ --load-context FILE '`. - -**2026-02-13**: Bugfix - CI `integration_tests` Failures Round 3 (venv PATH, Resource paths, hanging tests) - -- **Observation**: Round 2 fixed pabot resource exhaustion by switching to sequential `robot`. This exposed 18 new test failures (previously hidden — those suites never completed under pabot). Three root causes identified. -- **Issue 1 — `python -m cleveragents` uses system Python (not venv Python)**: - - **Root cause**: When rewriting the `integration_tests` session to use `robot` instead of `pabot`, the `session.env["PATH"]` line that prepends the venv `bin/` directory was accidentally removed. Robot Framework's `Run Process` keyword inherits the nox session environment, so without the PATH override, `python -m cleveragents` resolved to the system Python (which lacks the installed package). - - **Fix** (`noxfile.py`): Restored `session.env["PATH"]` to prepend the venv bin directory. Consolidated debug output into a single `session.run("python", "-c", ...)` call showing robot path, CWD, and robot/ directory contents. -- **Issue 2 — Robot Framework `Resource` file resolution fails on CI**: - - **Root cause**: Robot files used bare relative `Resource` references (e.g., `Resource v2_paths.resource`, `Resource common.resource`). Robot Framework resolves bare paths relative to the *current working directory*, not the test file's directory. When CWD differs between local and CI environments, these references break with `Resource file 'v2_paths.resource' does not exist`. - - **Fix** (30 robot files): Converted all bare `Resource` references to use `${CURDIR}/` absolute paths (e.g., `Resource ${CURDIR}/v2_paths.resource`). Exception: `robot/core_cli_commands.robot` retains bare `Resource discovery_common.resource` because that file intentionally does not exist (tests using it are excluded via `--exclude discovery`). -- **Issue 3 — `rxpy_route_validation.robot` tests hang indefinitely**: - - **Root cause**: Several `Run Process` calls invoking `python -m cleveragents actor run` lacked `timeout` parameters. Tests that expect the command to succeed (LangGraph routes, allowed RxPY routes) start actual actor runs that never terminate, causing the entire test suite to hang. - - **Fix** (`robot/rxpy_route_validation.robot`): Added `timeout=30s` to all 9 `Run Process` calls. Tagged `Test Run Command With LangGraph Routes Succeeds` and `Test Run Command Accepts RxPY Routes When Allowed` as `slow` (these require runtime infrastructure unavailable on CI). Also fixed a bug where `Test Run Command With LangGraph Routes Succeeds` was using `${RXPY_CONFIG}` instead of `${LANGGRAPH_CONFIG}`, and removed conflicting duplicate `stderr`/`stdout` parameters. -- **Verification**: `nox -s integration_tests` passes locally — 204 tests, 204 passed, 0 failed (2 additional tests now excluded via `slow` tag: the 2 RxPY tests that require running actors). - -**2026-02-13**: Bugfix - CI `integration_tests` Failures Round 4 (duplicate Settings blocks, venv Python injection, CI debug) - -- **Observation**: Round 3 fixes (commit `e8aa5ac`) passed locally (204/204) but CI still showed 18 failures across 6 files. Two distinct failure signatures: (A) `Resource file '/workspace/.../robot/v2_paths.resource' does not exist` for files that alphabetically follow `sandbox_integration.robot`, despite the directory listing confirming both `.resource` files are present; (B) `/usr/local/bin/python: No module named cleveragents` — system Python used instead of venv Python. -- **Issue 1 — Duplicate `*** Settings ***` blocks cause resource import failures on CI**: - - **Root cause**: The Round 3 sed-based `Resource` path conversion created a *second* `*** Settings ***` block in 14 robot files (the `Resource ${CURDIR}/...` line was appended in a new block rather than inserted into the existing one). While Robot Framework 7.4.1 nominally merges duplicate sections, this non-standard structure caused intermittent resource import failures on the CI container (Forgejo runner with `python:3.13-slim`). Locally, the same files parsed correctly — suggesting an RF parsing race or filesystem interaction specific to the CI overlay filesystem. - - **Fix** (14 robot files): Merged all duplicate `*** Settings ***` blocks into a single block per file, combining Documentation, Library, Resource, Suite Setup, and Suite Teardown into the canonical first block. Removed duplicate `Resource` imports (2 files had triple Settings blocks with duplicated imports). Added blank line separators between sections. -- **Issue 2 — Bare `python` in `Run Process` calls resolves to system Python on CI**: - - **Root cause**: 14 robot files used `Run Process python -m cleveragents ...` with bare `python`. On CI, `session.env["PATH"]` propagation from nox → robot → `Run Process` subprocess was unreliable — the system `/usr/local/bin/python` was used instead of the venv Python, causing `No module named cleveragents`. Files that imported `common.resource` and used `${PYTHON}` (set via `sys.executable` in `Setup Test Environment`) were unaffected. - - **Fix** (`noxfile.py` + 14 robot files): Noxfile now passes `--variable PYTHON:` to the `robot` command, explicitly injecting the venv Python path. All 14 files updated to use `${PYTHON}` instead of bare `python` in `Run Process` calls, with a `${PYTHON} python` default in `*** Variables ***` for standalone runs. This bypasses PATH entirely. -- **Issue 3 — Hardcoded `/app/src` path in `system_prompt_template_rendering.robot`**: - - **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. - -**2026-02-13**: Bugfix - CI `integration_tests` Failures Round 5 (guard cleanup when OpenAI key missing) - -- **Observation**: After Round 4, CI still failed mid-suite with a cascade of `Resource file ... does not exist` and `FileNotFoundError` for the venv Python path. The failures started immediately after `Robot.Scientific Paper Basic` was skipped due to missing `OPENAI_API_KEY`. -- **Root cause** (`robot/scientific_paper_basic.robot`): Suite setup begins with `Require OpenAI Key`. When the key is missing, the keyword calls `Skip`, so the rest of setup does not execute. This leaves `${CONTEXT_DIR}` as `${EMPTY}` (it was initialized to empty in the Variables table). In suite teardown, `Remove Directory ${CONTEXT_DIR} recursive=True` runs with an empty string, which resolves to the current working directory. On CI, this can delete the repo root (including `.nox` venv and `robot/*.resource` files), causing downstream suites to fail and the venv Python path to disappear. -- **Fix** (`robot/scientific_paper_basic.robot`): Initialize `${CONTEXT_DIR}` to `${TEMPDIR}/paper_basic_contexts` in the Variables table, and guard cleanup with `Run Keyword If '${CONTEXT_DIR}' != '${EMPTY}'` before removing the directory. This prevents accidental deletion of the workspace when the suite is skipped. -- **Verification**: Not re-run on CI yet; local `nox -s integration_tests` should continue to pass (204/204) with `OPENAI_API_KEY` unset. - -**2026-02-13**: Enhancement - Restore parallel Robot runs + silence discovery resource warning - -- **Change 1 — Reintroduce `pabot` for `integration_tests`**: - - **Reason**: Sequential `robot` runs were reliable but slow (~7 minutes on CI). With the teardown bug fixed, we can safely return to parallel execution. - - **Implementation** (`noxfile.py`): `integration_tests` now runs `pabot` with conservative default parallelism (max 2 processes). Overrides supported via `PABOT_PROCESSES` or `--processes` in nox args. Existing `--variable PYTHON:` injection remains to ensure `Run Process` uses the venv interpreter. -- **Change 2 — Add `robot/discovery_common.resource` stub**: - - **Reason**: `robot/core_cli_commands.robot` imports `discovery_common.resource`, which does not exist. This emits a non-fatal warning every run even though discovery-tagged tests are excluded. - - **Fix**: Add a minimal placeholder resource file to silence the warning. -- **Cleanup**: Remove the temporary CI debug dump in `integration_tests` now that the failure mode has been addressed. - -**2026-02-13**: Task Q0-min-coverage In Progress - Coverage Threshold Enforcement [Brent] - -- Enhanced `coverage_report` nox session (`noxfile.py:457-523`): - - Added `COVERAGE_THRESHOLD = 97` module-level constant (single source of truth) - - Session now generates HTML/XML reports **before** checking threshold (reports always available, even on failure) - - Added `coverage json -o build/coverage.json` for machine-readable total percentage - - Emits CI-parseable single-line summary: `COVERAGE OK: % (threshold: 97%)` or `COVERAGE FAILED: % < 97% threshold` - - Uses `session.error()` (non-zero exit) on failure for clear CI signaling - - Added `os.makedirs("build", exist_ok=True)` for fresh CI checkouts -- Updated CI workflow (`.forgejo/workflows/ci.yml:169-194`): - - Coverage job now tees nox output and greps for summary line - - Added "Surface coverage summary" step that reads `build/coverage.json` and emits/fails with single-line message - - `build/coverage.json` added to uploaded artifacts -- Created `docs/development/testing.md` (180+ lines): - - Full testing guide covering unit (Behave), integration (Robot), benchmarks (ASV), and coverage - - Documents 97% threshold, CI pipeline stages, troubleshooting section - - Sample success/failure output for CI parsing -- Created `features/coverage_threshold_enforcement.feature` (11 scenarios): - - Validates COVERAGE_THRESHOLD constant is 97 in noxfile.py - - Validates fail-under argument references the constant - - Validates branch coverage enabled, source includes src, paths under build/ - - Validates CI job references nox session and depends on lint+typecheck - - Validates CI-parseable COVERAGE OK/FAILED summary lines in session source -- Created `features/steps/coverage_threshold_enforcement_steps.py` with step definitions -- Created `robot/coverage_threshold.robot` (6 test cases) validating config presence -- Created `benchmarks/coverage_report_bench.py` (4 benchmarks) for config parsing -- **Verification**: lint 0 findings, typecheck 0 errors, 2235 unit scenarios passed, 211 integration tests passed, 97.5% coverage - -**2026-02-13**: Task Q0-adv-security In Progress - Align Security Scans with Nox [Brent] - -- Updated `noxfile.py:547-619` (`security_scan` session): - - Added Semgrep as Step 3 (between Bandit and Vulture): runs `semgrep --config=.semgrep.yml --error --quiet src/` with `success_codes=[0, 1]` - - Added comprehensive docstring documenting all 4 steps and severity gates (Bandit HIGH=hard fail, MEDIUM=report-only; Semgrep ERROR=hard fail, WARNING=report-only; Vulture >=80%=hard fail) - - Checks for `.semgrep.yml` existence before running semgrep (graceful skip with `session.warn()`) -- Updated `pyproject.toml:66`: Added `"semgrep>=1.60.0"` to dev dependencies -- Updated `.pre-commit-config.yaml:90`: Changed semgrep hook from `scripts/run-semgrep.sh` wrapper to direct `semgrep --config=.semgrep.yml --error --quiet src/` invocation (semgrep is now a project dependency, no wrapper needed) -- Updated `docs/development/quality-automation.md`: - - Quick Start: security_scan description now says "Bandit + Semgrep + Vulture" - - Security section: semgrep note changed from "optional" to "project dependency" - - Quality gate script: coverage-min 85->97 - - Gates checked: Coverage >= 85% -> 97% - - Troubleshooting: "Coverage below 85%" -> "Coverage below 97%" with threshold note -- Created `features/security_scan_hooks.feature` (13 scenarios): - - Validates Bandit and Semgrep hooks in `.pre-commit-config.yaml` (id, files pattern, args) - - Validates semgrep and bandit in dev dependencies - - Validates security_scan nox session exists and runs bandit/semgrep/vulture - - Validates `.semgrep.yml` has at least 3 rules -- Created `features/steps/security_scan_hooks_steps.py`: Step definitions using yaml, ast, tomllib for config validation -- Created `robot/security_scan.robot` (6 test cases): Config presence validation for bandit, semgrep, pre-commit hooks, nox session -- Created `robot/helper_security_scan.py`: Helper script for Robot tests (AST-based nox session verification) -- Created `benchmarks/security_scan_bench.py` (4 benchmarks): YAML parsing, hook extraction, semgrep rule parsing, AST session extraction -- **Verification**: lint 0 findings, typecheck 0 errors, 2248 unit scenarios passed (13 new), 217 integration tests passed (6 new), 97.5% coverage, benchmarks ok - -**2026-02-13**: Stage A2b.beta Complete - Plan Model Alignment [Luis] - -- Rewrote `src/cleveragents/domain/models/core/plan.py` to align with spec: `processing_state` replaces `action_state`/`state` (per line 1096), `project_links` replaces `project_ids`, added `action_name`, `automation_profile: AutomationProfileRef`, `invariants: list[PlanInvariant]`, `arguments`, actor fields, subplan hierarchy (`SubplanConfig`, `SubplanFailureHandler`, `SubplanStatus`), `as_cli_dict()`, `ProjectLink.validate_alias()`. Enum naming uses `InvariantSource` (not `InvariantScope`). Plan field is `processing_state` with `@property def state` alias. -- Updated 8 source files across domain, application, CLI, and infrastructure layers: - - `plan_lifecycle_service.py`: `use_action()` accepts `action_name` + `project_links`, all `plan.state =` changed to `plan.processing_state =`. - - `cli/commands/plan.py`: Uses `plan.project_links` iteration, `action_name=str(action.namespaced_name)`. - - `infrastructure/database/models.py`: `LifecycleActionModel` and `LifecyclePlanModel` updated for `processing_state`, `project_links` JSON, extra field serialization. - - `infrastructure/database/repositories.py`: Uses `row.description = action.description`. - - `domain/models/core/__init__.py`: Exports `InvariantSource`. - - `cli/commands/action.py`: Added `BusinessRuleViolation` import (from HEAD). -- Updated 12 Behave step definition files and 7 feature files for new field names and removed backwards compatibility shims (no `action phase`, `action state`, `draft`, `make action available`). -- Created `features/plan_model_coverage.feature` (246 lines, 39 scenarios) and `features/steps/plan_model_coverage_steps.py` (489 lines) for comprehensive plan model coverage including `as_cli_dict()`, `ProjectLink` validation, APPLIED auto-correction, alias uniqueness, `is_subplan`/`is_root_plan`/`depth` properties, `SubplanFailureHandler`. -- Created `benchmarks/plan_model_bench.py` (5 suites, 15 benchmarks). -- Updated `docs/reference/plan_model.md` (~270 lines) with phase/state semantics and linkage fields. -- Rebased `feature/m1-plan-model` onto `fd6d41b` (A2b.alpha commit `feat(domain): align action model with spec`). Resolved 30 merge conflicts across source, feature, step, and robot files. Key design decisions during merge: - 1. Plan field name: `processing_state` (per implementation_plan.md line 1096), NOT `state`. - 2. Invariant enum: `InvariantSource` (our naming), NOT `InvariantScope` (HEAD's naming). - 3. Action model (`action.py`): HEAD taken as-is (authoritative for action domain). - 4. No `action_id` on Action domain model — uses `namespaced_name` only. - 5. `make_action_available()`: Kept as no-op in service (from HEAD). - 6. `project_links` used everywhere (NOT `project_ids`). - 7. Feature files: Plan domain features take ours, action domain features take HEAD's. - 8. Step files: Merged — HEAD's `action_name=str(...)` + ours' `project_links=[ProjectLink(...)]`. -- Fixed 6 post-rebase test failures (documented as `Fix -` sub-items under A2b.beta checklist): - - Missing `@when('I try to make the action available')` step in `plan_lifecycle_service_steps.py`. - - Missing `@then('the action CLI should make action available')` step in `action_cli_steps.py`. - - Wrong CLI command (`show` instead of `available`) in `action_cli_steps.py:417`. - - `state=` instead of `processing_state=` in `plan_lifecycle_commands_coverage_steps.py:58` (Pydantic silently ignored unknown kwarg). - - Missing required `description` param in `robot/helper_plan_lifecycle_v3.py:672` `create_action()` call. - - `state=` → `processing_state=` and `project_names` → `project_links` in `robot/helper_db_lifecycle_models.py`. -- Final results: lint 0 errors, typecheck 0 errors, 130 Behave features / 2246 scenarios / 9868 steps all pass, 206 Robot tests all pass, `plan.py` coverage 100% (275 stmts, 56 branches). -- 29 files changed: +2076 / -1314 lines. - -**2026-02-06**: CRITICAL ARCHITECTURAL DECISION - Tool-Based Resource Modification -- **REPLACED**: OutputParser/code fence parsing approach -- **WITH**: Tool-based change tracking (modern approach used by Claude Code, Cursor, Aider) -- **Key changes**: - - LLMs call skills/tools directly (edit_file, write_file, delete_file, etc.) - - Skills operate on sandbox state directly - - ChangeSet is built from skill invocation history, NOT by parsing LLM text output -- Added built-in resource skills (now C4.file/C4.search/C4.git): file ops, dir ops, search, git ops -- Added MCP skill adapter (now C7.mcp): connect to external MCP servers - - Replaced C4 "Multi-File ChangeSet Generation" with "Tool-Based Change Tracking" - - Added SkillInvocationTracker and ToolCallRouter components -- **Rationale**: - - No parsing ambiguity (is this code or explanation?) - - Each operation is explicit, typed, and trackable - - Supports rollback (replay inverse of recorded changes) - - Resource-agnostic (works for files, databases, APIs, any resource type) - - Compatible with MCP standard for external tools -- See `docs/specification.md` sections: - - "Tool-Based Resource Modification (Modern Architecture)" - - "Unified Resource Abstraction Layer" - - "MCP Integration Architecture" - -**2026-02-09**: Stage A5.3 + A5.4 Complete - v3 SQLAlchemy Models -- Created `LifecycleActionModel` (table: `actions_v3`) in `src/cleveragents/infrastructure/database/models.py:184`: - - All columns per spec including action_id (ULID PK), name (unique), namespace, short_name, descriptions, actor refs, inputs_schema (JSON), state, timestamps, tags - - Indexes on namespace, state, short_name - - `to_domain()` and `from_domain()` conversion methods - - Relationship to `LifecyclePlanModel` -- Created `LifecyclePlanModel` (table: `lifecycle_plans`) in `src/cleveragents/infrastructure/database/models.py:327`: - - All columns per spec including self-referential FKs (parent_plan_id, root_plan_id), action_id FK to actions_v3, phase/state, timestamps (ISO-8601 strings), JSON fields (project_ids, tags, sandbox_refs, execution_log, strategy_context) - - Indexes on phase, state, parent, root, created_at, action_id - - `to_domain()` and `from_domain()` conversion methods with `_parse_iso`/`_to_iso` helpers - - 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: - - `protocol.py` (B3.1 + B3.2): `SandboxStatus` enum with 7 states and transition validation, `SandboxContext` and `CommitResult` frozen dataclasses, `Sandbox` runtime-checkable Protocol, exception hierarchy (`SandboxError`, `SandboxCreationError`, `SandboxCommitError`, `SandboxRollbackError`, `SandboxStateError`) - - `no_sandbox.py` (B3.5): `NoSandbox` class for non-sandboxable resources (API endpoints, etc.). Implements full Sandbox protocol: `create()` logs warning about immediate changes, `get_path()` returns original path, `commit()` is no-op success, `rollback()` always raises, `cleanup()` idempotent. Path traversal guard included. - - `factory.py` (B3.6): `SandboxFactory` with `create_sandbox()` method mapping strategy strings to implementations. Currently only `"none"` -> `NoSandbox` is fully implemented; `git_worktree`, `copy_on_write` raise `NotImplementedError` (awaiting Hamza's B3.3/B3.4). Includes `is_supported()` and `get_supported_strategies()` validation helpers with resource type compatibility map. - - `manager.py` (B3.7): `SandboxManager` with thread-safe (RLock) tracking of active sandboxes per plan. Lazy creation via `get_or_create_sandbox()`, batch operations (`commit_all`, `rollback_all`, `cleanup_all`), abandoned sandbox cleanup, atexit handler for graceful process exit. - - `merge.py` (B3.8): Three merge strategies: `GitMergeStrategy` (shells out to `git merge-file`, falls back to sequential), `SequentialMergeStrategy` (theirs-wins), `JsonMergeStrategy` (recursive deep-merge with configurable array handling). All implement `MergeStrategy` protocol. - - `__init__.py`: Exports all public types. -- Design decisions: - - Factory accepts raw `resource_id`/`original_path`/`sandbox_strategy` strings rather than Resource objects, since Resource model (B1) is not yet implemented by Hamza. This decouples the sandbox layer from the domain model and will be easy to wrap once B1 is complete. - - `SandboxStatus.assert_transition()` provides a convenient guard that raises `SandboxStateError` on invalid transitions -- used throughout NoSandbox and will be used by GitWorktreeSandbox/FilesystemSandbox. - - `NoSandbox.rollback()` always raises `SandboxRollbackError` rather than being a no-op, because silently swallowing rollback requests for unsandboxed resources would hide bugs. -- All 6 files pass pyright with 0 errors (39 pre-existing errors in models.py remain). -- Smoke tests pass: NoSandbox lifecycle, status transitions, factory creation, manager get_or_create, merge strategies. -- Remaining Luis sandbox-adjacent tasks: None. Hamza's B3.3 (GitWorktreeSandbox) and B3.4 (FilesystemSandbox) are the remaining sandbox implementations. - -**2026-02-09**: Stage A2.1 Already Complete -- `estimation_actor` field already present at `src/cleveragents/domain/models/core/action.py:219` -- `review_actor` field already present at `src/cleveragents/domain/models/core/action.py:211` -- Also has `apply_actor` at line 215 (bonus field from earlier work) -- safety_profile remains DEFERRED to post-30 per plan - -**2026-02-09**: Stage SEC1 Complete - Remove eval() Vulnerability (Luis tasks SEC1.1-SEC1.3) -- **SEC1.1 Audit results** (7 matches in `src/cleveragents/`): - - `reactive/stream_router.py:113` - `exec(code, {}, local_vars)` -- **CRITICAL: arbitrary code execution from config** - - `reactive/stream_router.py:340` - `eval(fn_str, {"__builtins__": {}})` -- **CRITICAL: eval of config transform strings** - - `reactive/config_parser.py:64` - `re.compile(...)` -- **SAFE: regex compilation, not Python compile()** - - `agents/graphs/plan_generation.py:192` - `graph.compile(...)` -- **SAFE: LangGraph compile, not builtin** - - `agents/graphs/context_analysis.py:135` - `graph.compile(...)` -- **SAFE: LangGraph compile** - - `agents/graphs/auto_debug.py:74` - `graph.compile(...)` -- **SAFE: LangGraph compile** - - Result: 2 real vulnerabilities, 4 false positives -- **SEC1.2 Fixes applied** to `src/cleveragents/reactive/stream_router.py` (full removal per NO BACKWARDS COMPATIBILITY rule): - - `SimpleToolAgent`: Added named operation registry (`_SAFE_OPERATIONS`) with `register_operation()` classmethod. New `operation` param selects from: identity, uppercase, lowercase, strip, extract_content, to_string. **Legacy `code` blocks are fully rejected** -- attempting to use a `code` block raises `StreamRoutingError`. No `exec()` call remains. - - `ReactiveStreamRouter`: Added named transform registry (`_TRANSFORM_REGISTRY`) with `register_transform()` classmethod. Registry includes: identity, uppercase, lowercase, strip, to_string, extract_content. **Legacy `fn` string expressions that are not in the registry are fully rejected** -- attempting to use an unregistered `fn` string raises `StreamRoutingError`. No `eval()` call remains. -- **SEC1.3**: `config_parser.py` has NO eval/exec/compile vulnerability. The `re.compile()` at line 64 is standard regex compilation. **No changes needed.** -- **Impact on tests**: BDD tests that previously exercised legacy exec/eval code paths have been updated to verify rejection. Tests in `stream_router_agent_tool_coverage.feature`, `stream_router_new_branches.feature`, and `stream_router_uncovered_paths.feature` now assert `StreamRoutingError` for code blocks and unregistered transforms. - -**2026-02-10**: Stage SEC1.5 Complete - Security BDD tests (Luis, acting as Rui per plan) -- Created `features/security_eval.feature` with 8 scenarios: - - Config with code injection attempt is rejected - - Malicious transform expression does not execute - - Valid config still works after eval removal (named operation) - - Named transform from registry works after eval removal - - Code block with import attempt is rejected - - Eval expression mimicking registry name is still rejected - - Custom registered operation works - - Custom registered transform works -- Created `features/steps/security_eval_steps.py` with step definitions - -**2026-02-19**: Stage C5.model COMMIT Complete - ChangeSet models and invocation tracker (Luis) -- Added `ToolInvocation` Pydantic model to `src/cleveragents/domain/models/core/change.py`: ULID id, plan_id, tool_name, skill_name, arguments, result, error, success, duration_ms, started_at, completed_at, change_ids, sequence_number, sandbox_path, resource_refs, provider_metadata. -- Added `InvocationTracker` Protocol and `InMemoryInvocationTracker` implementation with track(), get_invocations(), get_invocations_for_skill(), get_changes() -- all ordered by sequence_number. -- Added `ChangeType` alias for `ChangeOperation` enum. -- Added per-change field validators on `ChangeEntry`: CREATE rejects before_hash, DELETE rejects after_hash. -- Added `has_integrity_hashes` property for checking hash completeness per operation type. -- Added `sorted_entries()` (resource_id, path, timestamp) and `grouped_by_resource()` to `SpecChangeSet`. -- Added `add_change()` method to `SpecChangeSet`. -- Added `normalize_change_path()` utility for repo-relative POSIX paths. -- Updated `src/cleveragents/domain/models/core/__init__.py` exports. -- Created `features/change_tracking.feature` with 21 BDD scenarios. -- Created `robot/change_tracking.robot` with 5 integration smoke tests. -- Created `benchmarks/change_tracking_bench.py` with 4 ASV benchmark suites. -- Created `docs/reference/change_tracking.md`. -- All nox sessions pass: lint, typecheck, unit_tests (192 features / 3677 scenarios), integration_tests (339 tests), coverage_report (97.7%). - -**2026-02-19**: Stage C4.git COMMIT Complete - Add git operation skills (Luis) -- Created `src/cleveragents/tool/builtins/git_tools.py`: 4 read-only git tools (status, diff, log, blame) with ToolSpec definitions, safe environment variables (GIT_PAGER=cat, NO_COLOR=1, GIT_TERMINAL_PROMPT=0), path traversal guards, and user-friendly error mapping for 5 common git failure patterns. -- Updated `src/cleveragents/tool/builtins/__init__.py` to export `register_git_tools()`, all git ToolSpec constants, and `validate_repo_path`. -- Created `features/git_tools.feature` with 16 BDD scenarios: status (3), diff (4), log (3), blame (3), path traversal prevention (1), registration (2). -- Created `features/steps/git_tools_steps.py` with step definitions for all 16 scenarios. -- Created `robot/tool_git_builtins.robot` with 5 integration smoke tests. -- Created `robot/helper_tool_git_builtins.py` helper script for Robot tests. -- Created `benchmarks/git_tool_bench.py` with 3 ASV benchmark suites (GitToolSuite, GitRegistrationSuite, PathValidationSuite). -- Created `docs/reference/skills_git.md` with tool table, safety settings, path guards, error mapping, usage examples, and security rationale. -- All nox sessions pass: lint, typecheck, unit_tests (194 features / 3728 scenarios), integration_tests (355 tests), coverage_report (97.1%). - -**2026-02-19**: Combined merge branch fix - Alembic merge migration (Luis) -- Created `alembic/versions/m3_001_merge_session_and_skill.py` to merge the `a7_001_session_tables` and `c0_001_skill_registry` migration heads into a single head `m3_001_merge_session_skill`, resolving "Multiple head revisions" error. -- All nox sessions pass on combined branch: lint, typecheck, unit_tests (193 features / 3712 scenarios), integration_tests (350 tests), coverage_report (97.2%). - -**2026-02-19**: Stage SEC1.eval COMMIT Complete - Remove eval-based config parsing (Luis) -- Created `src/cleveragents/config/security_scanner.py`: Config security scanner that detects 15 disallowed patterns (eval, exec, __import__, os.system, subprocess.*, compile, os.popen, importlib.import_module, pickle.loads, template directives) across YAML/TOML/generic config files. Reports file path + line number + severity (CRITICAL/HIGH/MEDIUM) for each violation. -- Added `validate_config_safety()` gate that raises `ConfigurationError` when dangerous patterns are found. -- Updated `src/cleveragents/config/__init__.py` to export scanner public API (Severity, Violation, scan_content, scan_file, scan_files, validate_config_safety). -- Extended `features/security_eval.feature` from 8 to 16 scenarios: added 8 new scanner scenarios (detect eval/exec/import/os.system/subprocess, clean config, line numbers, validation gate, comment skipping, multiple violations). -- Created `robot/security_eval.robot` with 10 integration smoke tests for the config scanner (detect-eval, detect-exec, detect-import, detect-os-system, detect-subprocess, clean-config, line-numbers, validate-raises, skip-comments, detect-template). -- Created `robot/helper_security_eval_scanner.py` helper for Robot tests. -- Created `benchmarks/security_eval_bench.py` with 3 ASV benchmark suites (TimeScanContent, TimeValidateConfigSafety, TimeScanFile). -- Created `docs/reference/security_eval.md` with replacement patterns, scanned patterns table, usage examples, and security rationale. -- All nox sessions pass: lint, format, typecheck, security_scan, dead_code, unit_tests (191 features / 3664 scenarios), integration_tests (344 tests), docs, build, benchmark, coverage_report (97.5%). -**2026-02-09**: Stage A5.6 Complete - ActionRepository (Luis tasks A5.6a-A5.6j) -- Created `ActionRepository` class in `src/cleveragents/infrastructure/database/repositories.py` -- Uses session-factory pattern: `__init__(self, session_factory: Callable[[], Session])` -- each method obtains its own session from the factory -- Custom exceptions: `DuplicateActionError` (extends `DatabaseError`), `ActionInUseError` (extends `BusinessRuleViolation`) -- 10 methods implemented: - - `__init__` + `_session()` helper - - `create()`: Persists new Action via `LifecycleActionModel.from_domain()`, catches IntegrityError -> DuplicateActionError - - `get_by_id()`: Query by primary key, returns domain via `to_domain()` or None - - `get_by_name()`: Query by full namespaced name string, returns domain or None - - `get_by_namespace()`: Filter by namespace + optional state, order by short_name ASC - - `get_by_state()`: Filter by state, order by updated_at DESC - - `update()`: Fetch row, overwrite all mutable columns, auto-set updated_at - - `list_available()`: Filter state='available' + optional namespace, order by namespace+short_name - - `delete()`: Check referential integrity against LifecyclePlanModel, raise ActionInUseError if plans exist, else delete -- All public methods decorated with `@database_retry` per ADR-033 -- All mutating methods flush (do NOT commit) -- caller/UnitOfWork handles commit -- Uses `Any` type hints for domain Action objects to avoid circular import issues (LifecycleActionModel.to_domain() handles the actual conversion) -- Updated `infrastructure/database/__init__.py` to export ActionRepository, DuplicateActionError, ActionInUseError -- 0 new pyright errors (3 pre-existing sqlalchemy import resolution errors remain) - -**2026-02-09**: Stage E1 Complete - Subplan Model (Luis tasks E1.1-E1.5) -- All models added to `src/cleveragents/domain/models/core/plan.py` -- **E1.1a**: `ExecutionMode` enum (SEQUENTIAL, PARALLEL, DEPENDENCY_ORDERED) -- **E1.1b**: `SubplanMergeStrategy` enum (GIT_THREE_WAY, SEQUENTIAL_APPLY, FAIL_ON_CONFLICT, LAST_WINS) - - Renamed from `MergeStrategy` in spec to `SubplanMergeStrategy` to avoid collision with the infrastructure-level `MergeStrategy` protocol in `infrastructure.sandbox.merge` -- **E1.2a**: `SubplanConfig` Pydantic model with: execution_mode, merge_strategy, max_parallel (1-50, default 5), fail_fast, timeout_per_subplan_seconds, retry_failed, max_retries (0-5, default 2) -- **E1.3a**: Verified `parent_plan_id` and `root_plan_id` already exist in `PlanIdentity` (from A1) -- **E1.3b**: Added `subplan_config: SubplanConfig | None` and `subplan_statuses: list[SubplanStatus]` fields to `Plan` -- **E1.3c**: Added computed properties: `is_subplan` (has parent), `is_root_plan` (no parent or root==self), `depth` (0 for root, -1 placeholder for non-root), `has_subplans` (has statuses) -- **E1.4a**: `SubplanStatus` Pydantic model with: subplan_id, action_name, target_resources, status, timing, results (error, changeset_summary, files_changed), retries (attempt_number, previous_attempts) -- **E1.4b**: `SubplanAttempt` Pydantic model (used Pydantic BaseModel instead of dataclass for consistency) -- **E1.5a**: `SubplanFailureHandler` class with `should_stop_others()` and `should_retry()` methods -- **E1.5b**: `RETRIABLE_FAILURES` and `NON_RETRIABLE_ERRORS` as frozenset constants -- Used Pydantic BaseModel instead of dataclass (per ADR-004) for SubplanAttempt and SubplanStatus -- Added `from __future__ import annotations` to plan.py to support forward references -- 0 pyright errors on plan.py; all smoke tests pass -- E1.6 (Behave tests) is assigned to Rui, skipped - -**2026-02-09**: Stage A6 Complete - Automation Levels Foundation (Luis tasks) -- **A6.1**: Added `AutomationLevel` enum to `src/cleveragents/domain/models/core/plan.py:57`: - - `MANUAL` (default) - user triggers each phase transition - - `REVIEW_BEFORE_APPLY` - auto strategize+execute, pause before apply - - `FULL_AUTOMATION` - all phases run without human input - - Added `automation_level` field to `Plan` model (default MANUAL) -- **A6.2**: Added `default_automation_level` setting to `src/cleveragents/config/settings.py`: - - String field with default `"manual"`, env var `CLEVERAGENTS_AUTOMATION_LEVEL` - - Hierarchy: plan-level (explicit) > global default from settings - - Session-level override deferred (requires session CLI module that doesn't exist yet) -- **A6.3**: Updated `PlanLifecycleService` in `src/cleveragents/application/services/plan_lifecycle_service.py`: - - `automation_level` parameter on `use_action()` (explicit > global default) - - `_resolve_automation_level()` reads from settings, falls back to MANUAL - - `should_auto_progress(plan)` - pure query, checks if plan should auto-advance - - `auto_progress(plan_id)` - idempotent, advances to next phase if automation permits - - `complete_strategize()` and `complete_execute()` now call `auto_progress()` automatically - - `pause_plan(plan_id)` - sets automation to MANUAL to halt auto-progression - - `resume_plan(plan_id, level)` - restores automation level and triggers immediate auto-progress if ready - - `set_plan_automation_level(plan_id, level)` - change level for existing non-terminal plan -- **A6.4**: Updated CLI commands in `src/cleveragents/cli/commands/plan.py`: - - `--automation-level` option on `agents plan use` command (parses and validates) - - `agents plan set-automation-level ` command (calls `set_plan_automation_level`) - - `config set automation-level` and `session set automation-level` DEFERRED: require new CLI modules (`config.py`, `session.py`) that don't exist yet -- All modified files pass pyright with 0 new errors (only pre-existing structlog import resolution) - -**2026-02-10**: Stage A6.5 Complete - Automation Levels BDD Tests (Luis, taking over from Rui) -- Created `features/automation_levels.feature` with 24 Behave scenarios covering: - - Manual mode: verifies no auto-progression after complete_strategize or complete_execute - - Review-before-apply mode: auto-executes after strategize, pauses before apply - - Full automation mode: auto-executes and auto-applies - - Plan-level override: explicit automation_level on use_action overrides global default - - Mid-plan level changes: set_plan_automation_level works on non-terminal plans, rejected on terminal - - should_auto_progress query: verified for all 3 levels in strategize/complete and execute/complete states, plus terminal plans - - Pause/resume: pause_plan sets level to MANUAL, resume_plan restores level and triggers auto-progress when ready, defaults to REVIEW_BEFORE_APPLY when no level specified - - Settings resolution: _resolve_automation_level reads from settings, falls back to MANUAL for invalid values -- Created `features/steps/automation_levels_steps.py` with step definitions -- Discovery: pydantic-settings `BaseSettings` does not accept constructor keyword overrides for fields with `validation_alias`; must set attribute after construction. This affects test helpers that need to override `default_automation_level`. -- All 24 new scenarios pass; all 51 existing `plan_lifecycle_service.feature` scenarios continue to pass (no regressions) - -**2026-02-13**: Stage C0.domain Complete - Tool and Validation Domain Models [Jeff] -- Created `src/cleveragents/domain/models/core/tool.py` (624 lines) with: - - 6 StrEnums: `ToolSource` (mcp/agent_skill/builtin/custom/wrapped), `ToolType` (tool/validation), `ValidationMode` (required/informational), `ResourceAccessMode` (read_only/read_write), `BindingMode` (contextual/static/parameter), `CheckpointScope` (file/transaction/snapshot/composite) - - 5 Pydantic models: `ResourceSlot`, `ToolCapability`, `ToolLifecycle`, `Tool`, `Validation` - - Full validators: name pattern `^[a-zA-Z0-9_-]+/[a-zA-Z0-9_-]+$`, source-conditional field requirements, read_only constraint enforcement, static binding requires static_resource, wraps/transform exclusivity - - Factory methods: `Tool.from_config()` and `Validation.from_config()` for YAML loading, `as_cli_dict()` for CLI rendering - - Properties: `namespace`, `short_name` derived from `name` field -- Updated `src/cleveragents/domain/models/core/__init__.py` to export all 11 new types -- Created YAML schema docs: `docs/schema/tool.schema.yaml`, `docs/schema/validation.schema.yaml` -- Created example configs: `examples/tools/custom-tool.yaml`, `examples/tools/mcp-tool.yaml`, `examples/validations/required-validation.yaml`, `examples/validations/wrapped-validation.yaml` -- Created reference docs: `docs/reference/tool_model.md`, `docs/reference/validation_model.md` -- Created 60 Behave scenarios in `features/tool_model.feature` with `features/steps/tool_model_steps.py` -- Created 3 ASV benchmark suites in `benchmarks/tool_model_bench.py` -- Key decision: YAML loader implemented as `from_config()` class methods on Tool/Validation models (matches action.py pattern) rather than separate `src/cleveragents/tool/schema.py` module -- Key decision: `Validation` extends `Tool` via Pydantic model inheritance with `@model_validator(mode="after")` to force read-only constraints -- Key decision: `wraps` field sets source to `wrapped` implicitly; `transform` required when `wraps` is set -- Verification: lint 0 findings, typecheck 0 errors, 2293 unit test scenarios passed, 208 integration tests passed, 97% coverage (tool.py 99%) - -**2026-02-13**: Stage C0.skill.domain Complete - Skill Domain Model and Resolver [Jeff] -- Created `src/cleveragents/domain/models/core/skill.py` (475 lines) with: - - 9 Pydantic models: `SkillToolRef`, `SkillInclude`, `SkillInlineTool`, `SkillMcpSource`, `SkillAgentSource`, `SkillCapabilitySummary`, `Skill`, `ResolvedToolEntry`, `SkillResolver` - - `SkillResolver.resolve()` flattens includes into ordered tool lists, de-duplicates tools, and rejects cycles with path traces - - Namespaced naming rules: `^[a-zA-Z0-9_-]+/[a-zA-Z0-9_-]+$` pattern enforced - - MCP source and agent source support for external skill backends - - Capability summary computed from resolved tool entries -- Updated `src/cleveragents/domain/models/core/__init__.py` with 10 new exports -- Created `features/skill_resolution.feature` (42 scenarios) with `features/steps/skill_resolution_steps.py` -- Created `docs/reference/skill_model.md` and `docs/reference/skill_resolution.md` -- Created `benchmarks/skill_resolution_bench.py` for resolver performance -- Key decision: `SkillResolver` is a standalone class (not a method on Skill) to support registry-backed resolution in the future -- Key decision: `ResolvedToolEntry` includes source tracking (which skill contributed each tool) for compiler diagnostics -- Verification: lint 0 findings, typecheck 0 errors, 2335 unit test scenarios passed, 97% coverage (skill.py 98%) -- Branch: `feature/m3-skill-domain` (based on `feature/m3-tool-domain`); PR pending - -**2026-02-13**: Stage B1.core.db Complete - Resource Registry Database Tables [Jeff] -- Created Alembic migration `b1_001_resource_registry` (revises `a5_004_spec_aligned_plans`) with 3 tables: - - `resource_types`: Schema-level definitions constraining resource categories (PK: `name` namespaced string, CHECK on `resource_kind`, JSON fields for args/parents/children/discovery/capabilities/equivalence) - - `resources`: Registered resource instances with ULID PK, optional namespaced name (unique when non-null), FK to `resource_types` with RESTRICT delete, CHECK on `resource_kind`, content_hash for virtual equivalence - - `resource_edges`: DAG parent-child edges with composite PK, CASCADE delete, CHECK on self-loop prevention, CHECK on `link_type` enum -- Added 3 ORM models to `src/cleveragents/infrastructure/database/models.py`: - - `ResourceTypeModel` with relationships to `ResourceModel` - - `ResourceModel` with `parent_edges`/`child_edges` relationships to `ResourceEdgeModel` - - `ResourceEdgeModel` with `parent`/`child` relationships to `ResourceModel` -- All models use `__allow_unmapped__ = True` for `from __future__ import annotations` compatibility -- CHECK constraints added both in migration SQL and ORM model `__table_args__` for consistency -- FK enforcement enabled via SQLite `PRAGMA foreign_keys = ON` event listener in tests -- Updated `src/cleveragents/infrastructure/database/__init__.py` to export all 3 new models -- Updated `docs/reference/database_schema.md` with full table definitions, constraints, and updated ER diagram -- Created 31 Behave scenarios in `features/resource_registry_tables.feature` covering: table existence, CRUD for all 3 models, JSON field round-trips, FK/uniqueness/CHECK constraint enforcement, CASCADE/RESTRICT delete behavior, ORM relationship navigation, multiple parents/children DAG patterns, timestamp validation -- Created ASV benchmarks in `benchmarks/resource_registry_migration_bench.py` (4 classes: schema creation, type insert, resource insert, DAG edge queries) -- Key design decision: `resource_types` PK is the namespaced name string (not ULID) since types are schema-level definitions with stable identifiers per spec -- Key design decision: `link_type` enum ('contains', 'references', 'derived_from') covers hierarchical containment, cross-layer references, and derived virtual resources -- Key design decision: `auto_discovered` flag on both resources and edges tracks provenance for cleanup/refresh operations -- Verification: lint 0 findings, typecheck 0 errors, 2264 unit test scenarios passed, models.py 94% coverage with combined test suites -- Branch: `feature/m2-resource-core-db` (based on `master`); PR pending - -**2026-02-13**: Stage A7.domain Complete - Session Domain Models and Contracts [Jeff] -- Created `src/cleveragents/domain/models/core/session.py` with: - - `MessageRole` enum (user/assistant/system/tool) - - `SessionMessage` model with role, content, sequence_number, timestamps, metadata - - `SessionTokenUsage` model for tracking prompt/completion/total tokens - - `Session` model with ULID ID, actor ref, title, messages, token usage, timestamps - - Error classes: `SessionNotFoundError`, `SessionMessageError`, `SessionExportError` - - `SessionService` ABC defining create/list/show/delete/append/export/import contracts -- Updated `src/cleveragents/domain/models/core/__init__.py` with 10 new exports -- Created `features/session_model.feature` (39 scenarios) with `features/steps/session_model_steps.py` -- Created `docs/reference/session_model.md` and `docs/reference/session_service.md` -- Created `benchmarks/session_model_bench.py` for validation throughput -- Key decision: SessionService is an ABC (not Protocol) to enforce explicit inheritance and make contract violations visible at class definition time -- Key decision: Messages are ordered by sequence_number (not timestamp) to guarantee stable ordering across serialization boundaries -- Verification: lint 0 findings, typecheck 0 errors, 39 new scenarios pass, 97% coverage (session.py 98%) -- Branch: `feature/m3-session-domain` (based on `feature/m3-tool-domain`); PR pending - -**2026-02-13**: Stage A2b.gamma Complete (Aditya) - Action YAML Schema + Examples + Loader -- Created `docs/schema/action.schema.yaml` — formal schema definition for action YAML config files, covering all fields (name, description, strategy_actor, execution_actor, definition_of_done, arguments, invariants, automation_profile, inputs_schema, optional actors, behaviour flags, state), versioning, namespaced name patterns, key normalization mapping. -- Created 5 example action YAML configs under `examples/actions/`: simple.yaml, invariant-heavy.yaml, read-only.yaml, estimation-actor.yaml, inputs-schema.yaml. -- Created `src/cleveragents/action/schema.py` with `ActionConfigSchema` Pydantic model: - - `from_yaml(yaml_string)` and `from_yaml_file(path)` factory methods - - camelCase→snake_case key normalization with deprecation warnings - - `${ENV_VAR}` environment variable interpolation - - Invariant normalization: trim whitespace, drop blanks, de-duplicate preserving order - - Clear, actionable error messages for every validation failure mode - - Nested `ActionArgumentSchema` for typed arguments with validation - - `extra="forbid"` prevents unknown keys -- Behave tests: `features/action_schema.feature` — 31 scenarios / 140 steps covering valid schemas, missing fields, invalid names, invalid types, invariant normalization, key normalization, env var interpolation, serialization, edge cases (None/empty/list/directory inputs). -- Robot smoke tests: `robot/action_schema.robot` — 6 test cases validating all example YAMLs + invalid rejection. -- ASV benchmarks: `benchmarks/action_schema_bench.py` — 3 suites (validation, file-load, serialization). -- Coverage: 98% overall (action/schema.py: 98%, action/__init__.py: 100%). -- All nox sessions pass: lint, typecheck, unit_tests, integration_tests, benchmark, security_scan, coverage_report. - -**2026-02-14**: Stage A4b.action Complete - Action CLI Spec Alignment [Jeff] -- Rewrote `src/cleveragents/cli/commands/action.py`: config-only `action create --config `, removed `action available` command, added `--namespace`/`--state`/REGEX filters to `action list`, enhanced output with `Short Name`/`Definition of Done` summary. -- Updated 3 existing feature files (action_cli.feature, action_cli_uncovered_lines.feature, action_cli_edge_cases_coverage.feature) to use config-only create flow and remove `available` command references. -- Created `features/action_cli_spec_alignment.feature` (19 scenarios), Robot smoke test, ASV benchmarks. -- Verification: lint 0 findings, typecheck 0 errors, 2587 scenarios passed, 97% coverage. action.py 100% coverage. -- Branch: `feature/m1-action-cli` - -**2026-02-14**: Stage A4b.plan Complete - Plan CLI Flag Alignment [Jeff] -- Updated `src/cleveragents/cli/commands/plan.py`: `plan use` now accepts multiple PROJECT args, `--automation-profile`, `--invariant` (repeatable), `--strategy-actor`/`--execution-actor`/`--estimation-actor`/`--invariant-actor`, `--arg name=value`. Aligned `plan list` filters to spec. Enhanced `plan status` output. Added `--reason` to `plan cancel`. -- Created `features/plan_cli_spec_alignment.feature` with scenarios, Robot smoke test, ASV benchmarks. -- Verification: lint 0 findings, typecheck 0 errors, 2606 scenarios passed, 97% coverage. -- Branch: `feature/m1-plan-cli` (based on `feature/m1-action-cli`) - -**2026-02-14**: Stage A4b.outputs Complete - CLI Output Format Stabilization [Jeff] -- Created `src/cleveragents/cli/formatting.py`: shared `format_output()` helper with `OutputFormat` enum, JSON/YAML/plain/table/rich serializers. Handles datetime, Enum, nested structures. -- Updated action.py and plan.py with `--format` options and normalized output keys to spec field names. -- Created `features/cli_output_formats.feature` (15 scenarios), Robot smoke test, ASV benchmarks. -- Verification: lint 0 findings, typecheck 0 errors, 97% coverage. formatting.py 97%, action.py 100%. -- Branch: `feature/m1-cli-formats` (based on `feature/m1-plan-cli`) - -**2026-02-14**: Stage C0.runtime Complete - Tool Runtime Core [Jeff] -- Created `src/cleveragents/tool/runtime.py` (ToolSpec, ToolResult, ToolError), `registry.py` (thread-safe ToolRegistry with RLock), `runner.py` (ToolRunner with 4-stage lifecycle: discover/activate/execute/deactivate). -- Created `features/tool_runtime.feature` (26 scenarios), Robot smoke test (3 tests), ASV benchmarks. -- New tool modules have 100% coverage (105 statements, 14 branches, 0 misses). -- Verification: lint 0, typecheck 0, 2604 scenarios passed, 97% total coverage. -- Branch: `feature/m1-tool-runtime-core` - -**2026-02-14**: Stage C0.files Complete - Built-in File Tools [Jeff] -- Created `src/cleveragents/tool/builtins/` package with 6 file tools (file-read/write/edit/delete/list/search), path traversal prevention, ChangeSetEntry/ChangeSet/ChangeSetCapture models, and tool registration helpers. -- Created `features/tool_builtins.feature` (32 scenarios), Robot smoke test (7 tests), ASV benchmarks. -- Verification: lint 0, typecheck 0, 2630 scenarios passed, 97% total coverage. Tool builtins 97-100% coverage. -- Branch: `feature/m1-tool-builtins` (based on `feature/m1-tool-runtime-core`) -- 2026-02-14: Commit traceability sweep found no matching git log entries for skill schema/examples, skill CLI, provider actors, MCP config/adapter, actor compiler, or skill registry persistence; Section 2B traceability tasks remain open. - - -**2026-02-14**: Stage C1.tool.registry Complete - Tool Registry Persistence [Luis] -- Created Alembic migration `c1_001_tool_registry` (depends on `b1_001_resource_registry`) with 3 tables: - - `tools`: 22 columns, PK `name` (namespaced string e.g. `local/lint-check`), self-referential FK `wraps` -> `tools.name` (SET NULL), CHECK constraints on `tool_type` (tool/validation) and `source` (mcp/agent_skill/builtin/custom/wrapped), indexes on namespace/tool_type/source. Includes columns for inline code, MCP server/tool name, agent skill path, timeout (default 300), input/output schema JSON, capability/lifecycle JSON, transform, mode, and argument_mapping JSON. - - `tool_resource_bindings`: 10 columns, auto-increment PK, FK `tool_name` -> `tools.name` (CASCADE), columns for slot_name, resource_type, access_mode, binding_mode, static_resource, required (default true), description. Index on tool_name. - - `validation_attachments`: 8 columns, ULID PK `attachment_id`, FK `validation_name` -> `tools.name` (CASCADE), columns for resource_id, mode (required/informational CHECK), project_name, plan_id, args_json. Indexes on validation_name, resource_id, project_name. -- Added 3 ORM models to `src/cleveragents/infrastructure/database/models.py`: - - `ToolModel` (22 cols): `to_domain()` returns dict, `from_domain()` accepts dict/object with auto-namespace extraction. Relationships to `ToolResourceBindingModel` (cascade="all, delete-orphan") and `ValidationAttachmentModel`. - - `ToolResourceBindingModel` (10 cols): Nested child of ToolModel. - - `ValidationAttachmentModel` (8 cols): Nested child of ToolModel with mode CHECK constraint. -- Created 2 repository classes in `src/cleveragents/infrastructure/database/repositories.py`: - - `ToolRegistryRepository` (5 methods: create/get_by_name/list_all/update/delete): Session-factory pattern, `@database_retry` on all methods, duplicate name detection via `DuplicateToolError`, referential integrity check on delete via `ToolInUseError` (counts active validation attachments before allowing deletion). Update method replaces all child resource bindings. - - `ValidationAttachmentRepository` (4 methods: attach/detach/list_for_resource/get_by_id): ULID generation for attachment IDs, JSON serialization of args, filtering by resource_id/project_name/plan_id. -- Created `src/cleveragents/application/services/tool_registry_service.py` (192 lines): - - `ToolRegistryService` with 8 methods (5 tool CRUD + 3 validation attachment): pure dependency injection pattern, existence check on `attach_validation()` raises `NotFoundError` if validation tool not found. -- Updated `src/cleveragents/infrastructure/database/__init__.py` with 7 new exports (3 models, 2 repos, 2 errors). -- Updated `src/cleveragents/application/services/__init__.py` to export `ToolRegistryService`. -- Updated `docs/reference/database_schema.md` with 3 new table sections, updated ER diagram (tools -> bindings/attachments + self-referential wraps), updated migration chain and source locations. -- Created `features/tool_registry.feature` (27 scenarios across 7 groups: create/read/list/update/delete/attachments/service) with `features/steps/tool_registry_steps.py` (598 lines). -- Created `robot/tool_registry.robot` (4 integration tests: register-and-get, list-filter, attach-detach, duplicate-reject) with `robot/helper_tool_registry.py` (123 lines). -- Created `benchmarks/tool_registry_bench.py` (3 ASV suites, 7 benchmarks: ORM construction, CRUD operations, attachment operations). -- Key decision: `ToolModel.to_domain()` returns a dict (not a domain object) to decouple the persistence layer from the domain model until the full tool domain model integration is complete. -- Key decision: `ToolRegistryRepository.delete()` pre-checks for active `ValidationAttachmentModel` rows and raises `ToolInUseError` with count before allowing deletion, ensuring referential integrity at the application level. -- Key decision: Validation attachments are resource-scoped with optional project_name and plan_id narrowing, supporting both project-wide and plan-specific validation bindings per spec. -- Verification: lint 0 findings, typecheck 0 errors, 27 new Behave scenarios pass, 4 Robot integration tests pass. -- Branch: `feature/m3-tool-registry` - -**2026-02-15**: Stage A7.persistence Complete - Session Persistence and Repositories [Luis] -- Created Alembic migration `a7_001_session_persistence` (depends on `b1_001_resource_registry`) with 2 tables: - - `sessions`: 9 columns, ULID PK `session_id` (String(26)), columns for `actor_name` (nullable), `namespace` (default `'local'`), `automation_level` (nullable), `linked_plan_ids_json`, `token_usage_json`, `metadata_json` (all Text, nullable), `created_at`, `updated_at` (ISO-8601 strings). Indexes on `created_at` and `actor_name`. - - `session_messages`: 8 columns, ULID PK `message_id` (String(26)), FK `session_id` -> `sessions.session_id` (CASCADE, named `fk_session_messages_session`), columns for `role` (user/assistant/system/tool), `content` (Text), `sequence` (Integer for ordering), `timestamp` (ISO-8601), `metadata_json` (nullable), `tool_call_id` (nullable). Indexes on `session_id` and composite `(session_id, sequence)`. -- Added 2 ORM models to `src/cleveragents/infrastructure/database/models.py`: - - `SessionModel`: 9 columns, `to_domain()` constructs `Session` domain object with parsed `SessionTokenUsage` and child messages, `from_domain()` serializes token usage/plan IDs/metadata to JSON and creates child `SessionMessageModel` instances. Relationship `messages_rel` -> `SessionMessageModel` with `cascade="all, delete-orphan"`, ordered by sequence. - - `SessionMessageModel`: 8 columns, `to_domain()` returns `SessionMessage` domain object with `MessageRole` enum and parsed datetime/metadata, `from_domain()` serializes role/timestamp/metadata. Back-populates to `SessionModel`. -- Created 2 repository classes in `src/cleveragents/infrastructure/database/repositories.py`: - - `SessionRepository` (5 methods: `create`/`get_by_id`/`list_all`/`delete`/`update`): Session-factory pattern, `@database_retry` on all methods. `create()` catches `IntegrityError`. `update()` serializes `token_usage` as JSON dict with `input_tokens`/`output_tokens`/`estimated_cost`. `list_all()` accepts optional `actor_name` filter, ordered by `created_at`. `delete()` returns bool. Raises `DatabaseError` if session not found on update. - - `SessionMessageRepository` (3 methods: `append`/`get_for_session`/`count_for_session`): `append()` sets `session_id` on model, flushes. `get_for_session()` supports pagination via `limit`/`offset`, ordered by `sequence`. `count_for_session()` returns integer count. -- Created `src/cleveragents/application/services/session_service.py` (295 lines): - - `PersistentSessionService` extends domain `SessionService` ABC with 8 concrete methods: `create` (ULID generation), `get` (raises `SessionNotFoundError`), `list`, `delete` (raises `SessionNotFoundError`), `append_message` (auto-sequences via `count_for_session`, updates session `updated_at`), `export_session` (delegates to `Session.as_export_dict()`), `import_session` (validates schema version + SHA-256 checksum, generates new ULIDs for session and all messages), `update_token_usage` (cumulative additive tracking). - - Pure dependency injection: constructor takes `SessionRepository` + `SessionMessageRepository`. -- Updated `src/cleveragents/infrastructure/database/__init__.py` with 4 new exports (`SessionModel`, `SessionMessageModel`, `SessionRepository`, `SessionMessageRepository`). -- Updated `src/cleveragents/application/services/__init__.py` to export `PersistentSessionService`. -- Updated `docs/reference/database_schema.md` with 2 new table sections (`sessions`, `session_messages`), updated ER diagram with session -> session_messages (1:N, CASCADE), updated migration chain and source locations. -- Created `features/session_persistence.feature` (24 scenarios across 8 groups: creation/listing/deletion/message-append/pagination/export-import/token-usage/ORM-round-trip) with `features/steps/session_persistence_steps.py` (431 lines). -- Created `robot/session_persistence.robot` (4 integration tests: session round-trip, message append+ordering, export+import, token usage tracking) with `robot/helper_session_persistence.py` (139 lines). -- Created `benchmarks/session_persistence_bench.py` (2 ASV suites, 7 benchmarks: session create/get/list, message append, export, token update, import). -- Key decision: `PersistentSessionService` extends the domain `SessionService` ABC (not Protocol) to enforce explicit inheritance and make contract violations visible at class definition time. -- Key decision: `append_message()` auto-calculates sequence number via `count_for_session()` and updates the parent session's `updated_at` timestamp, maintaining ordering invariants. -- Key decision: `import_session()` validates schema version against `EXPORT_SCHEMA_VERSION` and verifies SHA-256 checksum integrity before persisting, then generates fresh ULIDs for both the session and all messages to avoid ID collisions. -- Key decision: `update_token_usage()` uses cumulative addition (+=) rather than replacement, allowing incremental tracking across multiple LLM calls within a session. -- Verification: lint 0 findings, typecheck 0 errors, 24 new Behave scenarios pass, 4 Robot integration tests pass. -- Branch: `feature/m3-session-persistence` - -**2026-02-15**: Bugfix - Benchmark Unique Name Constraint [Luis] -- Fixed `benchmarks/resource_registry_migration_bench.py`: ASV benchmark suites that create tools/resources now use unique names per iteration (incrementing counter) to avoid UNIQUE constraint failures when ASV runs multiple iterations of the same benchmark method. -- Branch: `feature/m3-tool-registry` (appended commit), `feature/m3-session-persistence` (appended commit) - -**2026-02-16**: C0.skill.schema Complete (Aditya) - Skill YAML Schema + Examples + Loader -- Created `docs/schema/skill.schema.yaml` — formal schema definition for skill YAML config files, covering all fields (name, description, tools, inline_tools, includes, mcp_servers, agent_skill_folders), versioning, namespaced name patterns, key normalization mapping, additionalProperties: false at all levels. -- Created 5 example skill YAML configs under `examples/skills/`: single-tool.yaml, composed.yaml, inline-tool.yaml, validation-only.yaml, mcp-backed.yaml. -- Created `src/cleveragents/skills/schema.py` with `SkillConfigSchema` Pydantic model: - - `from_yaml(yaml_string)` and `from_yaml_file(path)` factory methods - - camelCase→snake_case key normalization with deprecation warnings - - `${ENV_VAR}` environment variable interpolation - - Clear, actionable error messages for every validation failure mode - - Nested models: `SkillToolRefSchema` (tool refs with overrides), `SkillInlineToolSchema` (name/source/code/input_schema/writes/checkpointable/side_effects), `SkillIncludeSchema`, `SkillMcpServerSchema` (name/transport/command/args/env/url/headers/tool_filter), `SkillMcpToolFilterSchema`, `SkillAgentFolderSchema` - - `extra="forbid"` at all nesting levels to reject unknown keys -- Behave: 36 scenarios / 169 steps in `features/skill_schema.feature` + `features/steps/skill_schema_steps.py` -- Robot: 6 test cases in `robot/skill_schema.robot` + `robot/helper_skill_schema.py` -- ASV: 3 benchmark suites in `benchmarks/skill_schema_bench.py` -- Quality: lint 0 findings, typecheck 0 errors, all Behave/Robot tests pass. - - -**2026-02-17**: Bugfix - Unit Test and Benchmark Failures After Master Merge [Brent] - -- **Context**: After merging master into `feature/q0-min-coverage` (commit `7ddd99b`), full `nox` run showed 2 failing sessions: `unit_tests-3.13` (1 scenario failure) and `benchmark` (multiple benchmark failures). All other sessions (lint, format, typecheck, security_scan, dead_code, integration_tests, coverage_report) passed. -- **Unit test failure** — `features/project_repository.feature:38` "List projects respects limit": - - **Root cause**: Session mismatch in `features/steps/project_repository_steps.py`. The `NamespacedProjectRepository` creates a new SQLAlchemy session via `self._session_factory()` on each method call (session-factory pattern). The test setup passed a `sessionmaker` as the factory, so each repo method got a different session. When `context.pr_session.commit()` was called, it committed a separate session that did NOT contain the flushed data from the repo's sessions. With SQLite in-memory, only 1 of 3 projects was visible when querying with `limit=2`. - - **Fix** (`features/steps/project_repository_steps.py:75-91`): Changed the session factory passed to the repos from `sf` (the raw `sessionmaker`) to `lambda: session` (always returns the same session instance as `context.pr_session`). This ensures `context.pr_session.commit()` commits the data flushed by the repos. The raw `sessionmaker` is still available as `context.pr_session_factory` for tests that need independent sessions (e.g., `step_pr_create_dup`). -- **Benchmark failures** — 5 distinct issues across 7 files: - 1. **`cli_format_bench.py`**: `ActionListFormatSuite.setup()` and `PlanStatusFormatSuite.setup()` missing `fmt` parameter. ASV passes the parameterized value to `setup()`/`teardown()` for classes with `params`. Fix: added `fmt: str` parameter to both `setup()` and `teardown()` methods. Added `# noqa: RUF012` for ASV convention `params`/`param_names` class attributes. - 2. **`plan_model_bench.py`**: `PhaseTransitionSuite.time_can_transition_invalid` referenced `PlanPhase.APPLIED` which no longer exists (renamed to `PlanPhase.APPLY` during spec rebaseline). Fix: changed to `PlanPhase.APPLY`. - 3. **`plan_lifecycle_persistence_bench.py`**: `TimePhaseTransitionPersisted.time_execute_transition` failed on second ASV iteration with "Invalid phase transition from execute to execute" because `setup()` transitioned the plan to execute-ready state once, but the timing method was called repeatedly. Fix: moved plan creation + strategize transitions into the timing method itself so each iteration gets a fresh plan. - 4. **UNIQUE constraint failures** in `plan_phase_migration_bench.py`, `project_migration_bench.py`, `resource_registry_migration_bench.py`: Benchmark methods inserted rows with fixed IDs (e.g., `_make_ulid(i)` for i=0..99). ASV calls timing methods multiple times per `setup()`, so the second call hit UNIQUE constraint violations. Fix: added batch counters (`self._batch_ctr`, `self._single_ctr`) to generate unique IDs across iterations (e.g., `_make_ulid(offset + i)` where `offset = self._batch_ctr * 100`). For `ProjectLinkInsert`, expanded the resource pool from 50 to 5000 to accommodate repeated iterations. - 5. **`uow_lifecycle_bench.py`**: `TimeUowActionPlanRoundTrip.time_create_action_and_plan_via_uow` failed with FK constraint on plan insert, even after creating and committing the action in a separate session. Root cause: SQLite in-memory `StaticPool` + `autoflush=False` caused the plan's FK check to not see the committed action across session boundaries. Fix: simplified the benchmark to reuse the pre-seeded action (`local/bench-uow-action`) created in `setup()` rather than creating a new action per iteration. -- **Files changed** (8 files, +87/-45 lines): - - `features/steps/project_repository_steps.py` — session factory fix - - `benchmarks/cli_format_bench.py` — parameterized setup/teardown signatures + noqa - - `benchmarks/plan_model_bench.py` — `APPLIED` → `APPLY` - - `benchmarks/plan_lifecycle_persistence_bench.py` — per-iteration plan creation - - `benchmarks/plan_phase_migration_bench.py` — batch counters for unique IDs - - `benchmarks/project_migration_bench.py` — batch counters for unique IDs - - `benchmarks/resource_registry_migration_bench.py` — batch counters for unique IDs - - `benchmarks/uow_lifecycle_bench.py` — reuse pre-seeded action -- **Verification**: All 9 nox sessions pass: - - lint: success - - format: success - - typecheck: success (7s) - - security_scan: success (6s) - - dead_code: success - - unit_tests-3.13: success (3161 scenarios, 13765 steps, 0 failures) - - integration_tests-3.13: success (283 tests, 0 failures) - - coverage_report: success (97.3%, threshold 97%) - - benchmark: success (all benchmarks pass) -- **Commit**: `122af46` on `feature/q0-min-coverage` — `fix(tests): resolve unit test and benchmark failures` - -**2026-02-17**: Task C1.schema Complete (Aditya) - Actor YAML Schema Models - -- **Implementation**: Created complete actor YAML schema system in `src/cleveragents/actor/schema.py` (695 lines) - - Three actor types with clear separation: LLM (single LLM call + tools), TOOL (tool collections), GRAPH (multi-node workflows) - - Strict name validation enforcing `namespace/name` format (ADR-002 compliance) - - Comprehensive graph topology validation with cycle detection using DFS algorithm - - Type-specific field requirements enforced via Pydantic `model_validator` - - Environment variable interpolation support (`${ENV_VAR}` syntax) - - YAML I/O methods: `from_yaml_file()`, `to_yaml_file()`, `from_yaml()` - - Core models: `ActorType`, `NodeType`, `ContextView` enums; `ToolParameter`, `ToolDefinition`, `MemoryConfig`, `ContextConfigSchema`, `EdgeDefinition`, `NodeDefinition`, `RouteDefinition`, `ActorConfigSchema` Pydantic models - -- **Documentation**: Comprehensive reference docs in `docs/reference/actors_schema.md` (420 lines) - - Actor type definitions, field semantics, tool node behavior - - Graph constraints: unique node IDs, entry/exit validation, cycle detection - - Validation rules with examples for valid/invalid configurations - - Error message catalog - -- **Examples**: 5 YAML files in `examples/actors/` - - `simple_llm.yaml` - Minimal LLM actor (basic code review) - - `llm_with_tools.yaml` - LLM with tools, memory, context config - - `tool_collection.yaml` - TOOL actor with multiple tool references - - `simple_graph.yaml` - Basic 3-node linear graph workflow - - `graph_workflow.yaml` - Complex graph with conditionals, subgraphs, retry logic - -- **Tests**: Comprehensive coverage across all test types - - **Behave**: `features/actor_schema.feature` (50+ scenarios, 300+ steps) - - Valid/invalid configurations for all three actor types - - Name validation (namespace requirement, invalid characters) - - Graph topology (unique nodes, entry/exit validation, cycle detection) - - Tool/node validation, YAML I/O round-trip, error messages - - **Robot**: `robot/actor_schema.robot` (11 test cases) - - Smoke tests for all 5 example YAMLs - - Invalid configuration rejection (missing fields, bad topology, duplicate nodes) - - **ASV**: `benchmarks/actor_schema_bench.py` (8 benchmark classes) - - Parsing/validation for minimal/full LLM, tool, graph actors - - Graph topology validation performance (cycle detection) - - File I/O operations, serialization (`model_dump`) - -- **Branch**: `feature/actor-c1-schema` (11 commits across 10 sub-parts) -- **Commit messages follow Conventional Changelog format**: - 1. `feat(actor): add core enums for actor schema` - 2. `feat(actor): add tool and config pydantic models` - 3. `feat(actor): add graph topology models with validation` - 4. `feat(actor): add main actor schema and YAML I/O` - 5. `docs(actor): add comprehensive actor YAML examples` - 6. `docs(actor): add actor schema reference documentation` - 7. `test(actor): add behave scenarios for actor schema` - 8. `test(actor): add behave step definitions for actor schema` - 9. `test(actor): add robot framework integration tests for actor schema` - 10. `perf(actor): add asv benchmarks for actor schema` - 11. `test(actor): add final validation and quality checks` - -**2026-02-18**: Task C1.examples Complete (Aditya) - Actor YAML Examples and Documentation - -- **Implementation**: Built on C1.schema to add comprehensive documentation and examples - - **Documentation**: Created `docs/reference/actors_examples.md` (1098 lines) - - Pattern-based organization: Strategist, Executor, Reviewer, Tool-Only, Validation-Node, Graph, Hierarchical - - Each pattern includes: Purpose, Use Case, Key Features, complete YAML example - - Multi-level actor patterns: Planner/Executor hierarchies, parallel execution - - **Example Validation**: Verified all 5 YAML files from C1.schema work correctly - - Fixed `llm_with_tools.yaml` max_context_tokens (10000 → 16000) to match docs - -- **Tests**: Comprehensive coverage across all test layers (all passing) - - **Behave**: `features/actor_examples.feature` (25 scenarios, 173 steps) - - Load and validate all 5 example files - - Pattern verification (strategist, executor, reviewer, tool-only, validation-node) - - Complex graph patterns (conditional routing, retry logic, subgraph invocation, multi-level hierarchy) - - Documentation completeness checks - - Invalid actor rejection tests - - **Step Definitions**: `features/steps/actor_examples_steps.py` (435 lines) - - Maximized reuse of existing steps from `actor_schema_steps.py` - - Added pattern-specific steps (parallel execution, subgraph detection, doc checks) - - Enhanced parallel execution detection (config-based + topology-based) - - Added `context.error` compatibility for `service_steps.py` assertions - - **Robot**: `robot/actor_examples.robot` (16 test cases, 167 lines) - - Integration smoke tests for all example files - - Pattern verification and documentation checks - - Helper script: `robot/helper_actor_examples.py` (151 lines) - - **ASV**: `benchmarks/actor_examples_load_bench.py` (7 benchmark classes, 106 lines) - - Real-world YAML loading performance (1.46ms - 6.65ms per file) - - Individual benchmarks for each example file - - Batch loading and reload benchmarks - -- **Bug Fixes**: Resolved test suite issues during implementation - - Added missing `description` fields to graph nodes in test YAML strings - - Fixed `context_view` step definition conflict (added "config" variant) - - Enhanced parallel execution detection logic - - Added error message compatibility layer - -- **Branch**: `feature/m3-actor-schema-examples` (8 commits) -- **Commit messages follow Conventional Changelog format**: - 1. `docs(plan): mark actor YAML examples as complete in C1.examples checklist` - 2. `docs(actor): add comprehensive actor examples documentation` - 3. `test(actor): add behave scenarios for actor examples` - 4. `test(actor): add behave step definitions for actor examples` - 5. `test(actor): add robot framework tests for actor examples` - 6. `perf(actor): add asv benchmarks for actor examples` - 7. `test(actor): fix actor examples test suite issues` - 8. `docs(plan): update implementation_plan for completed C1.examples task` - -- **Test Results**: All quality checks passing - - Behave: 25/25 scenarios, 173/173 steps ✅ - - Robot: 16/16 tests ✅ - - ASV: 7/7 benchmarks verified and executable ✅ - - Linting: No errors ✅ - 11. `docs(actor): add c1.schema implementation notes and traceability` - -- **Quality metrics**: All nox sessions pass - - lint: 0 findings (pre-existing issues in other files noted) - - typecheck: 0 errors - - security_scan: 0 findings - - unit_tests: All scenarios pass - - integration_tests: All tests pass - - benchmark: All benchmarks execute successfully - -- **Implementation Notes section added** to task C1.schema in Implementation Checklist (line 2968) - - Full traceability with file paths and line numbers - - Design decisions documented with rationale - - Test coverage strategy explained - - Dependencies and open questions captured - -- **Next steps**: C2.loader (Actor Registry and Loader) depends on this schema foundation - - -**2026-02-17**: C0.skill.cli Complete (Aditya) - Skill CLI Commands + Output Formatting - -- Created `src/cleveragents/application/services/skill_service.py` — `SkillService` with dual-mode storage pattern (in-memory dict fallback, ready for `UnitOfWork` persistence when `C0.skill.registry` lands): - - `add_skill(config_dict, update)` — validates via `SkillConfigSchema`, builds `Skill` domain object, stores with timestamps; raises on duplicate unless `update=True` - - `get_skill(name)` — lookup by namespaced name with `KeyError` on miss - - `list_skills(namespace, source)` — filters by namespace prefix and/or tool source type (`builtin`, `mcp`, `agent_skill`, `custom`) - - `remove_skill(name)` — removes and returns the skill; tracks dependents via include graph - - `resolve_tools(name)` — delegates to `SkillResolver.resolve()` with cycle detection; returns `list[ResolvedToolEntry]` - - `get_dependents(name)` — scans includes to find skills that reference the given skill - - Metadata tracking: `_created_at`, `_updated_at`, `_config_paths` dicts for each registered skill -- Created `src/cleveragents/cli/commands/skill.py` — Typer command group with 5 subcommands: - - `skill add --config [--update] [--format]` — loads YAML, validates schema, registers skill, prints rich panel with capability summary - - `skill remove [--yes] [--format]` — confirmation prompt (skippable), dependency check warning, rich removal panel - - `skill list [--namespace] [--source] [--format]` — filtered table with tool counts, includes counts, summary panel - - `skill show [--format]` — full detail panels (details, includes, direct tools, MCP servers, agent skills, capability summary) - - `skill tools [--format]` — flattened resolved tool table with source tracking, read-only/writes/checkpoint columns - - All commands support 6 output formats (`rich`, `json`, `yaml`, `plain`, `table`, `color`) via `--format` flag - - Module-level `_service` singleton with `_get_skill_service()` / `_reset_skill_service()` for test isolation -- Updated `src/cleveragents/cli/main.py` — registered `skill` command group and added to `valid_cmds` list -- Created `features/skill_cli.feature` (25 scenarios, 164 steps) covering: - - Add from config (valid, duplicate, update, invalid schema, missing file) - - Remove (with confirmation, --yes, not found, dependency warning) - - List (all, namespace filter, source filter, empty result) - - Show (existing, not found, with includes, --format json) - - Tools (flattened output, includes source tracking, cycle detection, --format json) - - Output format tests (JSON, YAML validation) -- Created `features/steps/skill_cli_steps.py` — Behave step definitions using `typer.testing.CliRunner` with real `SkillService` (not mocked) -- Created `robot/skill_cli.robot` + `robot/helper_skill_cli.py` — 7 Robot smoke tests (add, add-duplicate, add-update, show, tools, list, remove) -- Created `benchmarks/skill_cli_bench.py` — 4 ASV benchmark suites (Add, List, Show, Tools) measuring CLI throughput -- Created `docs/reference/skill_cli.md` — CLI reference documentation with command syntax, options, examples, and output format descriptions -- **Quality checks (file-specific)**: - - Ruff lint: 0 findings - - Ruff format: all files formatted - - Bandit security: 0 findings (src/ scope) - - Vulture dead code: 0 findings - - Pyright typecheck: 0 errors, 0 warnings - - Behave tests: 25 scenarios, 164 steps, 0 failures - - Robot helpers: 7/7 pass - - ASV benchmarks: 4/4 suites pass -- Key decision: Followed `PlanLifecycleService` dual-mode pattern — `SkillService` works fully in-memory now; when Luis adds `C0.skill.registry` with `UnitOfWork`/`SkillRepository`, DB writes are added alongside the in-memory dict without changing the public API -- Key decision: Module-level `_service` singleton (not DI container) matches the pattern in `action.py` CLI; `_reset_skill_service()` enables test isolation - -**2026-02-19**: Task C2.loader Complete (Aditya) - Actor Registry and Loader - -- **Implementation**: Created `src/cleveragents/actor/loader.py` (277 lines) — `ActorLoader` class with thread-safe discovery, caching, and namespace management - - `ActorLoader.__init__(search_roots, tool_registry)` — accepts configurable search root directories and optional `ToolRegistry` for tool reference resolution - - `discover()` — scans all search roots recursively for `*.yaml`/`*.yml` files, parses against `ActorConfigSchema`, detects duplicates across roots, emits consolidated `ValidationError` with all errors - - `get(name)` — retrieves a loaded actor by its namespaced name - - `list_actors(namespace)` — lists all loaded actors with optional namespace prefix filtering - - `clear()` — drops all cached actors and content hashes - - `get_load_count(name)` — returns load count for a named actor (test introspection) - - `_CacheEntry` internal class stores `ActorConfigSchema`, SHA-256 content hash, source path, and load count - - `_compute_hash(content)` — SHA-256 content hashing for cache invalidation - - `_normalize_name(raw_name)` — applies `local/` default namespace when no slash present - - `_collect_yaml_files()` — recursive file collection from search roots with non-directory warning - - `_prune_deleted(current_files)` — removes stale actors whose source files no longer exist - - `_apply_namespace_default(raw)` — applies namespace default to raw YAML dict before validation - - `_resolve_tools(config)` — verifies tool references against `ToolRegistry`, logs warnings for unresolved tools - - All mutating operations protected by `threading.RLock` -- Updated `src/cleveragents/actor/__init__.py` — exported `ActorLoader` in package `__all__` - -- **Documentation**: Created `docs/reference/actors_loading.md` (83 lines) - - Discovery rules: search roots, YAML suffixes, recursive scanning - - Namespace handling: `local/` default, explicit namespace preservation, `/` format - - Duplicate detection: consolidated error across search roots - - Content-hash caching: SHA-256 based, skip reload for unchanged files - - API usage examples with code snippets - -- **Tests**: Comprehensive coverage across all test layers (all passing) - - **Behave**: `features/actor_loading.feature` (23 scenarios, 117 steps) - - Discovery: single root, multiple roots, YAML-only filtering, recursive nested discovery - - Duplicate detection: across roots, within single root, consolidated error messages - - Namespace handling: default `local/` application, explicit namespace preservation - - Namespaced lookup: get by name, nonexistent returns None, list filtered by namespace - - Content-hash caching: unchanged files not reloaded, modified files reloaded - - Validation: invalid YAML rejected, schema-invalid files rejected, list-content YAML rejected - - Integration: discover all example actors from `examples/actors/` - - Cache invalidation: clear removes all, deleted files removed on re-discovery - - Tool Registry: resolved tool references, unresolved tool warnings, no-tool actors with registry - - Edge cases: non-existent search root skipped gracefully - - **Step Definitions**: `features/steps/actor_loading_steps.py` (390 lines) - - Per-scenario temporary directory isolation via `_fresh_dir()` helper - - `_minimal_actor_yaml()` helper for generating valid actor YAML content - - Full coverage of given/when/then steps for all 23 scenarios - - **Robot**: `robot/actor_loading.robot` (4 test cases) - - Integration smoke tests: discover example actors, valid load, invalid rejection, namespaced lookup - - Helper script: `robot/helper_actor_loading.py` - - **ASV**: `benchmarks/actor_loading_bench.py` (4 benchmark classes) - - Discovery performance, cached re-discovery, namespace lookup, clear-and-reload cycle - -- **Coverage**: 98% on `src/cleveragents/actor/loader.py` (153 statements, 1 miss, 48 branches, 3 partial) - - Remaining uncovered: `_normalize_name` early return (line 62), two partial branch edges for empty iteration loops - -- **Quality checks (file-specific)**: - - Ruff lint: 0 findings - - Ruff format: all files formatted - - Bandit security: 0 findings - - Pyright typecheck: 0 errors - - Behave tests: 23 scenarios, 117 steps, 0 failures - - Robot tests: 4/4 pass - - ASV benchmarks: 4/4 suites pass - -- **Key design decisions**: - - Followed `ToolRegistry` pattern for thread-safe in-memory registry with `threading.RLock` - - SHA-256 content hashing (not mtime) for deterministic cache invalidation - - Single consolidated `ValidationError` when duplicates or parse errors found (not one error per file) - - Tool reference resolution at load time via optional `ToolRegistry` integration (warnings, not errors, for unresolved tools) - - `local/` default namespace applied during YAML parsing before schema validation - -- **Branch**: `feature/m3-actor-loader` -- **Files created/modified**: - - `src/cleveragents/actor/loader.py` (new) - - `src/cleveragents/actor/__init__.py` (modified) - - `features/actor_loading.feature` (new) - - `features/steps/actor_loading_steps.py` (new) - - `robot/actor_loading.robot` (new) - - `robot/helper_actor_loading.py` (new) - - `benchmarks/actor_loading_bench.py` (new) - - `docs/reference/actors_loading.md` (new) - -- **Next steps**: C2.compiler (Actor Compiler) depends on this loader; C2.context depends on C2.loader - - -**2026-02-20**: D0b.apply Complete (Jeff) - Diff Review + Apply Integration -- Created `src/cleveragents/application/services/plan_apply_service.py` — `PlanApplyService` with: - - `diff(plan_id, fmt)` — Generate unified diff from SpecChangeSet entries grouped by resource path, supporting rich/plain/json/yaml formats - - `artifacts(plan_id, fmt)` — Show ChangeSet ID, sandbox refs, apply summary, file list, and validation results - - `persist_apply_summary(plan_id, files_changed, validations_run)` — Store apply metadata (files changed, validations, timestamps) into plan - - `handle_merge_failure(plan_id, conflict_details)` — Rollback sandbox state and transition plan to ERRORED with conflict details - - `guard_empty_changeset(plan_id, allow_empty)` — Block apply on empty ChangeSet unless --allow-empty flag is set - - Helper functions: `_render_diff_plain`, `_render_diff_rich`, `_render_diff_json`, `_build_artifacts_dict`, `_operation_label` -- Updated `src/cleveragents/cli/commands/plan.py` — Added `plan diff` and `plan artifacts` CLI commands with --format flag -- Created `features/plan_diff_artifacts.feature` — 20 Behave scenarios covering diff output formats, artifacts, empty guard, apply summary, merge failure -- Created `features/steps/plan_diff_artifacts_steps.py` — Full step definitions with in-memory lifecycle + changeset store setup -- Created `robot/plan_diff_artifacts.robot` — 8 Robot integration tests for all service operations -- Created `robot/helper_plan_diff_artifacts.py` — Robot helper with test harness for each operation -- Created `benchmarks/plan_diff_bench.py` — 4 ASV suites (DiffRenderingSuite, ArtifactsSuite, GuardSuite, HelperFunctionsSuite) -- Created `docs/reference/plan_apply.md` — CLI reference for plan diff/artifacts, apply integration, error handling, recovery steps -- Updated `vulture_whitelist.py` — Added PlanApplyService public API entries -- Key decision: Used `error_details` dict on Plan as general metadata store (consistent with D0b.execute pattern) for apply summary fields until a dedicated metadata field lands -- Key decision: Service accepts optional `changeset_store` — when None, builds stub SpecChangeSet from plan metadata only; this keeps the feature independent of D0b.execute merge status - -**2026-02-20**: C5.router Complete (Jeff) - Tool Call Router for LLM Providers - -- Created `src/cleveragents/tool/router.py` (~890 lines) — `ToolCallRouter` translating between LLM provider tool call formats and internal `ToolRunner`: - - `ProviderFormat` enum: OPENAI, ANTHROPIC, LANGCHAIN, UNKNOWN - - `ToolCallErrorCategory` enum: TOOL_NOT_FOUND, SCHEMA_ERROR, EXECUTION_ERROR, TIMEOUT, PERMISSION_DENIED, UNKNOWN - - `StreamingStatus` enum: STARTED, ACCUMULATING, COMPLETE, ERROR - - `ToolCallRequest` Pydantic model — normalized request with provider_format, tool_name, arguments, call_id, raw_payload - - `NormalizedToolCallResult` Pydantic model — normalized result with call_id, tool_name, success, result_data, error fields, provider metadata, timing - - `StreamingToolUpdate` Pydantic model — streaming progress updates with status, accumulated_args, partial_result - - `detect_provider_format()` — identifies provider from raw payload structure - - `normalize_tool_call()` — converts provider-specific payloads to `ToolCallRequest` - - `generate_tool_call_id()` — deterministic IDs from plan_id + tool_name + sequence - - `classify_tool_error()` — categorizes error messages into `ToolCallErrorCategory` - - `normalize_tool_schema_for_provider()` — adapts schemas per provider limits (description length, field pruning) - - `ToolCallRouter` class with `route()`, `route_batch()`, `route_streaming()`, `export_schemas()` methods - - Thread-safe sequence counter for ID generation - - Validation tool surfacing with `is_validation` flag in results -- Updated `src/cleveragents/tool/__init__.py` — re-exports all router public API -- Created `features/tool_router.feature` — 50 Behave scenarios covering format detection, normalization, ID generation, routing, error classification, schema normalization, batch routing, streaming, validation surfacing -- Created `features/steps/tool_router_steps.py` — complete step implementations -- Created `robot/tool_router.robot` — 12 Robot Framework smoke tests (all pass) -- Created `robot/helper_tool_router.py` — Robot test helper -- Created `benchmarks/tool_router_bench.py` — 6 ASV benchmark suites (detect, normalize, route, batch, streaming, schema) -- Created `docs/reference/tool_router.md` — full reference documentation with provider mappings -- Updated `vulture_whitelist.py` — added router public API entries -- **Quality checks**: - - Ruff lint: 0 findings - - Pyright typecheck: 0 errors (strict mode) - - Behave tests: 50 scenarios, all passing - - Robot tests: 12/12 pass - - ASV benchmarks: 6/6 suites pass -- Key discovery: `ToolRunner.execute()` catches handler exceptions internally and returns `ToolResult(success=False)` rather than raising, so streaming produces COMPLETE + failed result (not ERROR update) for tool failures -- Key discovery: Pyright strict mode requires all Pydantic model fields (even those with defaults via `Field(default=...)`) to be explicitly passed in constructor calls -- Key discovery: Behave step name `'a ValueError should be raised with message containing "{text}"'` already existed in `coverage_boost_extra_steps.py`; renamed to `'a router ValueError should be raised containing "{text}"'` to avoid collision - ---- - -## Roadmap - -### Milestone Overview - -| Milestone | Target Date | Description | -|-----------|-------------|-------------| -| **M0: Foundation** | 2026-02-09 (Day 1) | Preserve existing LangGraph infrastructure and tooling baseline. | -| **M1: Minimal Plan Execution** | 2026-02-15 (Day 7) | Action YAML -> plan use -> execute/apply with LLM in git-checkout sandbox (no subplans). | -| **M2: Actor Compiler + Full LLM** | 2026-02-22 (Day 14) | v2 restore complete, actor compiler live, tool router + validation runner + MCP adapter. | -| **M3: Decision Tree + Correction** | 2026-02-26 (Day 18) | Decision recording, invariants, plan tree/explain/correct flows. | -| **M4: Subplans + Parallel** | 2026-03-02 (Day 22) | Subplan spawning, parallel execution, three-way merge. | -| **M5: ACMS + Large-Project Context** | 2026-03-06 (Day 26) | ACMS v1 + context indexing + 10K+ file handling. | -| **M6: Firefox-Scale Porting** | 2026-03-10 (Day 30) | Autonomous porting run with hierarchical decomposition and validation gates. | -| **Server Connectivity (Client Only)** | Beyond Day 30 | Client-side server stubs only (no server implementation in this project). | - -### Critical Path to 7-Day MVP (Source Code Only) - -**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). - -### Parallel Workstreams - -- Workstream A: Plan lifecycle + action/plan alignment + persistence (Section 3). -- Workstream B: Project/resource registry + CLI + sandbox strategies (Section 4). -- Workstream C: Actor/tool/skill/validation registries + built-in tools (Section 5). -- Workstream D: Tool router + change tracking + apply pipeline (Section 5/6). -- Workstream Q: Quality automation maintenance (Section 0). -- Workstream T: Testing (Brent through 2026-02-27, Rui after). - -## Quick Reference for Development - -### Tool Commands - -```bash -# Development setup -pip install -e .[dev,tests,docs] # Install with all extras -hatch env create # Create virtual environment -hatch shell # Activate environment - -# Testing -nox # Run all tests -nox -s unit_tests # Run Behave tests only -nox -s integration_tests # Run Robot tests only -nox -s coverage_report # Check coverage (must be >=97%) - -# Code quality -nox -s format # Format with Ruff -nox -s lint # Lint with Ruff -nox -s typecheck # Type check with pyright - -# Documentation -nox -s docs # Build documentation -``` - -### Key Files and Their Purpose -- `pyproject.toml` - All project configuration (no setup.py, no requirements.txt) -- `noxfile.py` - All task automation (no Makefile, no scripts/) -- `features/` - Behave unit tests (no tests/ directory) -- `robot/` - Robot integration tests -- `docs/specification.md` - Authoritative specification (source of truth for all architecture) -- `docs/reference/` - Discovery artifacts from Phase 0 -- `docs/architecture/decisions/` - ADRs from Phase 1 -- `examples/actions/` - Example action YAML config files -- `examples/actors/` - Example actor YAML config files -- `examples/tools/` - Example tool YAML config files -- `examples/skills/` - Example skill YAML config files -- `examples/profiles/` - Example automation profile YAML config files -- `examples/resource-types/` - Example custom resource type YAML config files -- `examples/validations/` - Example validation YAML config files - -### CLI Command Groups (spec-defined) -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 -# Core configuration (see spec Configuration section for the full list) -CLEVERAGENTS_HOME=~/.cleveragents -CLEVERAGENTS_LOG_LEVEL=INFO - -# Development -CLEVERAGENTS_DEBUG=true -CLEVERAGENTS_TEST_MODE=true -``` - ---- - -## Timeline Summary - -### TEAM ROLES AND ASSIGNMENTS - -| Developer | Role | Primary Focus Areas | Notes | -|-----------|------|---------------------|-------| -| **Jeff** | CTO/Lead Architect | Critical path items, architectural decisions, complex integrations | Fastest, most expert developer - handles blocking issues | -| **Luis** | Senior Python Architect | Domain models, persistence, algorithms, state machines | Good architecture but can be pedantic - needs clear requirements | -| **Aditya** | Domain Expert (Agents/LLMs) | Actor YAML configs, hierarchical actors, skill execution | Understands topic best but code may need cleanup | -| **Hamza** | Python/RDF Expert | Resources, sandbox, database, general Python | Well-rounded, no agent experience - assign infrastructure | -| **Rui** | Fast Developer | Testing (Behave/Robot), simpler implementations (post-2026-02-27) | New to Python; unavailable 2026-02-13 to 2026-02-27 | -| **Brent** | Quality Specialist | Code review, linting, type checking, documentation | Slow but detail-oriented - low contention independent work | -| **Mike/Brian** | Sysadmins | Deployment, infrastructure setup | Minimal coding tasks | - -### 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 | 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 | -| 5 | C3.protocol/C3.context/C3.inline Skill framework | Jeff | C4.file/C4.search Built-in skills | Luis + Jeff | -| 6 | C7.mcp MCP Adapter | Aditya + Jeff | C4.git + C5.model/C5.router Change tracking | Luis + Jeff | -| 7 | C5.diff Diff review artifacts | Luis | C6.pipeline/C6.gating Validation pipeline | Luis + Brent (tests) | - -### Week 2 (Days 8-14) - M3 Complete + Plan-Actor Integration -| Day | Focus | Owner | Deliverable | -|-----|-------|-------|-------------| -| 8 | C8.providers + C9.execute Plan-Actor integration | Jeff + Aditya (+Luis support) | Execute phase + providers ready | -| 9 | C9.apply Apply Phase + Review | Jeff + Luis | Apply flow ready with review gates | -| 10 | D1.domain Decision Model | Hamza (+Jeff review) | Decision model committed | -| 11 | D2.service Decision Recording | Hamza (+Jeff review) | Decision recording committed | -| 12 | E1.domain Subplan Model | Luis (+Jeff review) | Subplan domain committed | -| 13 | E2.service/E2.actor Subplan spawning | Jeff + Aditya (+Luis support) | Subplan spawn committed | -| 14 | End-to-end integration testing | All + Brent (tests/QA) | M3 milestone verified | - -### Week 3 (Days 15-21) - M4 Target (Decision Tree + Correction) -| Day | Focus | Owner | Deliverable | -|-----|-------|-------|-------------| -| 15 | D5.db/D5.repo Decision persistence | Hamza (+Jeff review) | Decision storage wired | -| 16 | D3.cli Decision viewing | Hamza (+Jeff review) | `agents [--data-dir PATH] [--config-path PATH] plan tree`, `agents [--data-dir PATH] [--config-path PATH] plan explain` | -| 17 | D4.revert Decision correction (revert) | Jeff (+Luis support) | `agents [--data-dir PATH] [--config-path PATH] plan correct` revert flow | -| 18 | D4.append + D5.di Decision wiring | Jeff + Hamza (+Luis support) | Append correction + service wiring | -| 19 | E3.exec Parallel Subplan Execution | Luis (+Jeff review) | Concurrent subplans | -| 20 | E4.merge Result Merging | Jeff (+Luis support) | Git-style merge for subplans | -| 21 | M4 integration testing | All + Rui (tests) + Brent (QA) | Decision correction working | - -### Week 4 (Days 22-30) - M6 Target (Large Project Autonomy - LOCAL MODE ONLY) -| Day | Focus | Owner | Deliverable | -|-----|-------|-------|-------------| -| 22-23 | CTX1.index Context indexing + G3.semantic | Hamza + Luis | Large codebase indexing + semantic validation | -| 24-25 | G4.context Hot/Warm/Cold tiers + G2.checkpoint | Hamza + Luis | Three-tier memory + checkpointing | -| 26-27 | G1.decompose + G5.estimate | Jeff + Hamza | Autonomous decomposition + estimation | -| 28 | F0.stubs | Luis | Client stubs (NOT server impl) | -| 29 | M6 perf triage + large project tests | All + Rui (tests) + Brent (QA) | 10K file perf target | -| 30 | M6 integration testing | All + Rui (tests) + Brent (QA) | Large project autonomy verified (Server connectivity DEFERRED) | - -> **Note**: Server connectivity (F1-F4) is DEFERRED beyond Day 30. Days 26-29 focus on client **stubs only** and large project testing. The server is a separate project. - -### Week 5 (Days 31-35) - M7 Target (Server Connectivity - Client Side Only) -| Day | Focus | Owner | Deliverable | -|-----|-------|-------|-------------| -| 31-32 | F1.client Server client infrastructure | Luis (+Jeff review) | HTTP client for server communication | -| 33 | F2.sync Plan sync client | Luis (+Jeff review) | Client can sync plans to server | -| 34 | F3.ws WebSocket client | Luis (+Jeff review) | Client receives real-time updates | -| 35 | F4.remote Remote project support | Hamza (+Jeff review) | Client can request server execution | - -### Week 6 (Days 36-40) - M8 Target (Full Feature Set + Polish) -| Day | Focus | Owner | Deliverable | -|-----|-------|-------|-------------| -| 36 | A6.* automation level refinements | Jeff + Luis | Automation modes stabilized | -| 37 | G5.estimate cost/risk estimation | Hamza (+Jeff review) | Estimation working | -| 38 | G2.checkpoint rollback | Luis (+Jeff review) | Checkpointing + rollback | -| 39 | G1.decompose + G3.semantic performance tuning | Jeff + Luis | Benchmarks passing | -| 40 | Final integration + documentation | All + Rui (tests) + Brent (QA) | Release candidate ready | - -### Continuous Tasks (Throughout) - -**Brent (Quality - Independent, Low Contention)**: -- Review all PRs within 4 hours of submission -- Run `nox -s typecheck` on all branches before merge -- Run `nox -s lint` and ensure 0 warnings -- Monitor test coverage (must stay >=97%) -- Update documentation for API changes -- Security audit: no eval(), no template injection, no secrets in code - -**Rui (Testing - Parallel with Feature Work)**: -- Unavailable 2026-02-13 to 2026-02-27; Brent owns M1/M2 testing during this window -- Write Behave scenarios for each feature (before implementation starts) after return -- Write Robot integration tests for each milestone after return -- Run full test suite daily once back on rotation -- Report test failures immediately -- Maintain test fixtures and mocks in `features/` - -### Critical Path Dependencies - -``` -Day 1: A5 (Persistence + Action Args) ───────────────────────────────┐ -Day 2: B1.core/B2.persistence/B2.service/B3.cli (Project/Resource) ─┐│ -Day 3: B4.sandbox (Sandbox) ────────────────────────────────────────┼┤ -Day 4: C1.schema/C2.legacy/C2.compiler (Actor) ─────────────────────┘│ -Day 5: C3.protocol/C4.file (Skills) ─────────────────────────────────┤ -Day 6: C4.search/C5.model (Change Tracking) ─────────────────────────┤ -Day 7: C6.pipeline/C7.mcp/C8.providers (Validation + Providers) ─────┘ - │ -Day 8-9: C9.execute/C9.apply (Integration + Apply) ────────────────┤ -Day 10-14: D1-E2 (Decisions + Subplans) ────────────────┤ - │ - MERGE POINT M3 ◄──────────────┘ - │ -Day 15-21: D3-E4 (Correction + Parallel) ───────────────┤ - │ - MERGE POINT M4 ◄──────────────┘ - │ -Day 22-30: CTX/G + F0 (Context + Large Project + Stubs) ─┘ -``` - -### Risk Mitigation - -| Risk | Mitigation | Owner | -|------|------------|-------| -| Git worktree complexity | Use B4.sandbox git_worktree with pre-commit verification and isolation tests | Jeff | -| Multi-file generation reliability | Validate C9.execute/C9.apply flows with diff review artifacts and Robot E2E | Luis + Brent (Rui after 2026-02-27) | -| Decision tree correction bugs | Jeff reviews D4 correction + checkpointing; add revert/append Behave coverage | Jeff | -| Large codebase performance | Profile CTX1/CTX2 indexing + hot/warm/cold tiers; enforce bounded memory tests | Luis + Hamza | -| Server connectivity stubs stability | Keep client-only stubs isolated; gate with feature flags and contract tests | Jeff + Luis | - -### Definition of Done (Each Task) - -1. ✅ Code implemented with full type annotations -2. ✅ Behave scenarios written and passing -3. ✅ Robot integration tests (for CLI/E2E tasks) passing -4. ✅ `nox -s typecheck` passes with 0 errors -5. ✅ `nox -s lint` passes with 0 warnings -6. ✅ Test coverage >=97% -7. ✅ PR reviewed by Brent (or Jeff for critical items) -8. ✅ Implementation notes added to this document - ---- - -## MILESTONE SUCCESS CRITERIA (DETAILED) - -### M1: Minimal Plan Execution (Day 7, past due) - -**End-to-end verification command sequence:** -```bash -# 1. Create an action -cat > /tmp/test_action.yaml < - -# 6. Review diff -agents [--data-dir PATH] [--config-path PATH] plan diff - -# 7. Apply changes -agents [--data-dir PATH] [--config-path PATH] plan apply - -# 8. Verify changes in repo -cd /path/to/repo && git log -1 # Shows CleverAgents commit -``` - -**Technical Criteria:** -- Plan and Action records persist to SQLite database. -- Execute/apply runs via actor-based LLM path. -- ChangeSet built from tool invocations (not parsed from output). -- Git worktree sandbox creates isolated working directory. -- Changes in sandbox do not affect original until Apply. -- Test coverage remains >=97%. - -### M2: Actor Compiler + Full LLM (Day 14) - -**End-to-end verification:** -```bash -# Create actor YAML file -cat > my_actor.yaml < /tmp/custom_action.yaml < - -# Validate tool routing + validation runner -agents [--data-dir PATH] [--config-path PATH] plan validations -``` - -**Technical Criteria:** -- Actor YAML files parse and validate correctly. -- Actors compile to LangGraph StateGraphs. -- Tool router and MCP adapter can resolve external tools. -- Validation runner executes required/informational validations. -- Multi-file generation produces correct ChangeSet. - -### M3: Decision Tree + Correction (Day 18) - -**End-to-end verification:** -```bash -# Execute a plan to generate decisions -agents [--data-dir PATH] [--config-path PATH] plan use local/complex-action local/large-project -agents [--data-dir PATH] [--config-path PATH] plan execute - -# View decision tree -agents [--data-dir PATH] [--config-path PATH] plan tree - -# Explain a decision -agents [--data-dir PATH] [--config-path PATH] plan explain - -# Add and list project invariants -agents [--data-dir PATH] [--config-path PATH] invariant add --project local/large-project "Use session cookies" -agents [--data-dir PATH] [--config-path PATH] invariant list --project local/large-project - -# Correct a decision (dry run first) -agents [--data-dir PATH] [--config-path PATH] plan correct --mode=revert --guidance "Use session cookies instead of JWT" --dry-run - -# Execute correction -agents [--data-dir PATH] [--config-path PATH] plan correct --mode=revert --guidance "Use session cookies instead of JWT" -``` - -**Technical Criteria:** -- Decisions recorded during Strategize with full context snapshot. -- Decision tree persists to database and renders correctly. -- Correction in revert mode re-executes from decision point. -- Invariants are enforced during strategize. - -### M4: Subplans + Parallel Execution (Day 22) - -**End-to-end verification:** -```bash -# Execute plan that spawns multiple subplans -agents [--data-dir PATH] [--config-path PATH] plan use local/refactor-action local/monorepo -agents [--data-dir PATH] [--config-path PATH] plan execute - -# View subplan tree -agents [--data-dir PATH] [--config-path PATH] plan tree - -# Verify merged results -agents [--data-dir PATH] [--config-path PATH] plan diff -``` - -**Technical Criteria:** -- Subplans spawned during Execute. -- Parallel subplan execution works with max_parallel. -- Three-way merge combines non-conflicting changes; conflicts surfaced. -- Parent plan tracks all subplan statuses. - -### M5: ACMS + Large-Project Context (Day 26) - -**End-to-end verification:** -```bash -# Index a large project (10,000+ files) -agents [--data-dir PATH] [--config-path PATH] project create local/large-project -agents [--data-dir PATH] [--config-path PATH] resource add git-checkout local/large-repo \ - --path /path/to/large/repo \ - --branch main -agents [--data-dir PATH] [--config-path PATH] project link-resource local/large-project local/large-repo - -# Verify indexing + context tiers -agents [--data-dir PATH] [--config-path PATH] project show local/large-project -``` - -**Technical Criteria:** -- Projects with 10,000+ files index without timeout. -- Context window management works (hot/warm/cold tiers). -- ACMS v1 pipeline produces scoped context output. - -### M6: Firefox-Scale Porting (Day 30) - -**End-to-end verification:** -```bash -# Create porting action -cat > /tmp/port_action.yaml < - -# Monitor hierarchical decomposition -agents [--data-dir PATH] [--config-path PATH] plan tree - -# Apply when complete -agents [--data-dir PATH] [--config-path PATH] plan apply -``` - -**Technical Criteria:** -- Hierarchical decomposition creates 4+ levels of subplans. -- Decision correction recomputes only affected subtree. -- Parallel execution scales to 10+ concurrent subplans. -- A realistic porting task (Firefox-scale) completes autonomously. -- `nox` passes with coverage >=97% including large-project suites. - ---- - -## QUICK REFERENCE: TASK DEPENDENCIES - -``` -LEGEND: - ───► = Sequential dependency (must complete before next) - ═══► = Parallel tracks that can proceed simultaneously - ⊕ = Merge point (all parallel tracks must complete) - -DAY 13-15: M1 CRITICAL PATH -┌─────────────────────────────────────────────────────────────────┐ -│ [Jeff] v2 LangGraph core + agent restore ───► execute/apply │ -│ [Brent] M1 end-to-end smoke suite │ -└─────────────────────────────────────────────────────────────────┘ - -DAY 15-18: M2 ACTOR COMPILER + FULL LLM -┌─────────────────────────────────────────────────────────────────┐ -│ [Jeff] actor compiler + actor CLI + tool router + file skills │ -│ [Aditya] MCP adapter runtime │ -│ [Luis] change model + validation runner + git skills │ -└─────────────────────────────────────────────────────────────────┘ - -DAY 19-23: M3 DECISIONS + CORRECTION -┌─────────────────────────────────────────────────────────────────┐ -│ [Hamza] decision domain/persistence/cli/service + invariants │ -│ [Jeff] plan correct + output rendering │ -│ [Luis] security eval hardening │ -└─────────────────────────────────────────────────────────────────┘ - -DAY 23-26: M4 SUBPLANS + MERGE -┌─────────────────────────────────────────────────────────────────┐ -│ [Jeff] subplan orchestrator + parallel exec + phase reversion │ -│ [Luis] three-way merge │ -│ [Rui] M1-M4 integration tests │ -│ [Jeff] config service resolution │ -└─────────────────────────────────────────────────────────────────┘ - -DAY 26-28: M5 ACMS + CONTEXT -┌─────────────────────────────────────────────────────────────────┐ -│ [Hamza] ACMS v1 pipeline + context indexing │ -│ [Jeff] large-project handling │ -└─────────────────────────────────────────────────────────────────┘ - -DAY 28-30: M6 FIREFOX-SCALE PORTING -┌─────────────────────────────────────────────────────────────────┐ -│ [Jeff] hierarchical decomposition + porting run + perf tuning │ -└─────────────────────────────────────────────────────────────────┘ -``` - ---- - -## SERVER CONNECTIVITY DEFERRAL NOTICE - -**Server connectivity (WORKSTREAM F) is deferred beyond the 30-day timeline. The server is a separate project—this implementation covers the client only.** - -The CleverAgents executable (`agents`) is purely a **client application** that can: -1. Run in stand-alone local-only mode (no server required) -2. Connect to an independently developed CleverAgents server for multi-user/collaborative features - -During Days 1-30, client stub infrastructure is delivered via the Day 14 plan M6 server stub workstream (M6.1/M6.2/M6.4), covering the connect command, client interfaces, local/remote detection, ACP facade, and LSP stub behavior. - -**What is NOT needed by Day 30:** -- Server implementation (the server is a separate project) -- Full client-server API implementation -- WebSocket client implementation -- Remote plan execution requests -- Authentication flow with server -- Permission system integration - -The client code should be structured so that adding server connectivity later is straightforward, but no functional server communication code is required for the 30-day milestone. The server will be developed as a separate project. - -## Schedule Adhereance - -Each schedule update entry must include: timeline reference, summary, milestone forecast, track forecast, developer forecast, and a task inventory table (milestone × developer breakdown). - -### 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-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 ~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 | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | 0d (no tasks due yet) | available | HIGH | lifecycle persistence + tool runtime + CLI rebaseline - - Luis | 0d (no tasks due yet) | available | MEDIUM | repositories + apply pipeline - - Hamza | 0d (no tasks due yet) | available | HIGH | resource registry + sandbox strategies - - Aditya | 0d (no tasks due yet) | available | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs - - Brent | +1d ahead (Q0 quality gates completed early) | available | MED-HIGH | test coverage + integration stability - - Rui | 0d (no tasks due yet) | available through tomorrow | HIGH | tests deferred until return - - Mike/Brian | N/A | standby | LOW | none - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 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-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 ~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 | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | 0d (no COMMIT tasks due yet; model alignment on track) | available | HIGH | lifecycle persistence + tool runtime + CLI rebaseline - - Luis | 0d (no COMMIT tasks due yet; plan model prep) | available | MEDIUM | repositories + apply pipeline - - Hamza | 0d (no COMMIT tasks due yet; sandbox work progressing) | available | HIGH | resource registry + sandbox strategies + RDF groundwork - - Aditya | +1d ahead (A2b.gamma action YAML schema completed early) | available | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs - - Brent | +1d ahead (Q0 done + CI bugfixes clearing pipeline) | available | MED-HIGH | test coverage + integration stability - - Rui | N/A (unavailable starting today) | unavailable 2026-02-13 to 2026-02-27 | HIGH | test backlog resumes after 2026-02-27 - - Mike/Brian | N/A | standby | LOW | none - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 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 | Tool runtime + file tools + sandbox strategies landed; resource registry tables done; M1 blocked by plan phase rebaseline, persistence wiring, resource/project CLI, and apply pipeline/validation gate. -- Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-15) -> ETA 2026-02-21 | +6d | HIGH - - M2 (2026-02-18) -> ETA 2026-02-25 | +7d | HIGH - - M3 (2026-02-22) -> ETA 2026-03-03 | +9d | HIGH - - M4 (2026-03-01) -> ETA 2026-03-10 | +9d | MED-HIGH - - M5 (2026-03-05) -> ETA 2026-03-13 | +8d | MEDIUM - - M6 (2026-03-10) -> ETA 2026-03-14 | +4d | MED-HIGH -- Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~5-7d | ETA 2026-02-21 | HIGH | plan phase rebaseline + persistence wiring - - Track B (Projects/resources + sandbox) | behind ~5-7d | ETA 2026-02-21 | HIGH | resource type model + project/resource repos + CLI - - Track C (Actors/tools/skills/validations) | behind ~7-9d | ETA 2026-03-03 | HIGH | tool registry persistence + actor YAML compiler + validation attachments - - Track D (Change tracking + apply pipeline) | behind ~5-7d | ETA 2026-02-22 | HIGH | ChangeSet + apply pipeline + execute/apply wiring - - Track Q (Quality automation) | ahead | ETA 2026-02-15 | LOW | maintenance only - - Track T (Testing) | at risk (Rui out) | ETA 2026-02-27+ | HIGH | QA load on Brent + feature owners -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | +1d ahead (tool runtime + file tools landed early on C-track; plan rebaseline pending on A-track; net slight ahead) | available | HIGH | plan phase rebaseline + persistence + resource/project CLI + execute/apply wiring - - Luis | -1d behind (repository wiring not yet complete) | available | MED-HIGH | repositories + apply pipeline + service wiring - - Hamza | 0d on schedule (sandbox strategies complete, resource types in progress) | available | MEDIUM | resource types + project DB + RDF groundwork - - Aditya | +1d ahead (schema work progressing ahead of plan) | available | MEDIUM | actor/skill/tool YAML configs + hierarchical graphs + MCP configs - - Brent | +1d ahead (QA gates solid, expanding coverage ahead of schedule) | available | MED-HIGH | test coverage + integration stability - - Rui | N/A (unavailable) | unavailable 2026-02-13 to 2026-02-27 | HIGH | test backlog resumes after 2026-02-27 - - Mike/Brian | N/A | standby | LOW | none - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 2026-02-17 (Day 9 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 ~3-4d | HIGH | Action/plan persistence + resource/project registry largely landed; apply pipeline, validation gating, and actor YAML pipeline still missing. -- 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-02-27 | +5d | HIGH - - M4 (2026-03-01) -> ETA 2026-03-04 | +3d | MED-HIGH - - M5 (2026-03-05) -> ETA 2026-03-06 | +1d | MEDIUM - - M6 (2026-03-10) -> ETA 2026-03-12 | +2d | MEDIUM -- Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~2-3d | ETA 2026-02-20 | MED-HIGH | execute/apply integration + CLI/Robot tests - - Track B (Projects/resources + sandbox) | behind ~3-4d | ETA 2026-02-24 | MED-HIGH | resource tree/inspect + handlers/auto-discovery - - Track C (Actors/tools/skills/validations) | behind ~6-7d | ETA 2026-02-27 | HIGH | actor YAML compiler + tool/validation CLI + registry persistence - - Track D (Change tracking + apply pipeline) | behind ~4-5d | ETA 2026-02-24 | HIGH | ChangeSet capture + validation gating + diff review - - Track Q (Quality automation) | ahead | ETA 2026-02-18 | LOW | maintenance only - - Track T (Testing) | at risk (Rui out) | ETA 2026-02-27+ | HIGH | QA load on Brent + feature owners -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | -1d behind (4/7 due tasks done; A5.delta +2d, B0.repo tasks +3d pending; offset by A5.epsilon/zeta done early) | available | HIGH | apply pipeline + tool/validation CLI + actor compiler - - Luis | -2d behind (0/2 due tasks done; D0.beta +3d, PROV1 +2d — apply pipeline not started) | available | MED-HIGH | apply pipeline + validation runner + decision/invariant wiring - - Hamza | 0d on schedule (no COMMIT tasks due yet; resource/sandbox foundation work progressing) | available | MEDIUM | resource handlers + DAG CLI + UKO/RDF groundwork - - Aditya | +3d ahead (C1.schema done Day 9, planned Day 12 — well ahead) | available | MEDIUM | actor/skill YAML configs + MCP adapter + hierarchical graphs - - Brent | +2d ahead (A4b.tests on time; A5.tests done 2d early; A7.domain.tests done 4d early) | available | MED-HIGH | coverage + integration stability + CLI/persistence tests - - Rui | N/A (unavailable) | unavailable 2026-02-13 to 2026-02-27 | HIGH | test backlog resumes after 2026-02-27 - - Mike/Brian | N/A | standby | LOW | none - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 2026-02-18 (Day 10 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 ~3-4d | HIGH | M1 blocked by apply pipeline + validation gating + M1 CLI/persistence tests; resource/project registries and tool runtime are done, actor/skill schema work in progress. -- 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-02-27 | +5d | HIGH - - M4 (2026-03-01) -> ETA 2026-03-04 | +3d | MED-HIGH - - M5 (2026-03-05) -> ETA 2026-03-06 | +1d | MEDIUM - - M6 (2026-03-10) -> ETA 2026-03-10 | +0d | MED-HIGH -- Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~2-3d | ETA 2026-02-20 | MED-HIGH | apply pipeline wiring + CLI/persistence tests - - Track B (Projects/resources + sandbox) | behind ~3-4d | ETA 2026-02-24 | MED-HIGH | resource tree/inspect + handlers/auto-discovery - - Track C (Actors/tools/skills/validations) | behind ~5-6d | ETA 2026-02-27 | HIGH | actor compiler + tool/validation CLI + MCP/Agent Skills adapters - - Track D (Change tracking + apply pipeline) | behind ~4-5d | ETA 2026-02-24 | HIGH | apply pipeline + validation gating + diff review - - Track Q (Quality automation) | ahead | ETA 2026-02-18 | LOW | maintenance only - - Track T (Testing) | at risk (Rui out) | ETA 2026-02-27+ | HIGH | QA load on Brent + feature owners -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | -1d behind (5/10 due tasks done; B1.types -2d, B1.dag -3d, B2.model -5d early — but A5.delta +2d, B0.repo/services/CLI +3d pending) | available | HIGH | apply pipeline wiring + tool/validation CLI + actor compiler - - Luis | -2d behind (0/3 due tasks done; D0.beta +3d, PROV1 +2d, PROV2 +2d — apply pipeline still not started) | available | MED-HIGH | apply pipeline + validation runner + decision persistence - - Hamza | 0d on schedule (CLI0.core done Day 10 exactly as planned; no other tasks due yet) | available | MEDIUM | resource handlers + DAG CLI + UKO/RDF groundwork - - Aditya | +2d ahead (C1.schema done Day 9 vs planned Day 12 = -3d; C1.examples done Day 10 vs planned Day 12 = -2d) | available | MEDIUM | actor/skill YAML configs + MCP/Agent Skills adapters - - Brent | -1d behind (1/4 due tasks done; tool-domain/skill-domain/D0 tests pending — but A5.tests done 2d early) | available | MED-HIGH | M1/M2 CLI/persistence tests + coverage stability - - Rui | N/A (unavailable) | unavailable 2026-02-13 to 2026-02-27 | HIGH | test backlog resumes after 2026-02-27 - - Mike/Brian | N/A | standby | LOW | none - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 2026-02-20 (Day 12 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 ~3-5d | MED-HIGH | Skill protocol/context/registry/inline-executor landed (Jeff batch2); actor loader landed (Aditya); SEC5/SEC7/CONC3/CLI0 all merged (Hamza); session CLI, config CLI, persistence Robot tests, QA playbook merged (Brent); ASV benchmarks operational (Michael). Execute/apply pipeline (D-track) remains the critical M1 blocker — no D-track code has been merged yet. Jeff's combined-batch2 branch (skill protocol + automation cleanup) pending PR/merge. -- Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-15) -> ETA 2026-02-23 | +8d | HIGH — execute/apply pipeline (D0b.execute, D0b.apply, D1.apply) unstarted; Jeff must pivot to D-track immediately - - M2 (2026-02-18) -> ETA 2026-02-22 | +4d | MEDIUM — resource registry/CLI/tree/inspect all done; remaining: handlers, auto-discovery, edge cases - - M3 (2026-02-22) -> ETA 2026-02-27 | +5d | MED-HIGH — skill infra largely done; remaining: actor compiler, skill compiler CLI, change model, MCP adapter, validation runner - - M4 (2026-03-01) -> ETA 2026-03-04 | +3d | MEDIUM — decisions/invariants not started but building blocks (persistence, CLI patterns) are solid - - M5 (2026-03-05) -> ETA 2026-03-08 | +3d | MEDIUM — subplan domain model done (Luis E1); orchestration and merge logic pending - - M6 (2026-03-10) -> ETA 2026-03-12 | +2d | MEDIUM — ACMS v1 not started; gap narrowing thanks to team velocity on M1-M3 foundations -- Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~1-2d | ETA 2026-02-21 | MEDIUM | CLI/persistence tests pending (Brent branches exist); execute/apply wiring is D-track - - Track B (Projects/resources + sandbox) | behind ~2-3d | ETA 2026-02-22 | MEDIUM | resource handlers/auto-discovery + DAG edge cases remaining - - Track C (Actors/tools/skills/validations) | behind ~4-5d | ETA 2026-02-27 | MED-HIGH | actor compiler + skill compiler CLI + change model + MCP adapter + validation runner still pending - - Track D (Change tracking + apply pipeline) | behind ~7-8d | ETA 2026-02-27 | HIGH | **Critical blocker** — D0b.execute/D0b.apply/D1.apply all unstarted; this blocks M1 completion - - Track Q (Quality automation) | ahead | ETA complete | LOW | CI improvements merged (Brent); ASV operational (Michael) - - Track T (Testing) | at risk (Rui out) | ETA 2026-02-27+ | MED-HIGH | Brent carrying full QA load; persistence/CLI Robot tests in progress; Rui returns Feb 27 -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | -1d behind (8/16 due tasks done; A6 track -13d ahead, C3 protocol/context -4d ahead, but D0b.execute/D0b.apply +2-3d behind and critical. B0 repos/services/CLI +3d pending.) | available | HIGH | **MUST pivot to D-track** (execute/apply pipeline) — skill/automation batch2 ready for PR; actor compiler + CLI extensions secondary - - Luis | -3d behind (0/8 due tasks done; D0.beta +3d, PROV1/2 +2d, CONC1 +2d, SEC1-4 deliberately deferred to +14d. Apply pipeline is the critical gap.) | available | MED-HIGH | apply pipeline (D1.apply) + validation runner (C5.router) + change model (C5.model — has remote branch) + provider fixes - - Hamza | +2d ahead (4 tasks complete, 3 done 2-3d early: SEC5 -2d, SEC7 -3d, CONC3 -2d, CLI0 on time. Strong velocity on security/ops track.) | available | MEDIUM | resource handlers/auto-discovery + decision persistence (D3) + invariants (D2); SEC5/SEC7/CONC3/CLI0 all complete - - Aditya | +2d ahead (C1.schema -3d, C1.examples -2d; C2.loader code complete, needs quality+PR) | available | MEDIUM | actor schema examples (branch exists, needs PR) + actor compiler + MCP adapter; C2.loader complete - - Brent | -1d behind (2/8 due tasks done on time; 6 testing tasks pending BUT most have committed code in branches just needing quality+PR. Effective coding work is closer to on schedule.) | available | MED-HIGH | persistence tests (branches exist) + CLI tests + scale/validation edge cases; needs to open PRs for tool/skill domain Robot tests - - Rui | N/A (unavailable) | unavailable until 2026-02-27 | HIGH | test backlog resumes after return -- Mike/Brian | N/A | standby | LOW | ASV benchmark testing (Michael active on CI) - - Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - -### 2026-02-21 (Day 13 since kickoff on 2026-02-09) -- Timeline reference: M1=Day 7 (2026-02-15, past due), M2=Day 14 (2026-02-22), M3=Day 18 (2026-02-26), M4=Day 22 (2026-03-02), M5=Day 26 (2026-03-06), M6=Day 30 (2026-03-10). -- Summary (Team | Status | Risk | Notes): Behind ~6-8d | CRITICAL | v2 LangGraph infrastructure stubbed (~4K LOC) and agent classes deleted during v3 transition; restore is now the M1 blocker and prerequisite for execute/apply. -- Task inventory (Milestone × Developer, current rebaseline): - Note: Task inventory was not recorded at this time. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M2 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M3 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M4 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M5 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | M6 | N/A | N/A | N/A | N/A | N/A | N/A | N/A | - | Total | N/A | N/A | N/A | N/A | N/A | N/A | N/A | -- Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-15) -> ETA 2026-02-23 | +8d | CRITICAL - - M2 (2026-02-22) -> ETA 2026-02-27 | +5d | HIGH - - M3 (2026-02-26) -> ETA 2026-03-03 | +5d | HIGH - - M4 (2026-03-02) -> ETA 2026-03-06 | +4d | MED-HIGH - - M5 (2026-03-06) -> ETA 2026-03-08 | +2d | MEDIUM - - M6 (2026-03-10) -> ETA 2026-03-10 | +0d | MEDIUM -- Track forecast (Track | Status | ETA | Risk | Blocking): - - Track A (Plan lifecycle + persistence) | behind ~5-7d | ETA 2026-02-23 | CRITICAL | execute/apply blocked by v2 restore - - Track B (Projects/resources + sandbox) | on track | ETA 2026-02-27 | MEDIUM | minor edge cases - - Track C (Actors/tools/skills/validations) | behind ~6-8d | ETA 2026-03-03 | HIGH | actor compiler + MCP adapter + validation runner - - Track D (Decision/correction + apply) | behind ~7-9d | ETA 2026-03-06 | HIGH | decision persistence + correction engine - - Track Q (Quality automation) | ahead | ETA complete | LOW | maintenance only - - Track T (Testing) | at risk (Rui out) | ETA 2026-03-06+ | HIGH | QA load on Brent + feature owners -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | -2d behind (v2 restore + execute/apply now critical) | available | CRITICAL | restore v2 LangGraph + agent classes, execute/apply pipeline, actor compiler - - Luis | -2d behind | available | HIGH | change model + validation runner + three-way merge - - Hamza | on track | available | MEDIUM | decisions/invariants + ACMS + context indexing - - Aditya | +1d ahead | available | MEDIUM | MCP adapter runtime + skill git - - Brent | on track | available | MED-HIGH | M1 E2E smoke + integration stability - - Rui | N/A (unavailable) | unavailable 2026-02-13 to 2026-02-27 | HIGH | M4 integration suite after return - - Mike/Brian | N/A | standby | LOW | none - -### 2026-02-22 (Day 14 since kickoff on 2026-02-09) -- Timeline reference: Day 7/M1 = 2026-02-15, Day 14/M2 = 2026-02-22, Day 18/M3 = 2026-02-26, Day 22/M4 = 2026-03-02, Day 26/M5 = 2026-03-06, Day 30/M6 = 2026-03-10. -- Summary (Team | Status | Risk | Notes): Behind ~7-9d | HIGH | Tool/router/resource registry/sandbox foundations exist; M1 still blocked by tool-aware execute + resource handlers + apply merge wiring. -- Milestone forecast (Target -> ETA | Delta | Risk): - - M1 (2026-02-15) -> ETA 2026-02-25 | +10d | HIGH - - M2 (2026-02-22) -> ETA 2026-02-28 | +6d | HIGH - - M3 (2026-02-26) -> ETA 2026-03-04 | +6d | MED-HIGH - - M4 (2026-03-02) -> ETA 2026-03-07 | +5d | MED-HIGH - - M5 (2026-03-06) -> ETA 2026-03-09 | +3d | MEDIUM - - M6 (2026-03-10) -> ETA 2026-03-10 | +0d | MED-HIGH -- Track forecast (Track | Status | ETA | Delta | Risk | Blocking): - - Track A (Tool-aware execute + apply) | behind ~7-8d | ETA 2026-02-25 | +10d | HIGH | actor runtime + sandbox apply merge - - Track B (Resources + sandbox handlers) | behind ~4-5d | ETA 2026-02-24 | +9d | MED-HIGH | resource handlers + bindings - - Track C (Actors/tools/skills/MCP) | behind ~6-7d | ETA 2026-02-28 | +6d | HIGH | actor compiler + MCP/Agent Skills loaders - - Track D (Decisions/validations/invariants) | behind ~8-10d | ETA 2026-03-04 | +6d | HIGH | decision persistence + validation runner - - Track E (Corrections/subplans/checkpoints) | behind ~7-9d | ETA 2026-03-07 | +5d | MED-HIGH | correction engine + subplan scheduler - - Track F (ACMS v1/context scaling) | behind ~8-10d | ETA 2026-03-09 | +3d | MEDIUM | UKO/CRP + pipeline - - Track Q (Quality automation) | ahead | ETA complete | LOW | maintenance only - - Track T (Testing) | at risk (Rui out) | ETA 2026-03-07+ | MED-HIGH | QA load on Brent + feature owners -- Developer forecast (Name | Days Ahead/Behind | Availability | Risk | Focus): - - Jeff | -2d behind | available | HIGH | actor runtime + execute wiring + actor compiler + LSP stubs - - Luis | -3d behind | available | HIGH | apply pipeline + changeset persistence + validation gating - - Hamza | -1d behind | available | MED-HIGH | resource handlers + decision domain + ACMS foundation - - Aditya | +1d ahead | available | MEDIUM | actor YAML hierarchy + MCP runtime + Agent Skills loader - - Brent | on track | available | MED-HIGH | M1/M2/M3 smoke suites + coverage enforcement - - Rui | N/A (unavailable) | unavailable 2026-02-13 to 2026-02-27 | HIGH | integration suites after return - - Mike/Brian | N/A | standby | LOW | none -- Task inventory (Milestone × Developer, current rebaseline): - Note: Each cell is **completed/total COMMIT items** for that milestone/owner. Completed counts are cumulative (all-time) and must never decrease; totals equal completed plus remaining Day 14 rebaseline items for that milestone/owner. Post-M6 rows reflect Section 18 deferred commits; totals can change as future work is added/removed but must always remain ≥ completed. - | Milestone | Jeff | Aditya | Luis | Hamza | Brent | Rui | Total | - |-----------|------|--------|------|-------|-------|-----|-------| - | M1 | 23/25 | 1/1 | 1/2 | 2/3 | 4/5 | 0/0 | 31/36 | - | M2 | 5/9 | 0/5 | 0/2 | 0/1 | 0/1 | 0/0 | 5/18 | - | M3 | 12/13 | 7/7 | 5/9 | 0/4 | 5/7 | 0/0 | 29/40 | - | M4 | 3/6 | 0/0 | 1/3 | 0/1 | 0/1 | 0/0 | 4/11 | - | M5 | 0/5 | 0/1 | 1/1 | 0/6 | 1/2 | 0/0 | 2/15 | - | M6 | 0/3 | 0/0 | 0/5 | 0/2 | 3/4 | 0/0 | 3/14 | - | M6+ | 0/1 | 0/0 | 0/7 | 0/7 | 0/1 | 0/1 | 0/17 | - | Total | 43/62 | 8/14 | 8/29 | 2/24 | 13/21 | 0/1 | 74/151 | - - -## Implementation Checklist - -This comprehensive checklist tracks all implementation tasks for the CleverAgents project. Each phase item includes mandatory **Code**, **Document**, and **Tests** bullets. Only mark the parent complete when every sub-bullet (including any spawned `Fix - ...` remediation tasks) is checked. - -**Organization**: This checklist is organized to enable parallel development and achieve a minimally working version as quickly as possible. Workstreams are clearly marked. Dependencies between workstreams are noted at merge points. - -> **CRITICAL PRIORITY DIRECTIVE (as of Day 14, 2026-02-22)**: -> The **M1 source-code MVP** is blocked by tool-aware execution and sandbox apply. The following tasks are the highest priority items across the entire project: -> -> 1. **M1.1** (Jeff) — Tool-calling actor runtime (execution actors) -> 2. **M1.2** (Jeff) — Plan execute wiring + ChangeSet capture via tool runtime -> 3. **M1.3** (Luis) — Sandbox merge/apply pipeline with validation gating hooks -> 4. **M1.4** (Hamza) — Resource handler runtime + tool/resource bindings -> 5. **M1.5** (Brent) — M1 end-to-end source-code smoke suite -> -> **Jeff MUST finish the actor runtime + plan execute wiring before M2.** -> -> **Aditya**: Prioritize hierarchical actor YAML configs + MCP/Agent Skills loaders (M2). -> -> **Luis**: Focus on apply pipeline now, then validation runner in M3. - -Execute all required tests through the appropriate `nox` sessions—never call `behave`, `robot`, or other runners directly. After touching **any** subtask, immediately add discoveries to the Notes section and update task descriptions. - -**Commit Ownership Rule**: Each **COMMIT** item has exactly one owner. Every subtask (Code/Docs/Tests/Quality/Commit) must list that same owner in brackets. If a subtask truly requires a different owner, split it into a separate **COMMIT** item under the appropriate parallel group. - -**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 Quality Ordering Rule**: The coverage verification task must appear immediately before the full `nox` run, and both must appear before any Git add/commit/push/PR steps. - -**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 (explicit command), `git add`, `git commit -m ""`, and `git push -u origin `. -- Do **not** list Git command tasks outside a **COMMIT** block; any Git command must be a child of the owning **COMMIT** item. -- Branches follow Gitflow naming: `feature/
-` (one branch per subtrack unless the subtrack explicitly states otherwise). -- **Merge policy**: merging from a feature branch into `master` is done in **Forgejo via PR only** (no CLI merge to master). -- **Push requirement**: include `git push -u origin ` in the COMMIT block to enable the PR. -- **PR requirement**: every branch with one or more commits must have a Forgejo PR task with an explicit description; merge happens in the Forgejo UI after CI + review. -- **Compatibility note**: If any existing subtrack still lists CLI merges (e.g., `git checkout master && git merge --no-ff feature/...`), replace with the Forgejo PR step above. - -### Day 14 Rebaseline Plan (ACTIVE) - -This section replaces all unfinished work items with the Day 14 plan. Work is organized by milestone and is the authoritative checklist from this point forward. - -#### M1: Minimal Local Source-Code Workflow (Target: Day 7, recovery path) -**Parallel Group M1: Tool-Aware Execute + Sandbox Apply** - -- [X] **COMMIT (Owner: Jeff | Group: M1.actor-runtime | Branch: feature/m1-actor-runtime | Planned: Day 14 | Expected: Day 16) - Commit message: "feat(actor): add tool-calling runtime for execution actors"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-actor-runtime` - - [X] Code [Jeff]: Add tool-calling loop that maps ToolRegistry specs to provider tool schemas and executes through ToolRunner with max-iteration safeguards. - - [X] Code [Jeff]: Capture tool call metadata (tool name, inputs, outputs, duration, success) into a structured record for downstream ChangeSet/decision usage. - - [X] Code [Jeff]: Thread sandbox root + resource bindings into tool inputs (default to plan/project resources). - - [X] Docs [Jeff]: Update `docs/reference/actor_runtime.md` with the tool-call loop and error semantics. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for tool-call loop, error handling, and max-iteration termination. - - [X] Tests (Robot) [Jeff]: Add Robot smoke test running `agents actor run` with a tool-calling actor against a temp repo. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/actor_runtime_bench.py` for tool-call loop overhead. - - [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 coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(actor): add tool-calling runtime for execution actors"` - - [X] Git [Jeff]: `git push -u origin feature/m1-actor-runtime` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-actor-runtime` to `master` with a suitable and thorough description (PR #141) - -- [X] **COMMIT (Owner: Jeff | Group: M1.plan-execute | Branch: feature/m1-plan-execute-runtime | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(plan): wire execute phase to actor runtime and changeset capture"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-plan-execute-runtime` - - [X] Code [Jeff]: Integrate PlanExecutor with strategy/execution actors using the new actor runtime and action-configured roles. - - [X] Code [Jeff]: Introduce a `PlanExecutionContext` that carries project resources, sandbox root, and automation profile for tool execution. - - [X] Code [Jeff]: Persist decision root IDs and ChangeSet IDs onto the plan, wiring ChangeSetStore for diff/artifacts. - - [X] Docs [Jeff]: Update `docs/reference/plan_execute.md` with tool-aware execute flow and metadata storage. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for plan execute lifecycle transitions and ChangeSet creation. - - [X] Tests (Robot) [Jeff]: Add Robot CLI test for `agents plan execute` with tool calls against a temp repo. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_execute_bench.py` for execute runtime baseline. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(plan): wire execute phase to actor runtime and changeset capture"` - - [X] Git [Jeff]: `git push -u origin feature/m1-plan-execute-runtime` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-execute-runtime` to `master` with a suitable and thorough description (PR #149) - -- [ ] **COMMIT (Owner: Hamza | Group: M1.resource-handlers | Branch: feature/m1-resource-handlers | Planned: Day 14 | Expected: Day 16) - Commit message: "feat(resource): add handler runtime for git-checkout and fs-directory"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m1-resource-handlers` - - [ ] Code [Hamza]: Define a resource handler protocol and implement `GitCheckoutHandler` + `FsDirectoryHandler` resolution of local paths. - - [ ] Code [Hamza]: Integrate sandbox manager to provide per-plan sandbox roots for git worktrees and copy-on-write paths. - - [ ] Code [Hamza]: Add resource binding helper to pass resource root into tool inputs consistently. - - [ ] Docs [Hamza]: Update `docs/reference/resource_handlers.md` with handler behavior and sandbox outputs. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for handler resolution and sandbox root creation. - - [ ] Tests (Robot) [Hamza]: Add Robot test covering resource handler + sandbox integration via CLI. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_handler_bench.py` for handler resolution overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add handler runtime for git-checkout and fs-directory"` - - [ ] Git [Hamza]: `git push -u origin feature/m1-resource-handlers` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m1-resource-handlers` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M1.apply-pipeline | Branch: feature/m1-apply-pipeline | Planned: Day 15 | Expected: Day 17) - Commit message: "feat(apply): merge sandbox changes into targets with conflict handling"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m1-apply-pipeline` - - [ ] Code [Luis]: Implement sandbox merge/apply pipeline for git worktree + copy-on-write strategies with conflict detection. - - [ ] Code [Luis]: Wire PlanApplyService to apply pipeline and record apply summaries (files changed, validations run). - - [ ] Code [Luis]: Add validation gating hook (skip if no validations attached; block on required failures). - - [ ] Docs [Luis]: Update `docs/reference/plan_apply.md` with apply pipeline and conflict outcomes. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add scenarios for apply success, conflict failure, and validation-gated apply. - - [ ] Tests (Robot) [Luis]: Add Robot CLI test covering `plan diff` + `plan apply` with sandbox merge. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/plan_apply_bench.py` for apply runtime baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(apply): merge sandbox changes into targets with conflict handling"` - - [ ] Git [Luis]: `git push -u origin feature/m1-apply-pipeline` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m1-apply-pipeline` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M1.e2e | Branch: feature/m1-e2e-sourcecode | Planned: Day 16 | Expected: Day 17) - Commit message: "test(e2e): add M1 source-code plan lifecycle suite"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m1-e2e-sourcecode` - - [ ] Code [Brent]: Add E2E fixtures for a minimal git repo and action config used in the M1 flow. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M1 source-code smoke run instructions. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m1_sourcecode_smoke.feature` covering action create, plan use, execute, diff, apply. - - [ ] Tests (Robot) [Brent]: Add Robot CLI smoke suite for M1 end-to-end flow. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m1_sourcecode_smoke_bench.py` for baseline runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M1 source-code plan lifecycle suite"` - - [ ] Git [Brent]: `git push -u origin feature/m1-e2e-sourcecode` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m1-e2e-sourcecode` to `master` with a suitable and thorough description - -#### M2: Actor Graphs + Tool Sources (Day 14) -**Parallel Group M2: Actor Configs + Tool Sources + LSP Stubs** - -**SEQUENTIAL ORDER**: M2.1 (hierarchical actor YAML) -> M2.2 (actor compiler/runtime) - -- [ ] **COMMIT (Owner: Aditya | Group: M2.1.actor-yaml | Branch: feature/m2-actor-yaml | Planned: Day 15 | Expected: Day 16) - Commit message: "feat(actor): extend hierarchical actor YAML schema and loader"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m2-actor-yaml` - - [ ] Code [Aditya]: Extend actor YAML schema to support hierarchical graphs (nodes, edges, subgraphs, entry/exit), per-node LSP bindings, and tool-source references. - - [ ] Code [Aditya]: Update actor loader validation errors with precise field paths and resolution hints. - - [ ] Docs [Aditya]: Update `docs/reference/actor_config.md` with hierarchical examples and error cases. - - [ ] Docs [Aditya]: Add/refresh `examples/actors/` hierarchical YAML samples. - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Aditya]: Add scenarios for graph validation (missing nodes, cycles, invalid edge refs, missing LSP bindings). - - [ ] Tests (Robot) [Aditya]: Add Robot smoke test loading hierarchical actor YAML via CLI. - - [ ] Tests (ASV) [Aditya]: Add `benchmarks/actor_yaml_bench.py` for schema load/validation overhead. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(actor): extend hierarchical actor YAML schema and loader"` - - [ ] Git [Aditya]: `git push -u origin feature/m2-actor-yaml` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m2-actor-yaml` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: M2.2.actor-compiler | Branch: feature/m3-actor-compiler | Planned: Day 16 | Expected: Day 17) - Commit message: "feat(actor): compile hierarchical actor configs to LangGraph"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-compiler` - - [ ] Code [Jeff]: Implement actor compiler to translate hierarchical YAML graphs into LangGraph StateGraph nodes/edges with LSP bindings. - - [ ] Code [Jeff]: Add actor reference/subgraph resolution with explicit validation errors for missing nodes or cycles. - - [ ] Code [Jeff]: Add runtime wiring so PlanExecutor can execute compiled actors using the tool runtime and the action-configured roles. - - [ ] Docs [Jeff]: Update `docs/reference/actor_compiler.md` with compilation pipeline, node binding, and error modes. - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Jeff]: Add scenarios for compile success/failure and node wiring validation. - - [ ] Tests (Robot) [Jeff]: Add Robot smoke test compiling and running a multi-node actor graph. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/actor_compiler_bench.py` for compile overhead. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(actor): compile hierarchical actor configs to LangGraph"` - - [ ] Git [Jeff]: `git push -u origin feature/m3-actor-compiler` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-compiler` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Aditya | Group: M2.3.mcp-runtime | Branch: feature/m3-mcp-adapter | Planned: Day 16 | Expected: Day 18) - 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` - - [ ] Code [Aditya]: Implement MCP adapter runtime to connect to servers, enumerate tools, and register them in ToolRegistry. - - [ ] Code [Aditya]: Add invocation path that validates tool inputs/outputs against MCP schema and surfaces errors consistently. - - [ ] Docs [Aditya]: Update `docs/reference/mcp_adapter.md` with runtime configuration, lifecycle, and error handling. - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Aditya]: Add scenarios for MCP tool discovery, invocation, and error mapping. - - [ ] Tests (Robot) [Aditya]: Add Robot integration test using a local MCP test server stub. - - [ ] Tests (ASV) [Aditya]: Add `benchmarks/mcp_runtime_bench.py` for adapter overhead. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(skill): add MCP adapter for external tools"` - - [ ] Git [Aditya]: `git push -u origin feature/m3-mcp-adapter` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-mcp-adapter` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Aditya | Group: M2.4a.agent-skills-loader | Branch: feature/m3-agent-skills-loader | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(skill): add agent skills loader"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m3-agent-skills-loader` - - [ ] Code [Aditya]: Add `AgentSkillSpec` loader that parses `SKILL.md` frontmatter + progressive disclosure sections into structured steps with stable ordering. - - [ ] Code [Aditya]: Map Agent Skills to Tool/Validation definitions with namespaced naming, resource binding slots, and read-only defaults. - - [ ] Code [Aditya]: Support `scripts/`, `references/`, and `assets/` folders with path normalization and safe read-only access rules. - - [ ] Docs [Aditya]: Add `docs/reference/agent_skills.md` describing folder layout, parsing rules, and tool mapping. - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Aditya]: Add scenarios for valid/invalid SKILL.md parsing, namespaced naming, and step ordering. - - [ ] Tests (Robot) [Aditya]: Add Robot test that loads a sample Agent Skills folder and verifies tool metadata. - - [ ] Tests (ASV) [Aditya]: Add `benchmarks/agent_skills_loader_bench.py` for parsing throughput. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(skill): add agent skills loader"` - - [ ] Git [Aditya]: `git push -u origin feature/m3-agent-skills-loader` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-agent-skills-loader` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: M2.4b.agent-skills-registry | Branch: feature/m3-agent-skills-registry | Planned: Day 17 | Expected: Day 18) - Commit message: "feat(skill): integrate agent skills discovery"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m3-agent-skills-registry` - - [ ] Code [Jeff]: Add config key `skills.agent_skills_paths` with default discovery path and allow multiple folders. - - [ ] Code [Jeff]: Register Agent Skills tools in ToolRegistry with `source=agent_skills` and include source metadata in `agents skill tools` output. - - [ ] Code [Jeff]: Add discovery refresh hook in SkillRegistryService and CLI `agents skill tools` to optionally re-scan Agent Skills paths. - - [ ] Docs [Jeff]: Update `docs/reference/skill_registry.md` and CLI reference with Agent Skills discovery behavior and output fields. - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Jeff]: Add scenarios for discovery, refresh, and source metadata rendering. - - [ ] Tests (Robot) [Jeff]: Add Robot CLI test that lists Agent Skills tools with source metadata. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/agent_skills_discovery_bench.py` for discovery overhead. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(skill): integrate agent skills discovery"` - - [ ] Git [Jeff]: `git push -u origin feature/m3-agent-skills-registry` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-agent-skills-registry` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M2.5.resource-registry | Branch: feature/m2-resource-registry | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(resource): add resource registry and DAG metadata"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m2-resource-registry` - - [ ] Code [Hamza]: Implement ResourceType and Resource registries with DAG parent/child constraints and discovery metadata. - - [ ] Code [Hamza]: Add local-mode discovery stubs and validation hooks for resource graph integrity. - - [ ] Docs [Hamza]: Update `docs/reference/resources.md` with registry fields and discovery behavior. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for registry validation, DAG constraints, and discovery defaults. - - [ ] Tests (Robot) [Hamza]: Add Robot test verifying resource registry CLI output. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/resource_registry_bench.py` for registry lookup overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add resource registry and DAG metadata"` - - [ ] Git [Hamza]: `git push -u origin feature/m2-resource-registry` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m2-resource-registry` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M2.6.changeset-persistence | Branch: feature/m2-changeset-persistence | Planned: Day 16 | Expected: Day 18) - Commit message: "feat(changeset): persist changesets and diff artifacts"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m2-changeset-persistence` - - [ ] Code [Luis]: Implement ChangeSet persistence with diff artifacts and tool invocation metadata. - - [ ] Code [Luis]: Wire ChangeSet retrieval into `plan diff` and `plan status` outputs. - - [ ] Docs [Luis]: Update `docs/reference/changeset.md` with persistence fields and diff output examples. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add scenarios for ChangeSet persistence, diff rendering, and missing artifact handling. - - [ ] Tests (Robot) [Luis]: Add Robot tests for ChangeSet retrieval via CLI. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/changeset_persistence_bench.py` for persistence overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(changeset): persist changesets and diff artifacts"` - - [ ] Git [Luis]: `git push -u origin feature/m2-changeset-persistence` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m2-changeset-persistence` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Jeff | Group: M2.7.lsp-stubs | Branch: feature/m2-lsp-stubs | Planned: Day 17 | Expected: Day 18) - Commit message: "feat(lsp): add registry and runtime stubs"** Done: 2026-02-22 - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m2-lsp-stubs` - - [X] Code [Jeff]: Add LSP registry models and a local-mode runtime stub (no server transport) per spec. - - [X] Code [Jeff]: Wire LSP registry lookups into actor compilation so node bindings are validated at compile time. - - [X] Docs [Jeff]: Update `docs/reference/lsp.md` with stub behavior and local-mode constraints. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for registry validation and missing LSP binding errors. - - [X] Tests (Robot) [Jeff]: Add Robot CLI test listing registered LSP bindings. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/lsp_registry_bench.py` for registry lookup overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(lsp): add registry and runtime stubs"` - - [X] Git [Jeff]: `git push -u origin feature/m2-lsp-stubs` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-lsp-stubs` to `master` with a suitable and thorough description - -**Parallel Group M2.8: Skill Registry Completion (Flattening + CLI + Refresh)** - **PARALLEL SUBTRACK SK1.core [Jeff]**: Flattened tool sets, includes, capability summary - **PARALLEL SUBTRACK SK2.persistence [Luis]**: Persistence extensions for flattened tools - **PARALLEL SUBTRACK SK3.cli [Aditya]**: CLI `skill tools/refresh` and output parity - **PARALLEL SUBTRACK SK4.refresh [Aditya]**: MCP refresh hooks and dynamic updates - **SEQUENTIAL MERGE NOTE**: SK2.persistence must land before SK1.core + SK3.cli to avoid schema mismatches; SK4.refresh depends on C7.mcp and can land after SK1.core. - -- [ ] **COMMIT (Owner: Jeff | Group: SK1.core | Branch: feature/m4-skill-registry-core | Planned: Day 18 | Expected: Day 26) - Commit message: "feat(skill): add registry flattening and capability summaries"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m4-skill-registry-core` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement skill flattening that resolves `includes`, named tool refs, and anonymous inline tools into a deterministic flattened list. - - [ ] Code [Jeff]: Detect include cycles and emit a clear error listing the cycle path (`skillA -> skillB -> skillA`). - - [ ] Code [Jeff]: Implement per-tool override merging (shallow merge) with explicit disallow list for non-overridable fields. - - [ ] Code [Jeff]: Compute capability summary (read/write/checkpointable/idempotent) for each skill from flattened tool metadata. - - [ ] Code [Jeff]: Add `SkillRegistry.tools(name)` and `SkillRegistry.validate_plan(plan)` to support actor activation and plan validation. - - [ ] Code [Jeff]: Add deterministic ordering for flattened tools (include order, then tool name). - - [ ] Code [Jeff]: Add error reporting that includes source file and line when overrides fail. - - [ ] Docs [Jeff]: Add `docs/reference/skill_registry.md` describing flattening rules, overrides, and validation errors. - - [ ] 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 `benchmarks/skill_flatten_bench.py` for flattening throughput. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(skill): add registry flattening and capability summaries"` - - [ ] Git [Jeff]: `git push -u origin feature/m4-skill-registry-core` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-skill-registry-core` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: SK2.persistence | Branch: feature/m4-skill-registry-db | Planned: Day 17 | Expected: Day 26) - Commit message: "feat(skill): persist flattened tool sets"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-skill-registry-db` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add migration fields/tables to store `flattened_tools_json`, `includes_json`, and `capability_summary_json` for each skill. - - [ ] Code [Luis]: Persist original skill YAML text and computed flattening hash for refresh invalidation. - - [ ] Code [Luis]: Extend SkillRepository to read/write flattened tool sets and invalidate cached summaries on update. - - [ ] Code [Luis]: Add uniqueness constraint for skill names and index on namespace for list filters. - - [ ] Code [Luis]: Add repository method to recompute flattening hash on update and store in DB. - - [ ] Docs [Luis]: Update `docs/reference/database_schema.md` with skill registry persistence fields. - - [ ] 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 `benchmarks/skill_registry_persist_bench.py` for persistence overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(skill): persist flattened tool sets"` - - [ ] Git [Luis]: `git push -u origin feature/m4-skill-registry-db` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-skill-registry-db` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Aditya | Group: SK3.cli | Branch: feature/m4-skill-registry-cli | Planned: Day 18 | Expected: Day 26) - Commit message: "feat(cli): add skill tools and refresh commands"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m4-skill-registry-cli` - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Aditya]: Add `agents skill tools ` to show flattened tool list and capability summary. - - [ ] Code [Aditya]: Add `agents skill refresh |--all` to recompute flattening and sync MCP-backed skills. - - [ ] Code [Aditya]: Update `skill list/show` output with includes, tool counts, and capability summary fields. - - [ ] Code [Aditya]: Add `--format json/yaml` output schema for tools/refresh output. - - [ ] Code [Aditya]: Add CLI errors for refresh when skill not found or MCP sync fails. - - [ ] Docs [Aditya]: Update CLI reference with skill tools/refresh examples and output columns. - - [ ] 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 `benchmarks/skill_cli_bench.py` for CLI overhead baseline. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(cli): add skill tools and refresh commands"` - - [ ] Git [Aditya]: `git push -u origin feature/m4-skill-registry-cli` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m4-skill-registry-cli` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Aditya | Group: SK4.refresh | Branch: feature/m4-skill-registry-refresh | Planned: Day 19 | Expected: Day 26) - Commit message: "feat(skill): add MCP refresh hooks"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m4-skill-registry-refresh` - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Aditya]: Implement `SkillRegistry.refresh(name)` and `refresh_all()` to recompute flattened tool sets on demand. - - [ ] Code [Aditya]: Wire MCP `notifications/tools/list_changed` to trigger skill refresh and registry cache invalidation. - - [ ] Code [Aditya]: Add safeguard to skip refresh when tool registry is unavailable; emit a single warning with recovery steps. - - [ ] Code [Aditya]: Add refresh debounce window to avoid repeated refresh storms from MCP notifications. - - [ ] Code [Aditya]: Add refresh result summary (skills refreshed, failures) for CLI output. - - [ ] Docs [Aditya]: Add `docs/reference/skill_refresh.md` with MCP refresh behavior and troubleshooting. - - [ ] 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 `benchmarks/skill_refresh_bench.py` for refresh overhead. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(skill): add MCP refresh hooks"` - - [ ] Git [Aditya]: `git push -u origin feature/m4-skill-registry-refresh` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m4-skill-registry-refresh` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M2.tests | Branch: feature/m2-actor-tool-smoke | Planned: Day 17 | Expected: Day 18) - Commit message: "test(e2e): add M2 actor + tool source smoke suite"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m2-actor-tool-smoke` - - [ ] Code [Brent]: Add fixtures for hierarchical actor YAML, MCP stub server, and skill packs. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M2 smoke suite usage. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m2_actor_tool_smoke.feature` covering actor compile, MCP tool invocation, and skill registry. - - [ ] Tests (Robot) [Brent]: Add Robot CLI smoke suite for actor compile + plan execute. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m2_smoke_bench.py` for suite runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M2 actor + tool source smoke suite"` - - [ ] Git [Brent]: `git push -u origin feature/m2-actor-tool-smoke` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m2-actor-tool-smoke` to `master` with a suitable and thorough description - -#### M3: Decisions + Validations + Invariants (Day 18) -**Parallel Group M3: Decision Tree + Validation Runner + Invariants** - -**SEQUENTIAL ORDER**: M3.1 -> M3.2 -> M3.3 (decision persistence before CLI explain/tree) - -- [ ] **COMMIT (Owner: Hamza | Group: M3.1.decision-domain | Branch: feature/m4-decision-domain | Planned: Day 19 | Expected: Day 20) - Commit message: "feat(decision): add decision domain and context snapshots"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-domain` - - [ ] Code [Hamza]: Implement decision domain model and context snapshot structures per spec. - - [ ] Docs [Hamza]: Update `docs/reference/decision_model.md` with decision fields and lifecycle. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for decision model validation and serialization. - - [ ] Tests (Robot) [Hamza]: Add Robot test for decision model persistence contract. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_model_bench.py` for model overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(decision): add decision domain and context snapshots"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-decision-domain` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-domain` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M3.2.decision-persistence | Branch: feature/m4-decision-persistence | Planned: Day 20 | Expected: Day 21) - Commit message: "feat(decision): add decision persistence"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-persistence` - - [ ] Code [Hamza]: Add decision tables, repositories, and migrations aligned to the decision domain model. - - [ ] Code [Hamza]: Add indexes for plan_id, decision_type, and superseded flags; ensure deterministic ordering for stored decision payloads. - - [ ] Code [Hamza]: Implement DecisionRepository + ContextSnapshotRepository with tree queries, superseded lookup, and ordered decision path retrieval. - - [ ] Docs [Hamza]: Update `docs/reference/database_schema.md` with decision tables. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for decision persistence, repository queries, and superseded retrieval. - - [ ] Tests (Robot) [Hamza]: Add Robot integration tests for decision persistence. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_persistence_bench.py` for repo overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(decision): add decision persistence"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-decision-persistence` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-persistence` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M3.2b.decision-service | Branch: feature/m4-decision-service | Planned: Day 22 | Expected: Day 26) - 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` - - [ ] Code [Hamza]: Implement `DecisionService` with record/list/tree helpers and snapshot storage. - - [ ] Docs [Hamza]: Add `docs/reference/decision_service.md` covering recording and snapshots. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add `features/decision_recording.feature` scenarios. - - [ ] Tests (Robot) [Hamza]: Add `robot/decision_recording.robot` integration smoke tests. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/decision_recording_bench.py` for record throughput. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(service): add decision recording and snapshot store"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-decision-service` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-service` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M3.2c.decision-di | Branch: feature/m4-decision-di | Planned: Day 26 | Expected: Day 26) - Commit message: "feat(di): wire decision services"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-decision-di` - - [ ] Code [Luis]: Wire decision repositories + services into DI and CLI. - - [ ] Code [Luis]: Inject DecisionService into PlanLifecycleService so strategize/execute can record decisions automatically. - - [ ] Docs [Luis]: Update DI docs for decision wiring. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add DI wiring scenarios for decision commands. - - [ ] Tests (Robot) [Luis]: Add CLI smoke test using persisted decisions. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/decision_di_bench.py` for DI resolution overhead. - - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(di): wire decision services"`. - - [ ] Git [Luis]: `git push -u origin feature/m4-decision-di` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-decision-di` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M3.3.plan-explain | Branch: feature/m4-decision-cli | Planned: Day 20 | Expected: Day 21) - Commit message: "feat(cli): add plan explain and decision tree outputs"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m4-decision-cli` - - [ ] Code [Hamza]: Add `plan explain` and `plan tree` CLI output with decision tree formatting (json/yaml/table) and flags for superseded/context/reasoning views. - - [ ] Docs [Hamza]: Update `docs/reference/plan_cli.md` with explain/tree examples. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for explain/tree output in multiple formats. - - [ ] Tests (Robot) [Hamza]: Add Robot CLI test for `plan explain` output fields. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/plan_explain_bench.py` for output generation. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(cli): add plan explain and decision tree outputs"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-decision-cli` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-decision-cli` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M3.4a.validation-pipeline | Branch: feature/m3-validation-pipeline | Planned: Day 21 | Expected: Day 22) - 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` - - [ ] Code [Luis]: Implement ValidationCommand, ValidationResult, and ValidationPipeline using Validation attachments from Tool Registry. - - [ ] Code [Luis]: Run validations at end of Execute phase only; do not re-run during Apply per spec. - - [ ] Code [Luis]: Enforce required vs informational validation modes and fix-then-revalidate loop hooks. - - [ ] Code [Luis]: Persist validation summary into Plan metadata for later review. - - [ ] Code [Luis]: Sort validations by (resource, mode, validation name) for deterministic execution order. - - [ ] Code [Luis]: Add per-validation timeout and capture stdout/stderr in ValidationResult for troubleshooting. - - [ ] Code [Luis]: Group validations by resource and cap parallel validation concurrency per resource type. - - [ ] Code [Luis]: Normalize validation output to `passed/message/data` schema even for tool errors. - - [ ] Code [Luis]: Add aggregation helper to compute counts (required_passed, required_failed, info_failed) for CLI display. - - [ ] Code [Luis]: Add guard to skip validations on read-only resources when validation requires write access (should never happen). - - [ ] Docs [Luis]: Add `docs/reference/validation_pipeline.md` with ordering, timeouts, and failure handling. - - [ ] Docs [Luis]: Document concurrency limits and output normalization rules. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] 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 `benchmarks/validation_pipeline_bench.py` for pipeline runtime. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(validation): add validation pipeline and results model"` - - [ ] Git [Luis]: `git push -u origin feature/m3-validation-pipeline` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-validation-pipeline` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M3.4.validation-runner | Branch: feature/m3-validation-apply | Planned: Day 20 | Expected: Day 22) - Commit message: "feat(validation): add validation runner and apply gating"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m3-validation-apply` - - [ ] Code [Luis]: Implement validation runner executing validation attachments and aggregating required/informational results. - - [ ] Code [Luis]: Support wrapped tool validations with transform mappings and consistent output schema normalization. - - [ ] Code [Luis]: Wire Apply pipeline gating to block on required validation failures and record summaries on the plan. - - [ ] Code [Luis]: Surface validation summary fields in `plan status`/`plan diff` outputs (required vs informational counts, failures). - - [ ] Docs [Luis]: Update `docs/reference/validation_runner.md` with lifecycle and result schema. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add scenarios for validation runner success/failure and required vs informational behavior. - - [ ] Tests (Robot) [Luis]: Add Robot test validating apply gating with required validations. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/validation_runner_bench.py` for runner overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(validation): add validation runner and apply gating"` - - [ ] Git [Luis]: `git push -u origin feature/m3-validation-apply` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-validation-apply` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Jeff | Group: M3.5.invariants | Branch: feature/m3-invariants | Planned: Day 21 | Expected: Day 22) - Commit message: "feat(invariant): add invariant models and enforcement"** Done: 2026-02-22 - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-invariants` - - [X] Code [Jeff]: Add invariant models, merge order (plan > project > action > global), and enforcement before strategize. - - [X] Code [Jeff]: Add Invariant Reconciliation Actor role and record `invariant_enforced` decisions. - - [X] Code [Jeff]: Add `agents invariant add/list/remove` CLI with scope flags and validation errors. - - [X] Docs [Jeff]: Add `docs/reference/invariants.md` with precedence and reconciliation examples. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add invariant merge + violation scenarios. - - [X] Tests (Robot) [Jeff]: Add invariant CLI integration tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/invariant_merge_bench.py` for merge overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(invariant): add invariant models and enforcement"` - - [X] Git [Jeff]: `git push -u origin feature/m3-invariants` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-invariants` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M3.6.definition-of-done | Branch: feature/m4-definition-of-done | Planned: Day 26 | Expected: Day 26) - Commit message: "feat(dod): enforce definition-of-done gating"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-definition-of-done` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Evaluate `definition_of_done` before apply; block apply with clear error if unmet. - - [ ] Code [Luis]: Ensure DoD templating uses plan arguments and preserves template in plan metadata. - - [ ] Code [Luis]: Add DoD evaluation hook to capture pass/fail reasoning and store in plan validation summary. - - [ ] Code [Luis]: Add DoD evaluator interface with a default text matcher implementation (regex/substring checks). - - [ ] Code [Luis]: Add CLI output in `plan status` showing DoD evaluation summary (passed/failed + message). - - [ ] Docs [Luis]: Add `docs/reference/definition_of_done.md` with examples. - - [ ] 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 `benchmarks/dod_evaluation_bench.py` for evaluation overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(dod): enforce definition-of-done gating"`. - - [ ] Git [Luis]: `git push -u origin feature/m4-definition-of-done` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-definition-of-done` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M3.tests | Branch: feature/m3-decision-validation-smoke | Planned: Day 21 | Expected: Day 22) - Commit message: "test(e2e): add M3 decision + validation suites"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m3-decision-validation-smoke` - - [ ] Code [Brent]: Add fixtures for decision tree outputs, validation attachments, and invariant configs. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M3 suite usage. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m3_decision_validation_smoke.feature` covering explain/tree, validation gating, and invariant enforcement. - - [ ] Tests (Robot) [Brent]: Add Robot integration suite for decision/validation CLI flows. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m3_smoke_bench.py` for suite runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M3 decision + validation suites"` - - [ ] Git [Brent]: `git push -u origin feature/m3-decision-validation-smoke` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m3-decision-validation-smoke` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M3.7.decision-tests | Branch: feature/m4-decision-tests | Planned: Day 27 | Expected: Day 27) - Commit message: "test(persistence): add decision persistence suites"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m4-decision-tests` - - [ ] Tests (Behave) [Brent]: Add `features/decision_persistence.feature` scenarios. - - [ ] Tests (Behave) [Brent]: Add scenarios for superseded decisions, correction attempts, and tree depth filtering. - - [ ] 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. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (ASV) [Brent]: Add `benchmarks/decision_persistence_bench.py` for DB persistence throughput. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(persistence): add decision persistence suites"`. - - [ ] Git [Brent]: `git push -u origin feature/m4-decision-tests` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m4-decision-tests` to `master` with a suitable and thorough description - -#### M4: Corrections + Subplans + Checkpoints (Day 22) -**Parallel Group M4: Correction Engine + Subplan Execution + Checkpoints** - -**SEQUENTIAL ORDER**: M4.1 (correction model) -> M4.2 (revert/append) -> M4.3 (subplan execution) - -- [X] **COMMIT (Owner: Jeff | Group: M4.1.correction-model | Branch: feature/m4-correction-model | Planned: Day 22 | Expected: Day 23) - Commit message: "feat(correction): add correction model and CLI hooks"** Done: 2026-02-22 - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m4-correction-model` - - [X] Code [Jeff]: Add correction models (correction request, target decision, reason, mode) and CLI scaffolding. - - [X] Docs [Jeff]: Add `docs/reference/decision_correction.md` with correction modes and command usage. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for correction request validation and CLI output. - - [X] Tests (Robot) [Jeff]: Add Robot test for `plan correct --dry-run` output. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/decision_correction_model_bench.py` for model overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(correction): add correction model and CLI hooks"` - - [X] Git [Jeff]: `git push -u origin feature/m4-correction-model` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-correction-model` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Jeff | Group: M4.2.correction-flows | Branch: feature/m4-correction-flows | Planned: Day 23 | Expected: Day 24) - Commit message: "feat(correction): implement revert and append flows"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m4-correction-flows` - - [X] Code [Jeff]: Implement correction impact analysis, dry-run report, and revert execution. - - [X] Code [Jeff]: Implement append corrections as new decision subtree with lineage and subplan spawning. - - [X] Docs [Jeff]: Extend correction docs for revert/append behavior and dry-run output. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add revert + append correction scenarios. - - [X] Tests (Robot) [Jeff]: Add correction integration tests with checkpoint rollback. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/decision_correction_bench.py` for correction overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(correction): implement revert and append flows"` - - [X] Git [Jeff]: `git push -u origin feature/m4-correction-flows` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-correction-flows` to `master` with a suitable and thorough description (PR #147) - -- [ ] **COMMIT (Owner: Hamza | Group: M4.3.checkpoints | Branch: feature/m4-checkpoints | Planned: Day 23 | Expected: Day 24) - Commit message: "feat(sandbox): add checkpoint and rollback hooks"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m4-checkpoints` - - [ ] Code [Hamza]: Add sandbox checkpoint/rollback hooks for plan execute/apply flows with metadata capture. - - [ ] Docs [Hamza]: Update `docs/reference/sandbox.md` with checkpoint lifecycle and rollback behavior. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for checkpoint creation and rollback on failure. - - [ ] Tests (Robot) [Hamza]: Add Robot test verifying rollback after failed apply. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/sandbox_checkpoint_bench.py` for checkpoint overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(sandbox): add checkpoint and rollback hooks"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-checkpoints` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-checkpoints` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M4.4.subplans | Branch: feature/m4-subplan-execution | Planned: Day 24 | Expected: Day 25) - Commit message: "feat(subplan): execute and merge subplans"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-subplan-execution` - - [ ] Code [Luis]: Implement subplan execution scheduler for sequential/parallel/dependency_ordered modes. - - [ ] Code [Luis]: Implement merge strategies (git three-way, sequential apply, fail on conflict, last wins) using sandbox outputs. - - [ ] Docs [Luis]: Update `docs/reference/subplans.md` with execution modes and merge outcomes. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add scenarios for parallel execution, conflict handling, and merge results. - - [ ] Tests (Robot) [Luis]: Add Robot test for subplan execution and merge summaries. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/subplan_execution_bench.py` for scheduler overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(subplan): execute and merge subplans"` - - [ ] Git [Luis]: `git push -u origin feature/m4-subplan-execution` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-subplan-execution` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: M4.5.phase-reversion | Branch: feature/m4-phase-reversion | Planned: Day 21 | Expected: Day 26) - Commit message: "feat(plan): add phase reversion state machine"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m4-phase-reversion` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement Execute-to-Strategize reversion in `PlanLifecycleService` when constraints are too restrictive (validation failures block apply and automation profile permits reversion). - - [ ] Code [Jeff]: Implement Apply-to-Strategize reversion from `constrained` terminal state, resetting phase to Strategize with preserved context and sandbox state. - - [ ] Code [Jeff]: Add `auto_reversion_from_apply` threshold check from the resolved `AutomationProfile` — only auto-revert if the profile's `auto_reversion_from_apply` flag is set. - - [ ] Code [Jeff]: Record each reversion as a `reversion` decision in the plan's decision tree with source phase, target phase, reason, and timestamp. - - [ ] Code [Jeff]: Wire reversion into `PlanLifecycleService` phase transition logic with explicit guard against infinite reversion loops (max 3 reversions per plan execution). - - [ ] Code [Jeff]: Add `plan revert --to-phase ` CLI command for manual reversion. - - [ ] Docs [Jeff]: Add `docs/reference/phase_reversion.md` documenting reversion triggers, automation profile thresholds, and loop guards. - - [ ] Tests (Behave) [Jeff]: Add `features/phase_reversion.feature` with scenarios for auto-reversion, manual reversion, loop guard, and profile-gated behavior. - - [ ] Tests (Robot) [Jeff]: Add `robot/phase_reversion.robot` for end-to-end reversion flow. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/phase_reversion_bench.py` for reversion overhead. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(plan): add phase reversion state machine"` - - [ ] Git [Jeff]: `git push -u origin feature/m4-phase-reversion` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-phase-reversion` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M4.6.error-recovery | Branch: feature/m4-error-recovery | Planned: Day 22 | Expected: Day 26) - Commit message: "feat(plan): add error recovery patterns and CLI hints"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-error-recovery` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Record `error_recovery` decision type in the decision tree during Execute phase failures, capturing error category, recovery action taken, and retry count. - - [ ] Code [Luis]: Add structured recovery hints to CLI error output (e.g., "use `agents plan prompt ` to resume", "use `agents plan revert --to-phase strategize` to restart strategy"). - - [ ] Code [Luis]: Wire retry/self-repair loop into Execute phase up to the configured retry limit from the automation profile (`max_retries` field). - - [ ] Code [Luis]: Add `plan errors ` CLI command that shows all error decisions with recovery hints and retry history. - - [ ] Code [Luis]: Capture structured error metadata (phase, actor, tool_call, stack_summary) into `error_details` JSON field on plan. - - [ ] Docs [Luis]: Add `docs/reference/error_recovery.md` documenting error categories, recovery patterns per phase, and retry behavior. - - [ ] Tests (Behave) [Luis]: Add `features/error_recovery.feature` with scenarios for retry exhaustion, recovery hint output, and error decision recording. - - [ ] Tests (Robot) [Luis]: Add `robot/error_recovery.robot` for end-to-end error and recovery flow. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/error_recovery_bench.py` for error handling overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(plan): add error recovery patterns and CLI hints"` - - [ ] Git [Luis]: `git push -u origin feature/m4-error-recovery` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-error-recovery` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M4.tests | Branch: feature/m4-correction-subplan-smoke | Planned: Day 24 | Expected: Day 25) - Commit message: "test(e2e): add M4 correction + subplan suites"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m4-correction-subplan-smoke` - - [ ] Code [Brent]: Add fixtures for correction flows, subplan execution, and conflict simulations. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M4 suite usage. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m4_correction_subplan_smoke.feature` covering correction flows and subplan merges. - - [ ] Tests (Robot) [Brent]: Add Robot integration suite for correction + subplan CLI flows. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m4_smoke_bench.py` for suite runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M4 correction + subplan suites"` - - [ ] Git [Brent]: `git push -u origin feature/m4-correction-subplan-smoke` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m4-correction-subplan-smoke` to `master` with a suitable and thorough description - -#### M5: ACMS v1 + Context Scaling (Day 26) -**Parallel Group M5: ACMS Pipeline + Context Indexing + Automation Profiles** - -- [ ] **COMMIT (Owner: Hamza | Group: M5.1.acms-context | Branch: feature/m5-acms-context | Planned: Day 26 | Expected: Day 28) - Commit message: "feat(acms): add ACMS v1 context pipeline"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m5-acms-context` - - [ ] Code [Hamza]: Implement ACMS v1 context assembly pipeline (UKO + CRP + fusion strategies) in local mode. - - [ ] Docs [Hamza]: Update `docs/reference/acms.md` with ACMS v1 pipeline overview. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for ACMS pipeline assembly and context output. - - [ ] Tests (Robot) [Hamza]: Add Robot tests validating ACMS pipeline in a sample project. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/acms_pipeline_bench.py` for pipeline overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(acms): add ACMS v1 context pipeline"` - - [ ] Git [Hamza]: `git push -u origin feature/m5-acms-context` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m5-acms-context` to `master` with a suitable and thorough description - -**Parallel Group M5b: ACMS Component Buildout (UKO + CRP + Strategy + Fusion + Scoped Views + Skeleton)** - -- [ ] **COMMIT (Owner: Hamza | Group: ACMS1.uko | Branch: feature/m6-acms-uko-schema | Planned: Day 26 | Expected: Day 31) - Commit message: "feat(uko): add UKO ontology scaffolding"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-uko-schema` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add UKO Layer 0-3 ontology skeleton (RDF/TTL) under `docs/ontology/uko.ttl` with version headers. - - [ ] Code [Hamza]: Define base URI, version IRI, and prefix conventions for layers and language-specific nodes. - - [ ] Code [Hamza]: Add minimal Layer 0 nodes (Resource, Artifact, CodeArtifact, Document) to allow end-to-end parsing. - - [ ] Code [Hamza]: Add Python loaders for UKO nodes (URI parsing, inheritance, versioning metadata). - - [ ] Code [Hamza]: Add a validation pass that rejects undefined prefixes and missing `rdf:type` for nodes. - - [ ] Code [Hamza]: Add ontology version registry (current version + supported versions) for future migrations. - - [ ] Code [Hamza]: Add unit helper to resolve layer inheritance (Layer 3 -> 2 -> 1 -> 0). - - [ ] Docs [Hamza]: Add `docs/reference/uko.md` describing layers, URI format, and extension points. - - [ ] 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 `benchmarks/uko_load_bench.py` for load throughput. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(uko): add UKO ontology scaffolding"` - - [ ] Git [Hamza]: `git push -u origin feature/m6-acms-uko-schema` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-uko-schema` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: ACMS2.crp | Branch: feature/m6-acms-crp-models | Planned: Day 27 | Expected: Day 31) - Commit message: "feat(acms): add context request protocol models"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-crp-models` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Add `ContextRequest`, `ContextFragment`, `DetailLevel`, and `ContextBudget` models with validation. - - [ ] Code [Jeff]: Add built-in `builtin/context` skill with tools `request_context`, `query_history`, and `get_context_budget` (stubbed to ACMS). - - [ ] Code [Jeff]: Add `ContextRequest` fields for `focus`, `breadth`, `depth`, `strategy`, `temporal_scope`, and `skeleton_ratio` with defaulting rules. - - [ ] Code [Jeff]: Add `ContextFragment` metadata (uko_uri, provenance, relevance_score, token_count, detail_level) and enforce token_count >= 0. - - [ ] Code [Jeff]: Add `DetailLevelMap` registry with name->integer resolution and inheritance support. - - [ ] Code [Jeff]: Add `ContextRequest` validation for invalid depth names and unknown strategies. - - [ ] Docs [Jeff]: Add `docs/reference/crp.md` with request fields, detail levels, and examples. - - [ ] 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 `benchmarks/crp_model_bench.py` for validation throughput. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(acms): add context request protocol models"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-acms-crp-models` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-crp-models` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: ACMS3.strategy | Branch: feature/m6-acms-strategy-registry | Planned: Day 27 | Expected: Day 31) - Commit message: "feat(acms): add context strategy registry"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-strategy-registry` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Define `ContextStrategy` interface and StrategyRegistry with plugin discovery. - - [ ] Code [Hamza]: Add stub strategies (keyword, semantic, graph, temporal) with feature flags and no-op defaults. - - [ ] Code [Hamza]: Add `ContextStrategyResult` model (fragments, stats, errors) with deterministic ordering. - - [ ] Code [Hamza]: Add configuration to enable/disable strategies per project context policy. - - [ ] Code [Hamza]: Add per-strategy timeout and max-fragment limits in registry config. - - [ ] Code [Hamza]: Add registry validation that strategies declare supported resource types. - - [ ] Docs [Hamza]: Add `docs/reference/context_strategies.md` with strategy contracts and outputs. - - [ ] 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 `benchmarks/context_strategy_bench.py` for registry lookup. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(acms): add context strategy registry"` - - [ ] Git [Hamza]: `git push -u origin feature/m6-acms-strategy-registry` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-strategy-registry` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: ACMS4.fusion | Branch: feature/m6-acms-fusion-engine | Planned: Day 28 | Expected: Day 31) - Commit message: "feat(acms): add strategy coordinator and fusion engine"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-fusion-engine` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement StrategyCoordinator with parallel execution and budget allocation. - - [ ] Code [Jeff]: Implement FusionEngine to dedupe fragments, resolve detail conflicts, and pack within budget. - - [ ] Code [Jeff]: Allocate budget proportionally by strategy confidence and enforce per-strategy max caps. - - [ ] Code [Jeff]: Add greedy knapsack packing with deterministic tie-breakers (relevance, detail level, token count). - - [ ] Code [Jeff]: Add fragment dedupe by UKO URI + hash of rendered text to avoid duplicates across strategies. - - [ ] Code [Jeff]: Add budget overage guard to drop lowest-relevance fragments and emit warnings. - - [ ] Docs [Jeff]: Add `docs/reference/acms_fusion.md` with flow diagrams and budget semantics. - - [ ] 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 `benchmarks/acms_fusion_bench.py` for fusion 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(acms): add strategy coordinator and fusion engine"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-acms-fusion-engine` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-fusion-engine` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: ACMS5.scoped | Branch: feature/m6-acms-scoped-view | Planned: Day 28 | Expected: Day 31) - Commit message: "feat(acms): add scoped backend view filtering"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m6-acms-scoped-view` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement ScopedBackendView that filters text/vector/graph queries to project resources. - - [ ] Code [Hamza]: Add enforcement hooks in context retrieval services and StrategyCoordinator. - - [ ] Code [Hamza]: Add allowlist/denylist resolution for resource scopes using project resource links and aliases. - - [ ] Code [Hamza]: Log and reject context requests that reference resources outside scope (security guard). - - [ ] Code [Hamza]: Add unit helper to resolve alias -> resource_id mapping and validate uniqueness. - - [ ] Code [Hamza]: Add guard for mixed project scopes (explicit error when request spans unlinked projects). - - [ ] Docs [Hamza]: Add `docs/reference/scoped_backend_view.md` with security guarantees. - - [ ] 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 `benchmarks/scoped_view_bench.py` for filter overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(acms): add scoped backend view filtering"` - - [ ] Git [Hamza]: `git push -u origin feature/m6-acms-scoped-view` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-acms-scoped-view` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: ACMS6.skeleton | Branch: feature/m6-acms-skeleton-compress | Planned: Day 29 | Expected: Day 31) - Commit message: "feat(acms): add skeleton compressor"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-acms-skeleton-compress` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement skeleton compressor that produces compressed inherited context with `skeleton_ratio`. - - [ ] Code [Jeff]: Integrate skeleton output into subplan context inheritance and strategy coordinator budgets. - - [ ] Code [Jeff]: Add stable ordering for compressed fragments to avoid non-deterministic context payloads. - - [ ] Code [Jeff]: Persist skeleton metadata (ratio, token counts, source decision IDs) for auditability. - - [ ] Code [Jeff]: Add `skeleton_ratio` validation (0.0-1.0) and default handling per plan. - - [ ] Code [Jeff]: Add compression summary (original tokens vs compressed tokens) stored in plan metadata. - - [ ] Docs [Jeff]: Add `docs/reference/skeleton_compressor.md` with ratios and examples. - - [ ] 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 `benchmarks/skeleton_compressor_bench.py` for compression overhead. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(acms): add skeleton compressor"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-acms-skeleton-compress` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-acms-skeleton-compress` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M5.2.context-indexing | Branch: feature/m4-context-indexing | Planned: Day 27 | Expected: Day 28) - Commit message: "feat(context): add repo indexing service"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m4-context-indexing` - - [ ] Code [Hamza]: Implement repository indexing for 10K+ file projects with incremental refresh and language detection. - - [ ] Code [Hamza]: Persist index metadata (resource_id, indexed_at, file_count, token_estimate) and per-file records with hashes. - - [ ] Code [Hamza]: Enforce include/exclude globs and max file/total size limits from project context policy. - - [ ] Docs [Hamza]: Update `docs/reference/context_indexing.md` with indexing modes, limits, and refresh behavior. - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Hamza]: Add scenarios for indexing large projects and tiered loading. - - [ ] Tests (Robot) [Hamza]: Add Robot tests for project show and indexing metrics. - - [ ] Tests (ASV) [Hamza]: Add `benchmarks/context_indexing_bench.py` for indexing overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(context): add repo indexing service"` - - [ ] Git [Hamza]: `git push -u origin feature/m4-context-indexing` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m4-context-indexing` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Jeff | Group: M5.3.automation-profiles | Branch: feature/m5-automation-profiles | Planned: Day 27 | Expected: Day 28) - Commit message: "feat(automation): add automation profiles and guards"** Done: 2026-02-22 - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m5-automation-profiles` - - [X] Code [Jeff]: Implement automation profiles and enforcement hooks (approval gates, max tool calls, allowlist/denylist). - - [X] Docs [Jeff]: Update `docs/reference/automation_profiles.md` with profile defaults and CLI usage. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for profile enforcement and override behavior. - - [X] Tests (Robot) [Jeff]: Add Robot tests for automation profile CLI flags. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/automation_profiles_bench.py` for guard overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(automation): add automation profiles and guards"` - - [X] Git [Jeff]: `git push -u origin feature/m5-automation-profiles` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m5-automation-profiles` to `master` with a suitable and thorough description - -**Parallel Group M5c: Subplan Expansion (Spawn Tooling + Service + Multi-Project)** - -- [ ] **COMMIT (Owner: Jeff | Group: M5c.subplan-service | Branch: feature/m5-subplan-service | Planned: Day 26 | Expected: Day 28) - Commit message: "feat(service): add subplan service and spawn workflow"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m5-subplan-service` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Add subplan service that builds child plans from DecisionService spawn entries and SubplanConfig. - - [ ] Code [Jeff]: Persist subplan spawn metadata (spawn_decision_id, parent/root plan ids, execution mode) for status output. - - [ ] Code [Jeff]: Add subplan spawn validation (resource scopes resolved, merge strategy defined, max_parallel bounds). - - [ ] Docs [Jeff]: Add `docs/reference/subplan_service.md` with spawn workflow and lifecycle. - - [ ] Tests (Behave) [Jeff]: Add scenarios for spawn workflow and invalid spawn payloads. - - [ ] Tests (Robot) [Jeff]: Add subplan spawn integration smoke tests. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/subplan_spawn_bench.py` for spawn throughput. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(service): add subplan service and spawn workflow"` - - [ ] Git [Jeff]: `git push -u origin feature/m5-subplan-service` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m5-subplan-service` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Aditya | Group: M5c.subplan-actor | Branch: feature/m5-subplan-actor | Planned: Day 26 | Expected: Day 28) - Commit message: "feat(actor): add plan_subplan tool and decision emission"** - - [ ] Git [Aditya]: `git checkout master` - - [ ] Git [Aditya]: `git pull origin master` - - [ ] Git [Aditya]: `git checkout -b feature/m5-subplan-actor` - - [ ] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Aditya]: Add `plan_subplan` tool to strategy actors and emit SUBPLAN_SPAWN decisions. - - [ ] Code [Aditya]: Support `parallel=true` to emit SUBPLAN_PARALLEL_SPAWN and include dependency list. - - [ ] Code [Aditya]: Include merge strategy, resource scope, and context view overrides in decision payload. - - [ ] Code [Aditya]: Validate that subplan tool payload includes at least one resource scope or project ref. - - [ ] Code [Aditya]: Add schema validation for `max_parallel`, `merge_strategy`, and dependency list in tool payload. - - [ ] Code [Aditya]: Add defaulting rules for omitted fields (inherit from action/plan; explicit override markers). - - [ ] Code [Aditya]: Emit decision rationale text with summary of why subplan was spawned (for explain output). - - [ ] Docs [Aditya]: Update actor YAML examples for subplan emission. - - [ ] 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 `benchmarks/subplan_actor_tool_bench.py` for tool invocation overhead. - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Aditya]: `git commit -m "feat(actor): add plan_subplan tool and decision emission"` - - [ ] Git [Aditya]: `git push -u origin feature/m5-subplan-actor` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m5-subplan-actor` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: M5c.multi-project | Branch: feature/m5-multi-project | Planned: Day 29 | Expected: Day 28) - Commit message: "feat(plan): add multi-project subplan support"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m5-multi-project` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Allow plans to target multiple projects with separate resource link contexts. - - [ ] Code [Hamza]: Ensure sandbox isolation and cross-project dependency resolution. - - [ ] Code [Hamza]: Add plan metadata to track project-specific ChangeSets and validation summaries. - - [ ] Code [Hamza]: Add project-scoped context view resolution so each subplan only sees its project resources. - - [ ] Code [Hamza]: Add `ProjectLink` alias resolution rules for multi-project plans (unique alias per plan). - - [ ] Code [Hamza]: Add CLI output for `plan status` to show per-project ChangeSet summaries. - - [ ] Code [Hamza]: Enforce that a plan cannot mix read-only and write-capable projects without explicit override. - - [ ] Docs [Hamza]: Add `docs/reference/multi_project_plans.md`. - - [ ] 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 `benchmarks/multi_project_bench.py` for multi-project overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(plan): add multi-project subplan support"` - - [ ] Git [Hamza]: `git push -u origin feature/m5-multi-project` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m5-multi-project` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M5.tests | Branch: feature/m5-acms-smoke | Planned: Day 28 | Expected: Day 28) - Commit message: "test(e2e): add M5 ACMS + context suites"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m5-acms-smoke` - - [ ] Code [Brent]: Add fixtures for ACMS pipeline outputs and large-project context cases. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M5 suite usage. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m5_acms_smoke.feature` covering ACMS pipeline and context indexing. - - [ ] Tests (Robot) [Brent]: Add Robot integration suite for ACMS + context CLI flows. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m5_smoke_bench.py` for suite runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M5 ACMS + context suites"` - - [ ] Git [Brent]: `git push -u origin feature/m5-acms-smoke` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m5-acms-smoke` to `master` with a suitable and thorough description - -#### M6: Autonomy Hardening + Server Stubs (Day 30) -**Parallel Group M6: ACP Stubs + Autonomy Guardrails + Final Acceptance** - -- [ ] **COMMIT (Owner: Luis | Group: M6.1.server-stubs | Branch: feature/m6-server-stubs | Planned: Day 29 | Expected: Day 30) - Commit message: "feat(interfaces): add server client stubs"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-server-stubs` - - [ ] Code [Luis]: Add protocol stubs for `ServerClient`, `RemoteExecutionClient`, and `AuthClient` with NotImplementedError. - - [ ] Code [Luis]: Add `ServerConnectionConfig` model (server_url, namespace, auth_token_ref, tls_verify) with validation. - - [ ] Code [Luis]: Add config keys (`core.server_url`, `core.server_namespace`, `core.server_tls_verify`) and load from config/env. - - [ ] Code [Luis]: Add `agents connect ` CLI stub that persists server_url and prints explicit stub warning. - - [ ] Code [Luis]: Add `agents info` output field for Server Mode: `disabled` vs `stubbed` (based on config). - - [ ] Docs [Luis]: Add `docs/reference/server_client_stubs.md` noting client-only behavior and config precedence. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add stub behavior scenarios and env var override/precedence checks. - - [ ] Tests (Robot) [Luis]: Add CLI stub smoke test. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/server_stub_bench.py` baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(interfaces): add server client stubs"` - - [ ] Git [Luis]: `git push -u origin feature/m6-server-stubs` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-server-stubs` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Jeff | Group: M6.2.acp-stubs | Branch: feature/m6-acp-stubs | Planned: Day 29 | Expected: Day 30) - Commit message: "feat(acp): add local facade and server stubs"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m6-acp-stubs` - - [X] Code [Jeff]: Add ACP boundary facade for local mode plus server-mode stubs returning NotImplemented for transport. - - [X] Docs [Jeff]: Update `docs/reference/acp.md` with local facade behavior and server stub limitations. - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Jeff]: Add scenarios for ACP facade routing to local services and stub errors for server mode. - - [X] Tests (Robot) [Jeff]: Add Robot CLI test for ACP facade usage. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/acp_facade_bench.py` for facade overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(acp): add local facade and server stubs"` - - [X] Git [Jeff]: `git push -u origin feature/m6-acp-stubs` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m6-acp-stubs` to `master` with a suitable and thorough description (PR #148) - -- [ ] **COMMIT (Owner: Jeff | Group: M6.4.lsp-stub | Branch: feature/m6-lsp-stub | Planned: Day 29 | Expected: Day 31) - Commit message: "feat(lsp): add LSP server stub"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-lsp-stub` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Add minimal LSP server entrypoint that supports initialize/shutdown and reports stubbed capability set. - - [ ] Code [Jeff]: Wire LSP requests to ACP facade (local mode) and return explicit "not implemented" responses for unsupported methods. - - [ ] Code [Jeff]: Add CLI command `agents lsp` to launch the stub server with logging and PID output. - - [ ] Docs [Jeff]: Add `docs/reference/lsp_stub.md` with usage notes and supported methods. - - [ ] Tests (Behave) [Jeff]: Add scenarios for LSP initialize/shutdown handshake and stub error responses. - - [ ] Tests (Robot) [Jeff]: Add Robot smoke test that launches the LSP stub and validates startup banner. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/lsp_stub_bench.py` for startup latency. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(lsp): add LSP server stub"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-lsp-stub` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-lsp-stub` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: M6.3.autonomy-guards | Branch: feature/m6-autonomy-guards | Planned: Day 29 | Expected: Day 30) - Commit message: "feat(automation): add autonomy guardrails and audit trail"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-autonomy-guards` - - [ ] Code [Luis]: Add autonomy guardrails (max steps, tool budget, required confirmations) and persist audit trail to plan metadata. - - [ ] Docs [Luis]: Update `docs/reference/automation_profiles.md` with audit trail fields and enforcement behavior. - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Luis]: Add scenarios for guardrail enforcement and audit trail recording. - - [ ] Tests (Robot) [Luis]: Add Robot test for autonomy guardrail CLI flags. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/autonomy_guardrails_bench.py` for enforcement overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(automation): add autonomy guardrails and audit trail"` - - [ ] Git [Luis]: `git push -u origin feature/m6-autonomy-guards` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-autonomy-guards` to `master` with a suitable and thorough description - -**Parallel Group M6b: Large Project Autonomy (Decomposition + Checkpoints + Semantic Validation + Context Tiers + Estimation + CLI Polish)** - -- [ ] **COMMIT (Owner: Jeff | Group: G1.decompose | Branch: feature/m6-large-decompose | Planned: Day 26 | Expected: Day 31) - Commit message: "feat(plan): add large-project decomposition and dependency closure"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-large-decompose` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Add hierarchical decomposition with 4+ levels and bounded context per subplan. - - [ ] Code [Jeff]: Implement decomposition heuristics (max_files_per_subplan, max_tokens_per_subplan, language/dir clustering). - - [ ] Code [Jeff]: Add dependency closure computation for large graphs and DAG execution ordering. - - [ ] Code [Jeff]: Add bounded dependency closure with cutoff thresholds and memoization for 10K+ files. - - [ ] Code [Jeff]: Record decomposition decisions in DecisionService (strategy_choice + subplan_spawn entries). - - [ ] Code [Jeff]: Add fallback decomposition strategy when heuristics fail (single subplan with warning). - - [ ] Code [Jeff]: Add config keys in Settings for `planner.max_depth`, `planner.max_files_per_subplan`, `planner.max_tokens_per_subplan`, `planner.min_files_per_subplan` with defaults. - - [ ] Code [Jeff]: Add deterministic clustering order (directory depth, language priority, file size) to make decomposition stable. - - [ ] Code [Jeff]: Add decomposition summary metrics (subplan count, max depth, avg size) stored in plan metadata. - - [ ] Code [Jeff]: Add guard to avoid spawning subplans when project is below threshold; default to single plan. - - [ ] Docs [Jeff]: Add `docs/reference/large_project_decomposition.md`. - - [ ] 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 `benchmarks/large_project_decompose_bench.py` for decomposition 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(plan): add large-project decomposition and dependency closure"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-large-decompose` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-large-decompose` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: G2.checkpoint | Branch: feature/m6-checkpoint | Planned: Day 27 | Expected: Day 31) - Commit message: "feat(checkpoint): add checkpointing and rollback"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-checkpoint` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add checkpoint declarations for tools and plan-level rollback policy. - - [ ] Code [Luis]: Add `checkpoints` table (checkpoint_id ULID, plan_id, sandbox_ref, created_at, metadata_json). - - [ ] Code [Luis]: Implement `plan rollback ` command. - - [ ] Code [Luis]: Implement git-worktree checkpoint snapshots (commit hash or patch) and rollback restore. - - [ ] Code [Luis]: Wire rollback into decision correction revert flow for reuse. - - [ ] Code [Luis]: Add checkpoint retention policy (max checkpoints per plan) with auto-prune on new checkpoints. - - [ ] Code [Luis]: Store checkpoint reason/source (tool name, phase) in metadata for auditability. - - [ ] Code [Luis]: Add CLI output to `plan rollback` showing restored file counts and changed paths. - - [ ] Code [Luis]: Add guard preventing rollback when plan is applied or sandbox is missing. - - [ ] Docs [Luis]: Add `docs/reference/checkpointing.md`. - - [ ] 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 `benchmarks/checkpoint_rollback_bench.py` for rollback latency. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(checkpoint): add checkpointing and rollback"` - - [ ] Git [Luis]: `git push -u origin feature/m6-checkpoint` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-checkpoint` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: G3.semantic | Branch: feature/m6-semantic-validation | Planned: Day 27 | Expected: Day 31) - Commit message: "feat(validation): add semantic validation service"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-semantic-validation` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add semantic validation hooks during strategize/execute and error-pattern checks. - - [ ] Code [Luis]: Add built-in semantic checks for syntax errors, missing imports, and broken references for Python projects. - - [ ] Code [Luis]: Expose semantic validation as Validation tools so they can be attached per resource. - - [ ] Code [Luis]: Add rule registry for semantic validators (dependency cycles, API misuse, missing symbols). - - [ ] Code [Luis]: Integrate semantic validation results into ValidationPipeline as informational by default. - - [ ] Code [Luis]: Add config keys for enabling/disabling semantic validation per project and per plan (default on for Python). - - [ ] Code [Luis]: Add severity mapping (info/warn/error) and map required vs informational behavior. - - [ ] Code [Luis]: Add output schema normalization so validations return `passed`, `message`, and `data` fields consistently. - - [ ] Code [Luis]: Add caching for semantic checks keyed by file hash to avoid rework on unchanged files. - - [ ] Docs [Luis]: Add `docs/reference/semantic_validation.md`. - - [ ] 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 `benchmarks/semantic_validation_bench.py` for validation cost. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(validation): add semantic validation service"` - - [ ] Git [Luis]: `git push -u origin feature/m6-semantic-validation` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-semantic-validation` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: G4.context | Branch: feature/m6-context-tiers | Planned: Day 28 | Expected: Day 31) - Commit message: "feat(context): add hot/warm/cold tiers and actor views"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m6-context-tiers` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Implement hot/warm/cold tiers with indexing, LRU eviction, and promotion/demotion. - - [ ] Code [Hamza]: Add tier storage backends (in-memory hot, sqlite warm, file-backed cold). - - [ ] Code [Hamza]: Add per-actor context views (strategist/executor/reviewer) and filtered presentation. - - [ ] Code [Hamza]: Add summarization hook when demoting to cold tier. - - [ ] Code [Hamza]: Enforce project-scoped filtering (ScopedBackendView) so actors never see resources outside the plan's project set. - - [ ] Code [Hamza]: Add `skeleton_ratio` support to cap inherited context size for subplans. - - [ ] Code [Hamza]: Add tier budget settings (max_tokens_hot, max_decisions_warm, max_decisions_cold) and defaults per project. - - [ ] Code [Hamza]: Add deterministic ordering for tier retrieval (most-recent-first with stable tie-breakers). - - [ ] Code [Hamza]: Add cold-tier compaction job to merge adjacent summaries and cap file size. - - [ ] Code [Hamza]: Add metrics for tier hit/miss counts and expose via `agents diagnostics`. - - [ ] Docs [Hamza]: Add `docs/reference/context_tiers.md`. - - [ ] 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 `benchmarks/context_tiers_bench.py` for tier lookup performance. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(context): add hot/warm/cold tiers and actor views"` - - [ ] Git [Hamza]: `git push -u origin feature/m6-context-tiers` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-context-tiers` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: G5.estimate | Branch: feature/m6-estimation | Planned: Day 28 | Expected: Day 31) - Commit message: "feat(estimation): add cost and risk estimation actor"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m6-estimation` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add optional `estimation_actor` role and cost/risk estimation outputs. - - [ ] Code [Hamza]: Persist estimation output to plan metadata (cost_estimate, risk_score, duration_estimate). - - [ ] Code [Hamza]: Invoke estimation during `plan use` and surface estimates in `plan status` output. - - [ ] Code [Hamza]: Add estimation output schema with currency, token estimates, and confidence ranges. - - [ ] Code [Hamza]: Add opt-out flag `--no-estimate` for `plan use` and persist `estimate_skipped` reason. - - [ ] Code [Hamza]: Add error handling when estimation actor fails (fallback to informational warning). - - [ ] Docs [Hamza]: Add `docs/reference/estimation.md` with output format. - - [ ] 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 `benchmarks/estimation_actor_bench.py` for estimation runtime. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(estimation): add cost and risk estimation actor"` - - [ ] Git [Hamza]: `git push -u origin feature/m6-estimation` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m6-estimation` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: G6.cli | Branch: feature/m6-cli-polish | Planned: Day 29 | Expected: Day 31) - Commit message: "chore(cli): polish help and output"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m6-cli-polish` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Standardize help text, progress indicators, and error messages with recovery hints. - - [ ] Code [Jeff]: Ensure `--format` outputs are consistent (rich/color/table/plain/json/yaml) across core commands. - - [ ] Code [Jeff]: Ensure `plain` format uses ASCII-only output to support log pipelines. - - [ ] Code [Jeff]: Add stable column names and ordering for list commands (`action list`, `plan list`, `project list`, `resource list`). - - [ ] Code [Jeff]: Add `--format json/yaml` schema docs and align field names across commands. - - [ ] Code [Jeff]: Add unified error envelope for JSON/YAML outputs (`error.code`, `error.message`, `error.details`). - - [ ] Docs [Jeff]: Update CLI output examples where needed. - - [ ] 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 `benchmarks/cli_render_bench.py` for output rendering overhead. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "chore(cli): polish help and output"` - - [ ] Git [Jeff]: `git push -u origin feature/m6-cli-polish` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m6-cli-polish` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: M6.tests | Branch: feature/m6-autonomy-smoke | Planned: Day 30 | Expected: Day 30) - Commit message: "test(e2e): add M6 autonomy acceptance suite"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/m6-autonomy-smoke` - - [ ] Code [Brent]: Add fixtures for ACP facade flows and autonomy guardrails. - - [ ] Docs [Brent]: Update `docs/development/testing.md` with M6 acceptance suite usage. - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add `features/m6_autonomy_acceptance.feature` covering ACP facade, guardrails, and full local mode flow. - - [ ] Tests (Robot) [Brent]: Add Robot integration suite for M6 acceptance run. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/m6_acceptance_bench.py` for runtime. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(e2e): add M6 autonomy acceptance suite"` - - [ ] Git [Brent]: `git push -u origin feature/m6-autonomy-smoke` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m6-autonomy-smoke` to `master` with a suitable and thorough description - -### Section 0: Quality Automation Setup [WORKSTREAM Q - Brent Lead] - -**Target: Days 0-3 (Minimum gates before merges; advanced gates after M1)** - -**Parallelization rules**: -- Minimum gating (pre-commit + CI + coverage enforcement) is a merge blocker; it can run in parallel with Week 1 coding but must land before any feature branches merge. -- Advanced automation (complexity metrics, dashboards, extended security scanning) is deferred until after M1 to avoid blocking the MVP. - -**Parallel Group Q0-Minimum Gates [Brent - blocks merges]** - -- [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` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add `pre-commit>=3.6.0` to `pyproject.toml` dev dependencies and ensure it is included in the `dev` extra. - - [X] Code [Brent]: Create `.pre-commit-config.yaml` pinned to specific hook versions; include `ruff format`, `ruff check`, `pyright`, `check-merge-conflict`, `end-of-file-fixer`, `trailing-whitespace`. - - [X] Code [Brent]: Add `pyrightconfig.json` validation to pre-commit (hook that fails if config missing or invalid). - - [X] Code [Brent]: Add/confirm `nox -s lint` session that runs Ruff + pyright using project settings; ensure session exits non-zero on warnings. - - [X] Code [Brent]: Add/confirm `nox -s format` session for Ruff formatting and align it with pre-commit `ruff format` behavior. - - [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 `benchmarks/precommit_config_bench.py` to benchmark config parsing and hook list extraction. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "feat(qa): add pre-commit baseline hooks"`. - - [X] Forgejo PR [Brent]: Open PR from `feature/q0-min-precommit` to `master`, wait for CI + review, merge in UI (no CLI merge) - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/q0-min-precommit` - - [X] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. - -- [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. - - [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] Git [Brent]: `git commit -m "feat(ci): add nox-based PR validation workflow"`. - - [X] Forgejo PR [Brent]: Open PR from `feature/q0-min-ci` to `master`, wait for CI + review, merge in UI (no CLI merge) - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/q0-min-ci` - - [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) - -- [X] **COMMIT (Owner: Brent | Group: Q0-Minimum | Branch: feature/q0-min-coverage | Done: Day 5, February 13, 2026 18:54:15 +0000) - 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) - skipped (SSH key unavailable in CI, already on latest master) - - [X] Code [Brent]: Ensure `nox -s coverage_report` fails below 97% and emits a single-line error message suitable for CI parsing. (COVERAGE_THRESHOLD constant + session.error with CI-parseable summary) - - [X] Code [Brent]: Update CI summary output (or job annotations) to surface the 97% threshold failure line clearly. (added "Surface coverage summary" step in CI that reads build/coverage.json) - - [X] Docs [Brent]: Update `docs/development/testing.md` with the 97% coverage requirement and a sample failure output. (created docs/development/testing.md with full testing guide) - - [X] Tests (Behave) [Brent]: Add a scenario that parses coverage config and asserts threshold >=97%. (features/coverage_threshold_enforcement.feature, 11 scenarios) - - [X] Tests (Robot) [Brent]: Add a Robot test that runs `nox -s coverage_report` and asserts pass/fail behavior. (robot/coverage_threshold.robot, 6 test cases) - - [X] Tests (ASV) [Brent]: Add `benchmarks/coverage_report_bench.py` for coverage report runtime baseline. (benchmarks/coverage_report_bench.py, 4 benchmarks) - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). (lint 0 findings, typecheck 0 errors, 2235 unit scenarios passed, 211 integration tests passed) - - [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`. (97.5% coverage, threshold 97%) - -**Parallel Group Q0-Advanced Gates [Brent - AFTER M1]** - -No standalone Q0-Advanced commits planned. Advanced QA enhancements are bundled with feature commits to minimize overhead during M1-M3. - ---- - -### Section 1: Completed Foundation (Phases 0-1) [PRESERVED] - -- [X] Phase 0: Discovery and Requirements Elaboration - - [X] Code: Implement Python discovery tooling for CLI, server, data contracts, supporting assets, environment variables, implicit behaviors, and parity matrix generation. - - [X] Document: Append findings, scripts, and open questions to **Phase 0 Notes** with `file_path:line_number` references. - - [X] Tests: Run Behave discovery scenarios and Robot smoke suites covering the generated artifacts. - -- [X] Phase 1: Architecture Definition - - [X] Code: Produce ADR stubs, module scaffolding, coding standard configurations, and packaging setup. - - [X] ADR-001: Python Package Layering and Module Boundaries - - [X] ADR-002: Asyncio Concurrency Model - - [X] ADR-003: Dependency Injection Framework - - [X] ADR-004: Pydantic for Data Validation - - [X] ADR-005: Error Handling Hierarchy - - [X] ADR-006: CLEVERAGENTS Environment Variables - - [X] ADR-007: Repository Pattern for Persistence - - [X] ADR-008: Provider Plugin Architecture - - [X] ADR-009: CLI Framework Selection - - [X] ADR-010: Logging and Observability - - [X] Document: Update **Phase 1 Notes** with ADR locations, dependency policies, and style guides. - - [X] Tests: Execute Ruff, pyright, Behave architecture scenarios, and Robot lint pipelines. - ---- - -### Section 2: Preserved Work from Previous Implementation [PRESERVED] - -- [X] LangChain/LangGraph Foundation - - [X] Dependencies installed (langchain, langgraph, langsmith, etc.) - - [X] ADR-011: LangChain/LangGraph Integration Patterns - - [X] Base StateGraph classes (BaseAgent, BaseStateGraph) - - [X] LangChain mock provider (FakeListLLM) - -- [X] Core LangGraph Workflows - - [X] PlanGenerationGraph (load_context -> analyze_requirements -> generate_plan -> validate) - - [X] ContextAnalysisAgent (5-node workflow for context analysis) - - [X] AutoDebugGraph (analyze_error -> generate_fix -> validate_fix -> apply_fix) - - [X] Memory service with EntityMemory - - [X] CLI streaming integration - -- [X] Provider Integration - - [X] Provider registry - - [X] OpenAI, Anthropic, Google, OpenRouter adapters - - [X] LangSmith observability - -- [X] Actor System (Stage 7.5) - - [X] Actor domain model with config hashing - - [X] Actor persistence (database, repository) - - [X] Actor registry (built-ins from provider registry) - - [X] Actor CLI commands (add, update, remove, list, show) - - [X] Actor-first plan/chat commands (--actor flag) - - [X] v2 format compatibility for actor configs - ---- - -### Section 2B: Commit Traceability Fixups [IMMEDIATE] - -- [X] Traceability [Aditya]: Found commit "docs(skill): add skill YAML schema and examples" (2026-02-16T19:52:47+05:30); updated C0.skill.schema Done/commit message to match. -- [X] Traceability [Aditya]: Found commit "feat(cli): add skill commands" (2026-02-17T14:44:40+00:00); updated C0.skill.cli Done/commit message to match. -- [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. -- [X] Traceability [Aditya]: Found commit "Feat: Harden actor configuration handling with unsafe confirmations, graph descriptors, and actor-based plan coverage." (2025-12-23T20:57:14-0500); updated C3.builtins Done/commit message to match. -- [X] Traceability [Aditya]: Found commit "feat(tool): add tool and validation domain models" (2026-02-13T21:41:16+00:00); updated C4.config Done/commit message to match. -- [X] Traceability [Jeff]: No matching commit in local refs for "feat(actor): compile actor YAML to runtime graphs" (`git log --all`); reset C3.compiler COMMIT to pending with Planned/Expected until SHA is provided. -- [X] Traceability [Jeff]: No matching commit in local refs for "feat(tool): add MCP adapter runtime" (`git log --all`); reset C4.adapter COMMIT to pending with Planned/Expected until SHA is provided. -- [X] Traceability [Luis]: No matching commit in local refs for "feat(skill): add skill registry persistence" (`git log --all`); reset C0.skill.registry COMMIT to pending with Planned/Expected until SHA is provided. -- [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)** - -#### Section 3 Notes - -- 2026-02-13: A2b.beta (plan model alignment) completed on `feature/m1-plan-model`. Rebased onto A2b.alpha (`fd6d41b`), resolved 30 merge conflicts. Key decisions: `processing_state` field name (not `state`), `InvariantSource` enum (not `InvariantScope`), `project_links` (not `project_ids`), HEAD's `action.py` authoritative. All tests green: 130 Behave features (2246 scenarios), 206 Robot tests, plan.py 100% coverage. See Development Log entry for full details. -- 2026-02-13: New test artifacts created for plan model coverage: `features/plan_model_coverage.feature` (39 scenarios), `features/steps/plan_model_coverage_steps.py` (489 lines), `benchmarks/plan_model_bench.py` (15 benchmarks), `docs/reference/plan_model.md` (~270 lines). -- 2026-02-13: Robot integration test fixes applied post-rebase: `robot/helper_plan_lifecycle_v3.py` (missing `description` param), `robot/helper_db_lifecycle_models.py` (`state=` → `processing_state=`, `project_names` → `project_links`). - -**WEEK 1 - CRITICAL PATH** - -- [X] **Stage A1: Plan Data Model** (Day 1) - COMPLETED 2026-02-05 - - [X] Code: Create Plan domain model - - [X] Define `Plan` Pydantic model with fields (plan_id ULID, parent_plan_id, root_plan_id, attempt counter, phase, state, timestamps) - - [X] Define `PlanPhase` enum (Action, Strategize, Execute, Apply, Applied) - - [X] Define `PlanState` enum per phase (available, draft, archived, queued, processing, errored, complete, cancelled) - - [X] Add namespace support to plan naming (`[server:][namespace/]`) - - [X] Location: `src/cleveragents/domain/models/core/plan.py` - - [X] Tests: Behave scenarios for plan model validation, phase/state transitions (30 scenarios in `features/plan_model.feature`) - -- [X] **Stage A2: Action Model** (Day 1) - COMPLETED 2026-02-05 - - [X] Code: Create Action domain model - - [X] Define `Action` Pydantic model (name, description, definition_of_done, strategy_actor, execution_actor, inputs_schema, reusable, read_only) - - [X] Add argument parsing for action parameters (`--arg name:type:required|optional:description`) - - [X] Location: `src/cleveragents/domain/models/core/action.py` - - [X] Tests: Behave scenarios for action model validation (22 scenarios in `features/action_model.feature`) - - [X] **A2.1** [Luis] Extend Action model with additional fields (follow-up): - - [X] Field `estimation_actor: str | None` - optional actor for cost/risk estimation (already present at `action.py:219`) - - [X] Field `review_actor: str | None` - optional actor for code review (already present at `action.py:211`) - - **Parallel Group A2b: Action/Plan Spec Rebaseline (M1-critical)** - **PARALLEL SUBTRACK A2b.alpha [Jeff]**: Action model alignment + YAML-first semantics - **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 | 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` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Update `src/cleveragents/domain/models/core/action.py` to remove `action_id` and make the namespaced name the unique identifier. - - [X] Code [Jeff]: Replace `short_description` with required `description`, keep optional `long_description`, and preserve stable serialization order. - - [X] Code [Jeff]: Align `ActionState` to `available`/`archived` only; default to `available` and remove draft-only behavior. - - [X] Code [Jeff]: Add optional `automation_profile`, `invariant_actor`, and `invariants` list with trimming, de-dup, and blank rejection. - - [X] Code [Jeff]: Add optional `review_actor`, `apply_actor`, and `estimation_actor` fields with namespaced validation. - - [X] Code [Jeff]: Add optional `inputs_schema` (JSON Schema dict) with JSON-serializable validation. - - [X] Code [Jeff]: Align `ActionArgument` types to spec (`string`, `integer`, `float`, `boolean`, `list`) and update coercion mapping. - - [X] Code [Jeff]: Add `ActionArgument.from_mapping()` for YAML and `ActionArgument.coerce_value()` for CLI `--arg` inputs. - - [X] Code [Jeff]: Add `Action.from_config()` and `Action.as_cli_dict()` for YAML-first parsing and stable CLI rendering. - - [X] Code [Jeff]: Add templating helper for `description`/`definition_of_done` with missing placeholder errors. - - [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 `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] 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] 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` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit). NOTE: Rebased onto `fd6d41b` (A2b.alpha) with 30 merge conflict resolutions. - - [X] Code [Luis]: Remove Action phase from `PlanPhase`; align lifecycle to strategize/execute/apply/applied. - - [X] Code [Luis]: Replace `action_state` with `processing_state` only; enforce phase/state consistency per spec. Field is `processing_state` with `@property def state` alias. - - [X] Code [Luis]: Add `action_name` (namespaced) and remove `action_id` usage throughout plan model. - - [X] Code [Luis]: Replace `project_ids` with `project_links` (name, alias, read_only) and enforce alias uniqueness. - - [X] Code [Luis]: Add `automation_profile` with provenance tags (plan/action/project/global) and lock after creation. Uses `AutomationProfileRef` model. - - [X] Code [Luis]: Add `invariants` list with source tags and stable ordering for CLI rendering. Uses `InvariantSource` enum (not `InvariantScope`). - - [X] Code [Luis]: Add `arguments` map + `arguments_order`, and persist rendered `description`/`definition_of_done` at plan creation. - - [X] Code [Luis]: Add `changeset_id`, `sandbox_refs`, `validation_summary`, `decision_root_id`, `error_message`, `error_details` placeholders. - - [X] Code [Luis]: Add `Plan.as_cli_dict()` for stable output and `ProjectLink.validate_alias()` helper. - - [X] Docs [Luis]: Update `docs/reference/plan_model.md` with phase/state semantics and linkage fields (~270 lines). - - [X] Tests (Behave) [Luis]: Add scenarios for phase transitions, automation profile provenance, invariant ordering, and project link alias errors. Created `features/plan_model_coverage.feature` (39 scenarios) + `features/steps/plan_model_coverage_steps.py` (489 lines). Total: 75 plan model scenarios (36 in `plan_model.feature` + 39 in `plan_model_coverage.feature`). - - [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] 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) - - [X] Fix - `plan_lifecycle_commands_coverage_steps.py:58` passed `state=ProcessingState(state)` instead of `processing_state=` to Plan constructor (Pydantic silently ignored unknown kwarg, defaulting to QUEUED). Fixed 4 failing auto-select scenarios. - - [X] Fix - `robot/helper_plan_lifecycle_v3.py:672` missing required `description` param in `create_action()` call (A2b.alpha renamed `short_description` → `description`) - - [X] Fix - `robot/helper_db_lifecycle_models.py`: `state=` → `processing_state=` in 3 Plan constructors (lines 135, 213, 239) and `project_names` → `project_links` (line 177) - - [X] Git [Luis]: `git add .` - - [X] Git [Luis]: `git commit -m "feat(domain): align plan model with spec"` - - [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] 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` - - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Docs [Aditya]: Author `docs/schema/action.schema.yaml` with required fields, versioning, and namespaced name validation. - - [X] Docs [Aditya]: Add schema blocks for arguments, invariants, automation_profile, inputs_schema, and optional actor refs. - - [X] Docs [Aditya]: Add action examples under `examples/actions/` (minimal, invariant-heavy, read-only, estimation-actor, inputs_schema). - - [X] Code [Aditya]: Add schema validation helper in `src/cleveragents/action/schema.py` (YAML load + schema validate + env var interpolation). - - [X] Code [Aditya]: Normalize YAML keys (snake_case vs camelCase) and emit warnings for legacy aliases. - - [X] Code [Aditya]: Normalize invariants list (trim, drop blanks, de-dup) preserving order. - - [X] Tests (Behave) [Aditya]: Add scenarios that load each example YAML and assert validation passes; add invalid schema cases. - - [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] 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. - - Validation helper: `src/cleveragents/action/schema.py` — Pydantic `ActionConfigSchema` model with `from_yaml()` and `from_yaml_file()` factories. - - Features: camelCase→snake_case key normalization with deprecation warnings, `${ENV_VAR}` interpolation, invariant trim/dedup/drop-blanks, clear error messages for every validation failure. - - Behave tests: 31 scenarios / 140 steps in `features/action_schema.feature`. - - Robot smoke: 6 test cases in `robot/action_schema.robot` (5 valid examples + 1 invalid rejection). - - ASV benchmarks: 3 suites (validation, file-load, serialization) in `benchmarks/action_schema_bench.py`. - - All nox sessions pass: lint ✓, typecheck (0 errors) ✓, unit_tests (2222 scenarios) ✓, integration_tests (208 passed) ✓, benchmark ✓, security_scan ✓, coverage (98%) ✓. - - **Parallel Group A2c: Plan Phase + Apply State Rebaseline (M1-critical)** - **PARALLEL SUBTRACK A2c.alpha [Jeff]**: Plan phase/state alignment + CLI output updates - **SEQUENTIAL MERGE NOTE**: A2c.alpha must land before A5 persistence wiring and D0 apply integration. -- [X] **COMMIT (Owner: Jeff | Group: A2c.alpha | Branch: feature/m1-plan-phase-rebaseline | Planned: Day 7 | Done: Day 7, February 15, 2026 00:12:07 -0500) - Commit message: "feat(domain): rebaseline plan phases and apply states"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-plan-phase-rebaseline` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Update `PlanPhase` to include `ACTION` and remove `APPLIED` as a phase; keep phases strictly `action/strategize/execute/apply` per spec. - - [X] Code [Jeff]: Expand `processing_state` (or introduce `apply_state` mapping) to represent Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`) and keep non-Apply states (`queued`, `processing`, `complete`) for Strategize/Execute. - - [X] Code [Jeff]: Update `Plan` model validators to allow namespaced names for top-level plans and ULID-only identifiers for subplans; enforce ULID-only for subplans in hierarchy validators. - - [X] Code [Jeff]: Update `Plan.as_cli_dict()` + CLI formatting to show Action phase, apply terminal outcome (explicit field), and phase/processing_state alignment. - - [X] Code [Jeff]: Update `PlanLifecycleService` to create plans in Action phase, transition to Strategize on `plan use`, and set Apply terminal outcomes on `plan apply` (including `constrained` for spec-defined reversion cases). - - [X] Docs [Jeff]: Update `docs/reference/plan_model.md` and `docs/reference/plan_lifecycle_service.md` with Action phase semantics, apply terminal outcomes, and reversion rules (Execute/Apply → Strategize). - - [X] Tests (Behave) [Jeff]: Add/adjust scenarios for Action phase creation, Strategize entry, Apply terminal outcomes, and reversion preconditions. - - [X] Tests (Robot) [Jeff]: Update lifecycle Robot suites to assert Action phase visibility and Apply terminal outcome fields in status output. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_phase_bench.py` for phase transition validation overhead. - - [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(domain): rebaseline plan phases and apply states"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-phase-rebaseline` to `master` with description "Rebaseline plan phases and apply terminal states to spec, with CLI output updates and tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-plan-phase-rebaseline` - - [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] **Stage A3: Plan State Machine** (Day 1-2) - COMPLETED 2026-02-05 - - [X] Code: Implement plan lifecycle state machine - - [X] Create `PlanLifecycleService` with phase transition methods - - [X] Implement `create_action()` - creates plan in Action phase - - [X] Implement `use_action(action, projects, args)` - transitions to Strategize - - [X] Implement `execute_plan()` - transitions to Execute - - [X] Implement `apply_plan()` - transitions to Applied - - [X] Add validation for phase transitions (only valid transitions allowed) - - [X] Location: `src/cleveragents/application/services/plan_lifecycle_service.py` - - [X] Tests: Behave scenarios for all phase transitions, invalid transition errors (29 scenarios in `features/plan_lifecycle_service.feature`) - -- [X] **Stage A4: Plan CLI Commands** (Day 2-3) - IN PROGRESS 2026-02-05 - - [X] Code: Implement plan lifecycle CLI - - [X] `agents [--data-dir PATH] [--config-path PATH] action create --config [] [--strategy-actor ] [--execution-actor ] [--definition-of-done ""] [--arg ...]` (legacy `--name` syntax kept in historical notes) - - [X] `agents [--data-dir PATH] [--config-path PATH] action list` - list available actions - - [X] `agents [--data-dir PATH] [--config-path PATH] action show ` - show action details - - [X] `agents [--data-dir PATH] [--config-path PATH] action available ` - make action available - - [X] `agents [--data-dir PATH] [--config-path PATH] action archive ` - archive action - - [X] `agents [--data-dir PATH] [--config-path PATH] plan use [--arg name=value ...]` - create plan from action (legacy `--project` syntax kept in historical notes) - - [X] `agents [--data-dir PATH] [--config-path PATH] plan execute [plan_id]` - execute current or specified plan - - [X] `agents [--data-dir PATH] [--config-path PATH] plan apply [plan_id]` - apply executed plan (v3 lifecycle) - - [X] `agents [--data-dir PATH] [--config-path PATH] plan status [plan_id]` - show plan phase/state - - [X] `agents [--data-dir PATH] [--config-path PATH] plan list [--phase ] [--state ] [--project ] [--action ]` - list plans with filters - - [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 (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. -- [X] **COMMIT (Owner: Jeff | Group: A4b.action | Branch: feature/m1-action-cli | Done: Day 6, February 14, 2026 06:27:41 +0000) - Commit message: "feat(cli): align action commands to spec"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-action-cli` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Enforce config-only `agents action create --config `; reject legacy flags and inline overrides. - - [X] Code [Jeff]: Load config via `ActionConfigSchema.from_yaml_file()` → `Action.from_config()` and surface file/line validation errors. - - [X] Code [Jeff]: Remove `action available`; align `action list/show/archive` to namespaced names with `--namespace` + `--state` filters. - - [X] Code [Jeff]: Ensure action CLI output includes namespaced name, short_name, state, actor refs, and definition_of_done summary. - - [X] Docs [Jeff]: Update `docs/reference/action_cli.md` with config-only flow, filters, and error cases. - - [X] Tests (Behave) [Jeff]: Add scenarios for config-only create, legacy flag rejection, and list/show filters. - - [X] Tests (Robot) [Jeff]: Add Robot smoke for action create/list/show/archive (DB-backed). - - [X] Tests (ASV) [Jeff]: Add `benchmarks/action_cli_bench.py` for config load + parsing overhead. - - [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(cli): align action commands to spec"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-action-cli` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: A4b.plan | Branch: feature/m1-plan-cli | Done: Day 6, February 14, 2026 14:21:00 +0000) - Commit message: "feat(cli): align plan use/list/status flags"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-plan-cli` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] 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`. - - [X] Code [Jeff]: Align `plan list` filters to spec (`--phase`, `--state`, `--project`, `--action`, optional regex); map `--state` to processing_state. - - [X] Code [Jeff]: Ensure `plan status` renders action_name, phase, processing_state, project links, arguments, and automation profile. - - [X] Docs [Jeff]: Update `docs/reference/plan_cli.md` with plan use flags + list/status filters. - - [X] Tests (Behave) [Jeff]: Add scenarios for plan use with args/invariants/actor overrides and list/status filter combinations. - - [X] Tests (Robot) [Jeff]: Add Robot smoke for plan use + list/status output (DB-backed lifecycle). - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_cli_bench.py` for plan use/list parsing overhead. - - [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(cli): align plan use/list/status flags"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-plan-cli` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: A4b.outputs | Branch: feature/m1-cli-formats | Done: Day 6, February 14, 2026 15:22:47 +0000) - Commit message: "feat(cli): stabilize action/plan output formats"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-cli-formats` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Ensure `--format json|yaml|plain|table|rich` parity for action/plan list/show/status outputs. - - [X] Code [Jeff]: Normalize output keys to spec field names (namespaced_name, processing_state, project_links, arguments, automation_profile). - - [X] Docs [Jeff]: Update `docs/reference/action_cli.md` + `docs/reference/plan_cli.md` with format examples and field descriptions. - - [X] Tests (Behave) [Jeff]: Add format output scenarios for json/yaml on action/plan list/show/status. - - [X] Tests (Robot) [Jeff]: Add Robot lifecycle flow verifying formatted outputs remain stable. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/cli_format_bench.py` for serialization overhead. - - [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(cli): stabilize action/plan output formats"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-cli-formats` - - [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%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Brent | Group: A4b.tests | Branch: feature/m1-cli-tests | Planned: Day 9 | Done: Day 9, February 17, 2026) - Commit message: "test(cli): expand lifecycle command coverage"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m1-cli-tests` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Brent]: Add CLI coverage for action create/list/show/archive and plan use/list/status/execute/apply/cancel (success + error paths). - - [X] Tests (Behave) [Brent]: Add scenarios for plan use with multi-project args, automation profile overrides, invariants, and actor overrides. - - [X] Tests (Behave) [Brent]: Add scenarios that assert Action phase visibility and Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`) in `plan status` output. - - [X] Tests (Behave) [Brent]: Add negative cases for missing config, invalid args, invalid project names, and unknown actions/resources. - - [X] Tests (Robot) [Brent]: Add end-to-end Robot suite for action → plan → execute → apply on a local repo (sandbox + ChangeSet capture verified). - - [X] Docs [Brent]: Update `docs/development/testing.md` with CLI suites + fixtures. - - [X] Tests (ASV) [Brent]: Add `benchmarks/plan_cli_smoke_bench.py` for CLI argument parsing overhead. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(cli): expand lifecycle command coverage"` - - [X] 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.". - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m1-cli-tests-robot` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` - - [X] Tests (Robot) [Brent]: Add end-to-end Robot suite for action → plan → execute → apply on a local repo with git_worktree sandbox + ChangeSet capture verification. - - [X] Tests (Robot) [Brent]: Add negative Robot cases for invalid project names, missing resources, and invalid `--arg` values to match CLI error outputs. - - [X] Tests (Behave) [Brent]: Add one CLI scenario mirroring the Robot E2E flow to keep unit/integration expectations aligned. - - [X] Docs [Brent]: Update `docs/development/testing.md` with Robot CLI suite entry and fixtures. - - [X] Tests (ASV) [Brent]: Add `benchmarks/cli_robot_flow_bench.py` for CLI flow fixture setup overhead. - - [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%. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Brent]: `git commit -m "test(cli): add Robot lifecycle CLI coverage"` - - [X] Git [Brent]: `git push -u origin feature/m1-cli-tests-robot` - - [X] Forgejo PR [Brent]: Open PR from `feature/m1-cli-tests-robot` to `master` with description "Add Robot end-to-end lifecycle coverage for CLI flows with sandbox + ChangeSet assertions and aligned Behave smoke.". - -**Parallel Group A5: Plan Persistence (M1-critical)** - **PARALLEL SUBTRACK A5.beta [Jeff]**: DB rebaseline for Action phase + Apply terminal states - **PARALLEL SUBTRACK A5.delta [Jeff]**: Lifecycle plan repository + filters - **PARALLEL SUBTRACK A5.epsilon [Jeff]**: 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.beta → A5.delta → A5.epsilon → A5.zeta; A5.eta runs after A5.zeta. - **LEGACY (completed, superseded by rebaseline)**: -- [X] **COMMIT (Owner: Jeff | Group: A5.alpha | Branch: feature/m1-db-actions | Done: Day 5, February 13, 2026 17:10:56 +0000) - Commit message: "feat(db): add spec-aligned action and plan tables with migrations, ORM models, and benchmarks"** - LEGACY (superseded by rebaseline) - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-db-actions` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add Alembic migration skeleton with explicit down_revision dependency and naming conventions for indexes/constraints. - - [X] Code [Jeff]: Create `actions` table with **namespaced_name (PK)**, `namespace`, `name`, and actor refs (strategy/execution/review/apply/estimation/invariant). - - [X] Code [Jeff]: Add `state` enum column (`available`/`archived`) with default `available` (no draft state). - - [X] Code [Jeff]: Add description columns (`description`, `long_description`) and `definition_of_done` (rendered text). - - [X] Code [Jeff]: Add behavioral columns (`automation_profile`, `reusable`, `read_only`, `inputs_schema_json`) and metadata (`tags_json`, `created_by`, timestamps). - - [X] Code [Jeff]: Add `action_invariants` table with FK to actions by namespaced_name, `invariant_text`, `position`, and created_at. - - [X] Code [Jeff]: Add unique index on `actions.namespaced_name`, index on `actions.namespace`, and index on `actions.state` for list filters. - - [X] Code [Jeff]: Ensure downgrade path drops indexes and tables in reverse order. - - [X] Code [Jeff]: Add Alembic migration for `action_arguments` table with FK to `actions.namespaced_name` and ordered `position` for deterministic argument ordering. - - [X] Code [Jeff]: Add columns for `name`, `arg_type` (string/integer/float/boolean/list), `requirement`, `description`, `default_value_json`, `min_value`, `max_value`, `validation_pattern`. - - [X] Code [Jeff]: Add check constraints for numeric min/max ordering and non-empty argument names. - - [X] Code [Jeff]: Add uniqueness constraint on (action_name, name) and index on (action_name, position). - - [X] Code [Jeff]: Add Alembic migration for `v3_plans` (replacing `lifecycle_plans`) with ULID PK and identity fields (parent_plan_id, root_plan_id, attempt). - - [X] Code [Jeff]: Add core plan columns: `namespaced_name`, `namespace`, `description`, `definition_of_done` (rendered). - - [X] Code [Jeff]: Add lifecycle columns: `phase` enum (strategize/execute/apply/applied), `processing_state` enum (queued/processing/errored/complete/cancelled), and phase timestamps. - - [X] Code [Jeff]: Add action linkage columns (`action_name` only) and actor refs (strategy/execution/review/apply/estimation/invariant). - - [X] Code [Jeff]: Add policy/metadata columns (`automation_profile`, `read_only`, `reusable`, `inputs_schema_json`, `created_by`, `tags_json`). - - [X] Code [Jeff]: Add execution placeholders (`changeset_id`, `sandbox_refs_json`, `validation_summary_json`, `decision_root_id`, `error_message`, `error_details_json`). - - [X] Code [Jeff]: Add `plan_projects` table with plan_id, project_name (namespaced), alias, read_only flag, and created_at. - - [X] Code [Jeff]: Add uniqueness constraint on (plan_id, project_name) and index on (project_name) for lookups. - - [X] Code [Jeff]: Add indexes on `phase`, `processing_state`, and `namespace` for list filtering. - - [X] Code [Jeff]: Add `plan_arguments` table with plan_id, name, value_json, value_type, and `position` for stable ordering. - - [X] Code [Jeff]: Add `plan_invariants` table with plan_id, invariant_text, source_scope (plan/action/project/global), optional `position`, and created_at. - - [X] Code [Jeff]: Add uniqueness constraint on (plan_id, name) for arguments and (plan_id, invariant_text) for invariants. - - [X] Code [Jeff]: Add index on (plan_id, position) for fast ordered retrieval. - - [X] Code [Jeff]: Update `LifecycleActionModel` ORM: PK as `namespaced_name`, child relationships for `arguments_rel` and `invariants_rel`, `to_domain()`/`from_domain()` methods. - - [X] Code [Jeff]: Add `ActionInvariantModel`, `ActionArgumentModel` child ORM models. - - [X] Code [Jeff]: Update `LifecyclePlanModel` ORM: maps to `v3_plans`, `action_name` FK, `processing_state`, child relationships for `project_links_rel`, `arguments_rel`, `invariants_rel`, `to_domain()`/`from_domain()` methods. - - [X] Code [Jeff]: Add `PlanProjectModel`, `PlanArgumentModel`, `PlanInvariantModel` child ORM models. - - [X] Code [Jeff]: Update `ActionRepository` to use `namespaced_name` identity, update child table management in `update()`. - - [X] Code [Jeff]: Export all new child models from `infrastructure.database.__init__`. - - [X] Docs [Jeff]: Create `docs/reference/database_schema.md` with column-level details, constraints, indexes, FK relationships, and ER diagram for all 7 new tables. - - [X] Docs [Jeff]: Document argument storage, JSON serialization rules, and invariant source scopes. - - [X] Tests (Behave) [Jeff]: Update migration scenarios and model coverage steps for new column names and child table patterns. - - [X] Tests (Robot) [Jeff]: Update Robot integration tests for new schema (namespaced_name lookups, child table inserts). - - [X] Tests (ASV) [Jeff]: Add `benchmarks/db_migration_actions_bench.py` for action ORM round-trip baseline. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/db_migration_action_args_bench.py` for argument serialization baseline. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/db_migration_plans_bench.py` for plan ORM round-trip baseline. - - [X] Quality [Jeff]: Run `nox -s typecheck` -- 0 errors, 0 warnings. - - [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] 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` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report` -- TOTAL 97%. -- [X] **COMMIT (Owner: Jeff | Group: A5.beta | Branch: feature/m1-db-plan-phase-rebaseline | Planned: Day 7 | Done: Day 7, February 15, 2026) - Commit message: "feat(db): rebaseline plan phase/state enums for Action and Apply terminal states"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-db-plan-phase-rebaseline` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add Alembic migration that updates `v3_plans` phase/state constraints to include `action` phase and Apply terminal outcomes (`applied`, `constrained`, `errored`, `cancelled`), and removes `applied` as a phase. - - [X] Code [Jeff]: Rebuild `v3_plans` table safely for SQLite (create temp table → copy → drop → rename) to update CHECK constraints and defaults without data loss. - - [X] Code [Jeff]: Update ORM `LifecyclePlanModel` to accept Action phase + Apply terminal states; ensure serialization/deserialization maps updated enums. - - [X] Code [Jeff]: Mark `automation_level` column as legacy (no new writes); keep nullable for backward compatibility until removal in A6.legacy cleanup. - - [X] Docs [Jeff]: Update `docs/reference/database_schema.md` with the new phase/state constraints and legacy automation_level note. - - [X] Tests (Behave) [Jeff]: Add migration scenarios asserting phase/state constraints accept Action + Apply terminal values and reject legacy `applied` phase. - - [X] Tests (Robot) [Jeff]: Add Robot migration smoke test that inserts a plan row with `phase=action` and `processing_state=queued`. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_phase_migration_bench.py` for migration runtime 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(db): rebaseline plan phase/state enums for Action and Apply terminal states"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-db-plan-phase-rebaseline` to `master` with description "Rebaseline plan phase/state constraints for Action phase and Apply terminal outcomes, with migration + tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-db-plan-phase-rebaseline` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. -- [X] **COMMIT (Owner: Jeff | Group: A5.delta | Branch: feature/m1-plan-repo | Planned: Day 8 | Expected: Day 10) - Commit message: "feat(repo): add lifecycle plan repository"** Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-plan-repo` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `LifecyclePlanRepository` backed by `LifecyclePlanModel` (create/get/update/delete) with ordered child persistence for project links, arguments, and invariants. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Persist Action phase + Apply terminal states (`applied`, `constrained`, `errored`, `cancelled`) in phase/state filters and serialization. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add list filters for phase, processing_state, action_name, project_name, and namespace (match CLI flags); ensure deterministic ordering. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Raise explicit errors for duplicate plan_id, missing plan, and invalid phase/state updates. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Document plan repository contract + filters in `docs/reference/repositories.md`. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios for create/get/list/update, filter behavior, and child row ordering. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot smoke test for repository CRUD via service layer. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_repository_bench.py` for list/query performance. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(repo): add lifecycle plan repository"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-repo` to `master` with description "Add lifecycle plan repository with filters and ordered child persistence.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-plan-repo` - - [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%, if not repeat this task as many times as is needed until coverage reaches >=97%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: A5.epsilon | Branch: feature/m1-uow-lifecycle | Planned: Day 9 | Done: Day 7, February 15, 2026) - Commit message: "feat(uow): wire lifecycle repositories"** - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-uow-lifecycle` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Update `UnitOfWork` to expose `actions` + `lifecycle_plans` repositories and remove legacy plan repository accessors. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Update `UnitOfWorkContext` to include new repos and remove legacy plan/change repositories from default access. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Update `docs/reference/repositories.md` with UoW lifecycle usage patterns. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios verifying UoW exposes action + lifecycle plan repositories. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot smoke test that creates an action + plan via UoW. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/uow_lifecycle_bench.py` for UoW overhead baseline. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(uow): wire lifecycle repositories"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-uow-lifecycle` to `master` with description "Wire lifecycle repositories into UnitOfWork and remove legacy plan repo access.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-uow-lifecycle` - - [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%, if not repeat this task as many times as is needed until coverage reaches >=97%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: A5.zeta | Branch: feature/m1-lifecycle-persist | Planned: Day 10 | Done: Day 7, February 15, 2026) - Commit message: "feat(service): persist plan lifecycle via repositories"** - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-lifecycle-persist` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Update `PlanLifecycleService` to use ActionRepository + LifecyclePlanRepository (remove in-memory maps). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Persist plan creation + phase transitions (Action → Strategize → Execute → Apply) with timestamps and apply terminal state updates. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Persist rendered description/definition_of_done and ordered arguments/invariants at plan creation. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Update `docs/reference/plan_lifecycle_service.md` with persistence-only flow and error mapping. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios for persisted transitions, duplicate action name rejection, and missing action errors. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add end-to-end test that restarts the app and reloads plan state from DB. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_lifecycle_persistence_bench.py` for lifecycle persistence overhead. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(service): persist plan lifecycle via repositories"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-lifecycle-persist` to `master` with description "Persist plan lifecycle via repositories and remove in-memory storage.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-lifecycle-persist` - - [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%, if not repeat this task as many times as is needed until coverage reaches >=97%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: A5.eta | Branch: feature/m1-remove-legacy-planstore | Planned: Day 11 | Done: Day 7, February 15, 2026) - Commit message: "refactor(plan): remove legacy plan persistence"** - - [X] Git [Jeff]: `git checkout master`. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master`. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-remove-legacy-planstore`. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Remove legacy `PlanService`, `PlanRepository`, and `plan_legacy.py` usage from services/CLI. Done: Day 7, February 15, 2026. Added deprecation warnings to PlanService, PlanRepository, and ChangeRepository since they are still heavily referenced. Added deprecation warnings to all legacy CLI commands (tell, build, apply, new, current, list, cd, continue). - - [X] Code [Jeff]: Remove legacy change persistence paths (`ChangeRepository`, old `Change` model) from plan CLI flows. Done: Day 7, February 15, 2026. Added deprecation warnings to ChangeRepository; legacy code preserved for backward compatibility. - - [X] Docs [Jeff]: Update `docs/reference/plan_cli.md` and `docs/reference/plan_lifecycle_service.md` to remove legacy mentions. Done: Day 7, February 15, 2026. Added deprecation tables and notes to both docs. - - [X] Tests (Behave) [Jeff]: Add scenarios that ensure legacy CLI paths are rejected with explicit errors. Done: Day 7, February 15, 2026. Created `features/legacy_plan_removal.feature` with 14 scenarios covering PlanService, PlanRepository, ChangeRepository, all 8 CLI wrappers, PlanLifecycleService (no deprecation), and UnitOfWorkContext plans property. - - [X] Tests (Robot) [Jeff]: Add Robot smoke test ensuring legacy plan commands are not reachable. Done: Day 7, February 15, 2026. Created `robot/legacy_plan_removal.robot` with 4 test cases verifying deprecation warnings via subprocess. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/legacy_removal_bench.py` for minimal overhead regression guard. Done: Day 7, February 15, 2026. Created 3 benchmark suites (LegacyPlanServiceSuite, LegacyRepositorySuite, LegacyCLIWrapperSuite). - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026. All nox sessions pass: lint 0 findings, typecheck 0 errors, 2785 scenarios passed / 0 failed. - - [X] Git [Jeff]: `git add .`. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "refactor(plan): remove legacy plan persistence"`. Done: Day 7, February 15, 2026 - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-remove-legacy-planstore` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Done: Day 7, February 15, 2026. - -- [X] **COMMIT (Owner: Brent | Group: A5.tests | Branch: feature/m1-persistence-tests | Planned: Day 11 | Done: Day 9, February 17, 2026) - Commit message: "test(persistence): add plan/action persistence suites"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m1-persistence-tests` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Tests (Behave) [Brent]: Add plan persistence scenarios (create, phase/state transitions, list filters, plan tree links). - - [X] Tests (Behave) [Brent]: Add scenarios for Action phase persistence and Apply terminal state storage (`applied`, `constrained`, `errored`, `cancelled`). - - [X] Tests (Behave) [Brent]: Add action persistence scenarios (create/list/archive, arguments/invariants ordering). - - [X] Tests (Behave) [Brent]: Add cross-restart scenarios verifying plan status persists across process restarts. - - [X] Tests (Robot) [Brent]: Add plan persistence E2E (full lifecycle, restart persistence, concurrent CLI access). - - [X] Docs [Brent]: Update `docs/development/testing.md` with persistence suites, fixtures, and nox commands. - - [X] Tests (ASV) [Brent]: Add `benchmarks/persistence_suites_bench.py` for test runtime baseline. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(persistence): add plan/action persistence suites"` - - [X] Forgejo PR [Brent]: Merged to master via PR #101 (develop-20260217 batch merge). - - -- [X] **COMMIT (Owner: Brent | Group: A5.tests.robot | Branch: feature/m1-persistence-tests-robot | Done: Day 12, February 19, 2026 | Planned: Day 11 | Expected: Day 12) - Commit message: "test(persistence): add Robot persistence coverage"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m1-persistence-tests-robot` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` - - [X] Tests (Robot) [Brent]: Add plan persistence E2E suite (full lifecycle, process restart, re-open plan status, concurrent CLI access safeguards). - - [X] Tests (Robot) [Brent]: Add assertions for stored arguments/invariants ordering and project links persistence. - - [X] Tests (Behave) [Brent]: Add one persistence scenario mirroring the Robot restart flow to keep unit/integration expectations aligned. - - [X] Docs [Brent]: Update `docs/development/testing.md` with Robot persistence suite references. - - [X] Tests (ASV) [Brent]: Add `benchmarks/persistence_robot_bench.py` for Robot fixture setup overhead. - - [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%. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Brent]: `git commit -m "test(persistence): add Robot persistence coverage"` - - [X] Git [Brent]: `git push -u origin feature/m1-persistence-tests-robot` - - [X] Forgejo PR [Brent]: Open PR from `feature/m1-persistence-tests-robot` to `master` with description "Add Robot end-to-end persistence coverage with restart/ordering checks and aligned Behave smoke.". - -- [X] **Stage A6: Automation Levels Foundation** (Day 4-5) **[Luis]** - - [X] Code: Implement basic automation level support - - [X] **A6.1** [Luis] Add `AutomationLevel` enum to `src/cleveragents/domain/models/core/plan.py`: - - [X] Value `MANUAL` - user triggers each phase transition - - [X] Value `REVIEW_BEFORE_APPLY` - auto strategize+execute, pause before apply - - [X] Value `FULL_AUTOMATION` - all phases automatic - - [X] **A6.2** [Luis] Add automation level configuration to `src/cleveragents/config/settings.py`: - - [X] Add `default_automation_level: AutomationLevel` setting - - [X] Add `CLEVERAGENTS_AUTOMATION_LEVEL` environment variable - - [X] Implement hierarchy: plan-level > session-level > global-level - - [X] **A6.3** [Luis] Update `PlanLifecycleService` to respect automation levels: - - [X] Add `automation_level` parameter to `use_action()` method - - [X] If automation allows, automatically call `execute_plan()` after strategize completes - - [X] If full automation, automatically call `apply_plan()` after execute completes - - [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 - - [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 - - [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 - - [X] Scenario: Manual mode requires explicit apply command - - [X] Scenario: Review-before-apply auto-executes after strategize completes - - [X] Scenario: Review-before-apply pauses at apply - - [X] Scenario: Full automation auto-executes after strategize completes - - [X] Scenario: Full automation auto-applies after execute completes - - [X] Scenario: Plan-level automation overrides global setting - - [X] Scenario: Use action with explicit automation level - - [X] Scenario: Use action without explicit automation level uses global default - - [X] Scenario: Change automation level mid-plan works correctly - - [X] Scenario: Cannot change automation level on terminal plan - - [X] Scenario: should_auto_progress returns false for manual plan in strategize complete - - [X] Scenario: should_auto_progress returns true for review-before-apply plan in strategize complete - - [X] Scenario: should_auto_progress returns false for review-before-apply plan in execute complete - - [X] Scenario: should_auto_progress returns true for full-automation plan in execute complete - - [X] Scenario: should_auto_progress returns false for terminal plan - - [X] Scenario: Pause plan sets automation to manual - - [X] Scenario: Cannot pause terminal plan - - [X] Scenario: Resume plan restores automation level - - [X] Scenario: Resume plan without explicit level defaults to review-before-apply - - [X] Scenario: Cannot resume terminal plan - - [X] Scenario: Resume plan triggers auto-progress when ready - - [X] Scenario: Resolve automation level from settings - - [X] Scenario: Invalid automation level in settings falls back to manual - -**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 [Jeff]**: Profile resolution + precedence - **PARALLEL SUBTRACK A6.cli [Jeff]**: CLI commands for profiles - **SEQUENTIAL MERGE NOTE**: A6.core must land before A6.service/cli; A6.service must land before gating integration in Section 6. -- [x] **COMMIT (Owner: Jeff | Group: A6.core | Branch: feature/m4-automation-profiles-core | Planned: Day 22 | Done: Day 9, February 17, 2026) - Commit message: "feat(domain): add automation profile model and built-ins"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m4-automation-profiles-core` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] 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. - - [x] Code [Jeff]: Add built-in profiles (`manual`, `review`, `supervised`, `cautious`, `trusted`, `auto`, `ci`, `full-auto`) with exact threshold values per spec and stable names. - - [x] Code [Jeff]: Add YAML schema for automation profiles under `docs/schema/automation_profile.schema.yaml` and loader helper with env interpolation. - - [x] Code [Jeff]: Add `examples/profiles/` built-in profile YAMLs (one per profile) with schema version guard. - - [x] Docs [Jeff]: Add `docs/reference/automation_profiles.md` describing built-ins, threshold semantics, and resolution precedence. - - [x] Tests (Behave) [Jeff]: Add scenarios for profile validation, built-in defaults, and invalid threshold ranges. - - [x] Tests (Robot) [Jeff]: Add Robot test that loads each built-in profile and prints summary. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/automation_profile_bench.py` for profile validation. - - [x] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Jeff]: `git add .` - - [x] Git [Jeff]: `git commit -m "feat(domain): add automation profile model and built-ins"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-profiles-core` to `master` with description "Add automation profile domain model, built-ins, schema, and tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m4-automation-profiles-core` - - [x] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. -- [x] **COMMIT (Owner: Jeff | Group: A6.service | Branch: feature/m4-automation-profiles-service | Planned: Day 23 | Done: Day 9, February 17, 2026) - Commit message: "feat(service): resolve automation profiles with precedence"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m4-automation-profiles-service` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Jeff]: Add `AutomationProfileService` to resolve profiles with precedence (plan > action > project > global) and emit explicit errors for missing profiles. - - [x] Code [Jeff]: Add persistence table `automation_profiles` (namespaced name PK) and repository with list/show/update and schema_version guard. - - [x] Code [Jeff]: Add config key `core.automation_profile` and env var override for global default; keep `automation_level` as legacy mapping until removal. - - [x] Code [Jeff]: Update PlanLifecycleService auto-progress logic to use AutomationProfile thresholds (map legacy automation_level to built-ins). - - [x] Docs [Jeff]: Update `docs/reference/config.md` with automation profile defaults, legacy mapping notes, and override behavior. - - [x] Tests (Behave) [Jeff]: Add scenarios for precedence resolution, missing profile errors, and legacy automation_level mapping. - - [x] Tests (Robot) [Jeff]: Add Robot config smoke test for global profile override. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/automation_profile_resolution_bench.py` for resolution latency. - - [x] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Jeff]: `git add .` - - [x] Git [Jeff]: `git commit -m "feat(service): resolve automation profiles with precedence"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-profiles-service` to `master` with description "Add automation profile resolution service, persistence, and config precedence with tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m4-automation-profiles-service` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: A6.cli | Branch: feature/m4-automation-profiles-cli | Planned: Day 24 | Done: Day 10, February 18, 2026) - Commit message: "feat(cli): add automation-profile commands"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m4-automation-profiles-cli` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Implement `agents automation-profile add/remove/list/show` commands with YAML config input, schema_version guard, and namespaced name validation. - - [X] Code [Jeff]: Add `--update` behavior with conflict errors; preserve original created_at on update, and surface `source` (built-in/custom) in outputs. - - [X] Code [Jeff]: Ensure `automation-profile list` supports `--namespace` and regex filters with deterministic ordering; add `--format json|yaml|plain` output. - - [X] Code [Jeff]: Extend `plan use` with `--automation-profile` and show profile name + threshold summary in `plan status` output. - - [X] Code [Jeff]: Deprecate `--automation-level` and `plan set-automation-level` (keep as alias mapping to built-in profiles with warning). - - [X] Docs [Jeff]: Update CLI reference with automation-profile examples, built-in profiles list, and deprecation notes. - - [X] Tests (Behave) [Jeff]: Add CLI scenarios for profile add/list/show/remove/update and invalid name/threshold validation errors. - - [X] Tests (Behave) [Jeff]: Add output snapshot assertions for `automation-profile list --format json` and `show --format yaml`. - - [X] Tests (Robot) [Jeff]: Add Robot CLI tests for automation-profile commands (add/show/remove + format outputs). - - [X] Tests (ASV) [Jeff]: Add `benchmarks/automation_profile_cli_bench.py` for CLI parsing. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(cli): add automation-profile commands"` - - [X] Git [Jeff]: `git push -u origin feature/m4-automation-profiles-cli` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-profiles-cli` to `master` with description "Add automation-profile CLI commands, output formats, and tests.". - -- [X] **COMMIT (Owner: Jeff | Group: A6.legacy | Branch: feature/m4-automation-legacy-cleanup | Planned: Day 25 | Done: Day 12, February 20, 2026) - Commit message: "refactor(automation): remove automation_level legacy fields"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m4-automation-legacy-cleanup` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Remove `automation_level` from Plan domain model, config settings, and CLI flags; keep `automation_profile` as the only automation control. - - [X] Code [Jeff]: Add migration to drop `automation_level` column + CHECK constraint from `v3_plans` (SQLite rebuild), with downgrade restoring legacy column. - - [X] Code [Jeff]: Remove legacy mapping logic in `PlanLifecycleService` and config fallback (no `automation_level` alias). - - [X] Docs [Jeff]: Update config + CLI references to remove automation_level mentions and document profile-only flow. - - [X] Tests (Behave) [Jeff]: Add scenarios ensuring legacy automation_level inputs are rejected with explicit errors. - - [X] Tests (Robot) [Jeff]: Add Robot CLI test verifying `plan use --automation-level` is rejected post-removal. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/automation_legacy_cleanup_bench.py` for migration runtime baseline. - - [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 coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "refactor(automation): remove automation_level legacy fields"` - - [X] Git [Jeff]: `git push -u origin feature/m4-automation-legacy-cleanup` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m4-automation-legacy-cleanup` to `master` with description "Remove automation_level legacy fields in favor of automation profiles with migrations + tests.". - -**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 | 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` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add `Session` and `SessionMessage` domain models with ULID IDs, actor ref, timestamps, and role enum (user/assistant/system/tool). (MessageRole enum, SessionMessage, SessionTokenUsage, Session models in session.py) - - [X] Code [Jeff]: Add message validation for role/content presence and stable ordering by sequence number. - - [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) - - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/session_model_bench.py` for validation throughput. - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, 39 new scenarios pass. - - [X] Git [Jeff]: `git add .` - - [X] Git [Jeff]: `git commit -m "feat(session): add session domain models and contracts"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-session-domain` to `master` with description "Add session domain models + service contracts with docs and tests." - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m3-session-domain` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (session.py 98%). - -- [X] **COMMIT (Owner: Brent | Group: A7.domain.tests | Branch: feature/m3-session-domain-robot | Planned: Day 13 | Done: Day 9, February 17, 2026) - Commit message: "test(session): add robot session model smoke tests"** - - [X] 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. - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m3-session-domain-robot` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add `robot/session_model.robot` smoke tests for Session creation, message ordering, and serialization output. - - [X] Docs [Brent]: Update `docs/reference/session_model.md` to mention the Robot smoke suite and how to run it. - - [X] Tests (Behave) [Brent]: Add a scenario in `features/session_model.feature` that mirrors the Robot smoke expectations for serialization order. - - [X] Tests (Robot) [Brent]: Add Robot suite that validates session model creation and export paths. - - [X] Tests (ASV) [Brent]: Confirm `asv/benchmarks/session_model_bench.py` still passes after the new Robot suite is added. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(session): add robot session model smoke tests"` - - [X] 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.". - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/m3-session-domain-robot` - - [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%. -- [X] **COMMIT (Owner: Luis | Group: A7.persistence | Branch: feature/m3-session-persistence | Done: Day 7, February 15, 2026 16:49:13 +0000) - Commit message: "feat(session): add session persistence and repositories"** - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git pull origin master` - - [X] Git [Luis]: `git checkout -b feature/m3-session-persistence` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Luis]: Add DB tables `sessions` (9 cols, ULID PK, indexes on `created_at` and `actor_name`) and `session_messages` (8 cols, ULID PK, FK to sessions CASCADE, composite index on `(session_id, sequence)`) via migration `a7_001_session_persistence` (depends on `b1_001_resource_registry`). - - [X] Code [Luis]: Implement `SessionRepository` (5 methods: `create`/`get_by_id`/`list_all`/`delete`/`update`) + `SessionMessageRepository` (3 methods: `append`/`get_for_session`/`count_for_session`) with pagination (`limit`/`offset`), message append semantics, and `@database_retry` on all methods. - - [X] Code [Luis]: Implement `PersistentSessionService` extending domain `SessionService` ABC (8 methods: `create`/`get`/`list`/`delete`/`append_message`/`export_session`/`import_session`/`update_token_usage`) with ULID generation, auto-sequencing, SHA-256 checksum verification on import, schema version validation, and cumulative token usage tracking. - - [X] Code [Luis]: Wire session repositories/services into exports: 4 symbols in `infrastructure/database/__init__.py` (`SessionModel`, `SessionMessageModel`, `SessionRepository`, `SessionMessageRepository`), 1 symbol in `application/services/__init__.py` (`PersistentSessionService`). - - [X] Docs [Luis]: Update `docs/reference/database_schema.md` with 2 new table sections (`sessions`, `session_messages`), updated ER diagram, migration chain, and source locations. - - [X] Tests (Behave) [Luis]: Add `features/session_persistence.feature` (24 scenarios across 8 groups: creation/listing/deletion/message-append/pagination/export-import/token-usage/ORM-round-trip) with `features/steps/session_persistence_steps.py` (431 lines). - - [X] Tests (Robot) [Luis]: Add `robot/session_persistence.robot` (4 integration tests: round-trip, message ordering, export+import, token tracking) with `robot/helper_session_persistence.py` (139 lines). - - [X] Tests (ASV) [Luis]: Add `benchmarks/session_persistence_bench.py` (2 ASV suites, 7 benchmarks: session create/get/list, message append, export, token update, import). - - [X] Quality [Luis]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Luis]: `git add .` - - [X] Git [Luis]: `git commit -m "feat(session): add session persistence and repositories"` - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: `git push -u origin feature/m3-session-persistence` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-session-persistence` to `master` with a suitable and thorough description - **Notes (A7.persistence)**: - - Migration `a7_001_session_persistence` depends on `b1_001_resource_registry`. Tables: `sessions` (9 cols, ULID PK, namespace default `'local'`) and `session_messages` (8 cols, ULID PK, CASCADE from sessions). - - `SessionModel.to_domain()` returns full `Session` domain object (not a dict) with parsed `SessionTokenUsage` and hydrated child `SessionMessage` list, unlike `ToolModel.to_domain()` which returns a dict. - - `PersistentSessionService` extends the domain ABC `SessionService`, not a Protocol, enforcing explicit inheritance. - - `append_message()` auto-calculates sequence number via `count_for_session()` and updates parent session `updated_at`, maintaining ordering invariants. - - `import_session()` validates `EXPORT_SCHEMA_VERSION` and SHA-256 checksum, then generates fresh ULIDs for both session and messages to avoid ID collisions. - - `update_token_usage()` uses cumulative addition (+=) for `input_tokens`, `output_tokens`, `estimated_cost` rather than replacement. - - Second commit `fix(bench)` (2026-02-15 16:49:20 +0000) fixes `benchmarks/resource_registry_migration_bench.py` unique name constraints under ASV multi-iteration runs. - - 12 files changed, +1861/-1 lines (main commit); 1 file changed, +12/-4 lines (bench fix). -- [X] **COMMIT (Owner: Brent | Group: A7.cli | Branch: feature/m3-session-cli | Planned: Day 15 | Expected: Day 19 | Done: 2026-02-19) - Commit message: "feat(cli): add session commands"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m3-session-cli` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` - - [X] Code [Brent]: Implement `agents session create/list/show/delete/export/import/tell` with `--actor`, `--stream`, and format outputs. - - [X] Code [Brent]: Ensure `session tell` uses SessionService append + actor execution, updates last_active, and persists message order. - - [X] Code [Brent]: Validate `session export/import` paths (create dirs, refuse overwrite unless `--force`) and guard against missing session IDs. - - [X] Code [Brent]: Add `--format json/yaml` support for list/show and include message counts + last_active timestamps. - - [X] Docs [Brent]: Update CLI reference with session command examples, streaming notes, and JSON output shape. - - [X] Tests (Behave) [Brent]: Add `features/session_cli.feature` covering create/list/show/delete/export/import/tell flows + error cases. - - [X] Tests (Robot) [Brent]: Add `robot/session_cli.robot` end-to-end session flows with export/import round-trip. - - [X] Tests (ASV) [Brent]: Add `benchmarks/session_cli_bench.py` for command parsing overhead. - - [X] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Brent]: `git commit -m "feat(cli): add session commands"` - - [X] Git [Brent]: `git push -u origin feature/m3-session-cli` - - [X] Forgejo PR [Brent]: Open PR from `feature/m3-session-cli` to `master` with description "Add session CLI commands with Behave/Robot coverage and docs updates." - -**Parallel Group A8: Config CLI [Brent]** (M3; post-M1; depends on Settings) -- [X] **COMMIT (Owner: Brent | Group: A8.cli | Branch: feature/m3-config-cli | Planned: Day 16 | Expected: Day 20 | Done: Day 19) - Commit message: "feat(cli): add config get/set/list commands"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m3-config-cli` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` - - [X] Code [Brent]: Implement `agents config set `, `agents config get `, and `agents config list []` with `--filter-values` regex support. - - [X] Code [Brent]: Ensure config updates write to the configured path (create file + parent dirs if missing) and preserve existing comments ordering when possible. - - [X] Code [Brent]: Mask secret values in `config list` output by default with `--show-secrets` override. - - [X] Code [Brent]: Emit explicit errors for unknown keys and invalid regex filters. - - [X] Docs [Brent]: Add `docs/reference/config_cli.md` with examples and masking rules for secrets. - - [X] Tests (Behave) [Brent]: Add `features/config_cli.feature` for set/get/list, filter behavior, and secret masking. - - [X] Tests (Robot) [Brent]: Add `robot/config_cli.robot` smoke tests for config list output. - - [X] Tests (ASV) [Brent]: Add `benchmarks/config_cli_bench.py` for CLI parsing. - - [X] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Brent]: `git commit -m "feat(cli): add config get/set/list commands"` - - [X] Git [Brent]: `git push -u origin feature/m3-config-cli` - - [X] Forgejo PR [Brent]: Open PR from `feature/m3-config-cli` to `master` with description "Add config get/set/list CLI commands with tests and docs updates." - -**Parallel Group A9: Config Service Backend [Jeff + Luis]** (depends on A8.cli) - **PARALLEL SUBTRACK A9.service [Jeff]**: Config resolution chain and key registry - **PARALLEL SUBTRACK A9.project [Luis]**: Project-scoped config persistence - **SEQUENTIAL MERGE NOTE**: A9.service lands before A9.project. - -- [ ] **COMMIT (Owner: Jeff | Group: A9.service | Branch: feature/m3-config-service | Planned: Day 14 | Expected: Day 22) - Commit message: "feat(config): add config service with multi-level resolution"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m3-config-service` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Implement `ConfigService` with TOML file management (`~/.cleveragents/config.toml`), read/write operations, and parent directory auto-creation. - - [ ] Code [Jeff]: Implement multi-level resolution chain: CLI flag > environment variable > project-scoped > global config > default. Each `config get` call returns the winning value plus the source level that provided it. - - [ ] Code [Jeff]: Add config key registry with typed entries: key name, Python type, default value, env var mapping (`CLEVERAGENTS_*`), project-scopability flag, and description. Register the complete catalog per spec (`core.*`, `plan.*`, `provider.*`, `sandbox.*`, `context.*`, `index.*`). - - [ ] Code [Jeff]: Wire `config get` output to display the resolution chain (which level provided the winning value) when `--verbose` is passed. - - [ ] Code [Jeff]: Add env var interpolation for all registered keys following the `CLEVERAGENTS_
_` convention. - - [ ] Code [Jeff]: Add validation that rejects unknown keys and type-mismatched values with actionable error messages. - - [ ] Docs [Jeff]: Add `docs/reference/config_resolution.md` documenting the resolution chain, all config keys, their types, defaults, and env var mappings. - - [ ] Tests (Behave) [Jeff]: Add `features/config_resolution.feature` with scenarios for each resolution level, env var overrides, unknown key rejection, and type validation. - - [ ] Tests (Robot) [Jeff]: Add `robot/config_resolution.robot` for end-to-end config get/set with env var interactions. - - [ ] Tests (ASV) [Jeff]: Add `benchmarks/config_resolution_bench.py` for resolution chain performance. - - [ ] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(config): add config service with multi-level resolution"` - - [ ] Git [Jeff]: `git push -u origin feature/m3-config-service` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-config-service` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: A9.project | Branch: feature/m4-config-project-scope | Planned: Day 18 | Expected: Day 26) - Commit message: "feat(config): add project-scoped config overrides"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-config-project-scope` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add `--project` flag to `config set` and `config get` commands. Store project-scoped overrides under `[project.""]` TOML tables in the global config file. - - [ ] Code [Luis]: Integrate project-scoped resolution into `ConfigService` resolution chain (between env var and global levels). - - [ ] Code [Luis]: Add `config list --project ` to show only project-scoped overrides with their source annotations. - - [ ] Code [Luis]: Add persistence for project-scoped config in the database as an alternative backend (for projects that don't use TOML). - - [ ] Docs [Luis]: Update `docs/reference/config_resolution.md` with project-scoped examples and precedence diagram. - - [ ] Tests (Behave) [Luis]: Add `features/config_project_scope.feature` with scenarios for project-scoped set/get/list and precedence over global defaults. - - [ ] Tests (Robot) [Luis]: Add `robot/config_project_scope.robot` for project-scoped round-trip. - - [ ] Tests (ASV) [Luis]: Add `benchmarks/config_project_scope_bench.py` for resolution with project scope overhead. - - [ ] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark). - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(config): add project-scoped config overrides"` - - [ ] Git [Luis]: `git push -u origin feature/m4-config-project-scope` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-config-project-scope` to `master` with a suitable and thorough description - -**M1 SUCCESS CRITERIA (Day 7 MVP - source code only)**: -- Action created from YAML config and persisted (namespaced name, description, arguments, strategy/execution actors). -- Project created and linked to a local `git-checkout` resource (worktree sandbox enabled). -- Plan use creates Action phase then Strategize/Execute/Apply completes end-to-end on a local git repo with sandbox isolation; Apply ends in `applied`. -- Tool-based change tracking produces a ChangeSet and apply merges to the original working tree only after validations pass. -- `nox` passes with coverage >=97% on the MVP end-to-end path. - ---- - -### Section 4: Projects & Resources [WORKSTREAM B - Hamza Lead] - -**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. - -**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 [Jeff]**: ResourceType model + schema loader (Resource model already landed) - **PARALLEL SUBTRACK B0.builtins [Jeff]**: 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 [Jeff]**: Projects + project_resource_links tables - **PARALLEL SUBTRACK B0.repo.resources [Jeff]**: ResourceType + Resource repositories - **PARALLEL SUBTRACK B0.repo.projects [Jeff]**: Project + ProjectResourceLink repositories - **PARALLEL SUBTRACK B0.services [Jeff]**: 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. - -- [X] **COMMIT (Owner: Jeff | Group: B0.type-model | Branch: feature/m1-resource-type-schema | Planned: Day 7 | Expected: Day 10) - Commit message: "feat(resource): add resource type model + schema loader"** Done: Day 7, February 15, 2026 - - [X] Meta [Jeff]: Only mark this commit complete after every subtask is done and `git commit -m "feat(resource): add resource type model + schema loader"` has executed. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-resource-type-schema` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: 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). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Define `ResourceTypeArgument` fields per spec (`name`, `type`, `required`, `description`, `default`, `validation_pattern`) and validate `name` to map to CLI `--`. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add `ResourceTypeSpec` fields per spec: `user_addable`, `cli_args`, `child_types`, `parent_types`, `auto_discovery`, `equivalence` (virtual only), `handler`, `sandbox_strategy`, and `capabilities` (read/write/sandbox/checkpoint). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Enforce namespaced name rules for custom types; allow unnamespaced built-ins (e.g., `git-checkout`, `fs-directory`) via a dedicated `built_in` flag. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: 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). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: 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. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Add `docs/reference/resource_type_model.md` with minimal examples and validation rules (include git-checkout + fs-directory and physical/virtual notes). Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios for resource type name validation, `cli_args` parsing, `child_types`/`parent_types` constraint validation, and unnamespaced built-in allowance. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add schema loader scenarios for env var interpolation, version mismatch, and handler metadata validation. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot test that loads a ResourceType YAML fixture and asserts required fields are present. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_type_schema_bench.py` for YAML validation throughput. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_type_model_bench.py` for resource type validation and constraint checks. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(resource): add resource type model + schema loader"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-resource-type-schema` to `master` with description "Add resource type domain model + YAML schema loader with tests and docs.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-resource-type-schema` Done: Day 7, February 15, 2026 - - [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%. Done: Day 7, February 15, 2026 - - -- [X] **COMMIT (Owner: Jeff | Group: B0.builtins | Branch: feature/m1-resource-builtins | Done: Day 7, February 15, 2026) - Commit message: "feat(resource): add git-checkout and fs-directory resource types"** - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-resource-builtins` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add built-in resource type YAMLs under `examples/resource-types/` for `git-checkout` and `fs-directory` (schema_version, args, sandbox_strategy). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Mark both as unnamespaced built-ins; `git-checkout` uses `git_worktree` and `--path/--branch`, `fs-directory` uses `copy_on_write` and `--path`. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Add `docs/reference/resource_types_builtin.md` with git-checkout + fs-directory flags and examples. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios asserting built-in YAMLs validate against the schema. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot tests that load both built-in type YAML files. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_type_builtin_bench.py` for built-in YAML load cost. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(resource): add git-checkout and fs-directory resource types"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-resource-builtins` to `master` with description "Add built-in git-checkout and fs-directory resource type configs with docs/tests.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-resource-builtins` Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: B0.db.projects | Branch: feature/m1-project-db | Done: Day 7, February 15, 2026) - Commit message: "feat(db): add projects and project links tables"** - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-project-db` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add Alembic migration for `ns_projects` and `project_resource_links` with explicit down_revision to latest head. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Define `ns_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. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Define `project_resource_links` columns: `link_id` ULID, `project_name` FK, `resource_id` FK, `alias`, `read_only`, `created_at`. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add uniqueness constraint on (`project_name`, `resource_id`) and index on (`project_name`, `alias`). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add indexes on `project_resource_links.project_name` and `project_resource_links.resource_id` for joins. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add ORM models `NamespacedProjectModel` and `ProjectResourceLinkModel` with `to_domain()`/`from_domain()` mapping to `NamespacedProject` + link model and proper JSON field handling. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Document project tables and link constraints in `docs/reference/database_schema.md`. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add migration scenarios verifying project tables and link uniqueness. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot migration smoke test that inserts a project and link row. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/project_migration_bench.py` for migration baseline. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(db): add projects and project links tables"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-project-db` to `master` with description "Add ns_projects + project_resource_links tables with constraints and migration tests.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-project-db` Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Done: Day 7, February 15, 2026 - **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` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add Alembic migration for `resource_types`, `resources`, and `resource_edges` tables with naming conventions. (Migration: `b1_001_resource_registry`, revises `a5_004_spec_aligned_plans`) - - [X] Code [Jeff]: Define `resource_types` columns: `name`, `namespace`, `description`, `resource_kind`, `sandbox_strategy`, `user_addable`, `handler_ref`, `args_schema_json`, `allowed_parent_types_json`, `allowed_child_types_json`, `auto_discover_json`, timestamps. (Also added: `capabilities_json`, `equivalence_json`, `source`) - - [X] Code [Jeff]: Define `resources` columns: ULID PK, `namespaced_name`, `namespace`, `type_name`, `resource_kind`, `location`, `description`, `read_only`, `metadata_json`, `sandbox_strategy`, timestamps. (Also added: `content_hash`, `properties_json`, `auto_discovered`) - - [X] Code [Jeff]: Add check constraints for `resource_kind` enum values and enforce `namespaced_name` uniqueness when non-null. (CHECK constraints on all 3 tables: `ck_resource_types_kind`, `ck_resources_kind`, `ck_resource_edges_no_self_loop`, `ck_resource_edges_link_type`) - - [X] Code [Jeff]: Add FK from `resources.type_name` -> `resource_types.name` with restrict-on-delete to prevent orphaned types. - - [X] Code [Jeff]: Define `resource_edges` columns: `parent_id`, `child_id`, `created_at`, with uniqueness constraint and FK cascade rules. (Also added: `link_type`, `auto_discovered`) - - [X] Code [Jeff]: Add indexes on `resources.namespaced_name`, `resources.namespace`, `resources.type_name`, and `resource_edges.parent_id/child_id`. (Also: `ix_resources_kind`, `ix_resources_content_hash`, `ix_resource_types_*`, `ix_resource_edges_*`) - - [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`) - - [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] Git [Jeff]: `git add .` - - [X] Git [Jeff]: `git commit -m "feat(db): add resource registry tables"` - - [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%) - -- [X] **COMMIT (Owner: Brent | Group: B0.db.resources.tests | Branch: feature/m1-resource-db-robot-tests | Planned: Day 11 | Expected: Day 13) - Commit message: "test(db): add resource registry robot smoke test"** Done: Day 11, February 17, 2026 - - [X] 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. - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m1-resource-db-robot-tests` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] 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. - - [X] Docs [Brent]: Update `docs/reference/database_schema.md` to note the Robot migration smoke suite and how to run it. - - [X] Tests (Behave) [Brent]: Add a migration scenario asserting resource registry tables exist after `nox -s db_migrate`. - - [X] Tests (Robot) [Brent]: Add Robot test that verifies migration execution and table presence. - - [X] Tests (ASV) [Brent]: Confirm `asv/benchmarks/resource_registry_migration_bench.py` still passes after the new Robot suite is added. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(db): add resource registry robot smoke test"` - - [X] 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.". - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/m1-resource-db-robot-tests` - - [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%. - -- [X] **COMMIT (Owner: Jeff | Group: B0.repo.resources | Branch: feature/m1-resource-repos | Planned: Day 9 | Expected: Day 12) - Commit message: "feat(repo): add resource repositories"** Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-resource-repos` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `ResourceTypeRepository` CRUD with list filters (namespace, user_addable) and ordered output. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `ResourceRepository` CRUD with name/ULID resolution and type validation on create. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add repository helpers for `resolve_namespaced_name` and `resolve_ulid` with clear NotFound errors. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Document repository interfaces in `docs/reference/repositories.md` (resource types + resources). Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add repository scenarios for create/get/list and invalid type rejection. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot test that creates a resource and fetches it by name and ULID. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_repository_bench.py` for list/query performance. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(repo): add resource repositories"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-resource-repos` to `master` with description "Add resource repositories with name/ULID resolution, docs, and tests.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-resource-repos` Done: Day 7, February 15, 2026 - - [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%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: B0.repo.projects | Branch: feature/m1-project-repos | Planned: Day 9 | Expected: Day 12 | Done: Day 7, February 15, 2026) - Commit message: "feat(repo): add project repositories"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-project-repos` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Implement `ProjectRepository` CRUD keyed by namespaced name with namespace filtering. - - [X] Code [Jeff]: Implement `ProjectResourceLinkRepository` with link create/list/remove and alias uniqueness enforcement. - - [X] Docs [Jeff]: Document project repositories and link semantics in `docs/reference/repositories.md`. - - [X] Tests (Behave) [Jeff]: Add scenarios for project create, link/unlink, and duplicate alias rejection. - - [X] Tests (Robot) [Jeff]: Add Robot test that links a resource and validates link list output. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/project_repository_bench.py` for link list performance. - - [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(repo): add project repositories"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-project-repos` to `master` with description "Add project repositories + resource link repository with tests/docs.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-project-repos` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: B0.services | Branch: feature/m1-resource-project-services | Planned: Day 10 | Expected: Day 13) - Commit message: "feat(service): wire resource registry and project services"** Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-resource-project-services` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add `ResourceRegistryService` with register/list/show for built-in and custom resource types. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Add startup bootstrap that registers built-in resource type YAMLs if missing (idempotent). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Rework `ProjectService` to use namespaced names, store project invariants + invariant_actor, and link/unlink resources via repositories (no path-based model). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Update DI container wiring for resource/project services and repositories. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Update `docs/reference/project_model.md` with linking rules and name resolution. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add scenarios for resource bootstrap registration and project link/unlink flows. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot test that registers a git-checkout resource and links it to a project. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_service_bench.py` for registry list operations. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(service): wire resource registry and project services"` Done: Day 7, February 15, 2026 - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-resource-project-services` to `master` with description "Wire resource registry + project services with bootstrap registration and tests.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-resource-project-services` Done: Day 7, February 15, 2026 - - [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%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: B0.cli.resources | Branch: feature/m1-resource-cli | Planned: Day 10 | Expected: Day 13) - Commit message: "feat(cli): add resource commands (core)"** Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git pull origin master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout -b feature/m1-resource-cli` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `agents resource type add --config [--update]` and `agents resource type remove [--yes] ` for custom types (built-ins remain read-only). Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `agents resource type list/show` for built-in + custom types with `--format json/yaml` output. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `agents resource add git-checkout --path [--branch ] [--update]` with type validation. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `agents resource list` and `agents resource show` with namespaced name/ULID resolution. Done: Day 7, February 15, 2026 - - [X] Code [Jeff]: Implement `agents resource remove [--yes] ` with FK guardrails. Done: Day 7, February 15, 2026 - - [X] Docs [Jeff]: Update CLI reference with resource type add/remove/list/show and resource add/list/show examples. Done: Day 7, February 15, 2026 - - [X] Tests (Behave) [Jeff]: Add CLI scenarios for resource type add/remove/list/show, resource add/list/show/remove, and invalid type errors. Done: Day 7, February 15, 2026 - - [X] Tests (Robot) [Jeff]: Add Robot CLI test that adds a git-checkout resource and shows it. Done: Day 7, February 15, 2026 - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_cli_bench.py` for CLI parsing overhead. Done: Day 7, February 15, 2026 - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git add .` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git commit -m "feat(cli): add resource commands (core)"` Done: Day 7, February 15, 2026 - - [X] 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.". Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git checkout master` Done: Day 7, February 15, 2026 - - [X] Git [Jeff]: `git branch -d feature/m1-resource-cli` Done: Day 7, February 15, 2026 - - [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%. Done: Day 7, February 15, 2026 - -- [X] **COMMIT (Owner: Jeff | Group: B0.cli.projects | Branch: feature/m1-project-cli | Done: Day 7, February 15, 2026) - Commit message: "feat(cli): add project commands (core)"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-project-cli` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Implement `agents project create [--description ] [--resource ]... [--invariant ]... [--invariant-actor ]` with namespaced name validation. - - [X] Code [Jeff]: Implement `agents project link-resource [--read-only] ` with alias support. - - [X] Code [Jeff]: Implement `agents project unlink-resource [--yes] ` with clear not-found errors. - - [X] Code [Jeff]: Implement `agents project list` and `agents project show` with linked resources and basic metadata. - - [X] Code [Jeff]: Implement `agents project delete [--force] [--yes] ` (hard delete from registry only). - - [X] Docs [Jeff]: Update CLI reference with project create/link/list/show examples. - - [X] Tests (Behave) [Jeff]: Add CLI scenarios for project create, link-resource, unlink-resource, delete, and list/show outputs. - - [X] Tests (Robot) [Jeff]: Add Robot CLI test that creates a project, links a resource, unlinks, and deletes the project. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/project_cli_bench.py` for CLI parsing overhead. - - [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(cli): add project commands (core)"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-project-cli` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: 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 [Jeff]**: fs-mount/fs-directory built-ins + auto_discover rules - **PARALLEL SUBTRACK B1.dag [Jeff]**: 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. - -- [x] **COMMIT (Owner: Jeff | Group: B1.types | Branch: feature/m2-resource-types | Planned: Day 11 | Done: Day 9, February 17, 2026) - Commit message: "feat(resource): add fs-mount and fs-directory types"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m2-resource-types` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Jeff]: Add `examples/resource-types/fs-mount.yaml`, `fs-directory.yaml`, and `fs-file.yaml` with parent/child constraints. - - [x] Code [Jeff]: Add `auto_discover` rules for git-checkout → fs-directory/fs-file and fs-mount → fs-directory/fs-file. - - [x] Docs [Jeff]: Update built-in resource type reference with fs-mount and discovery rules. - - [x] Tests (Behave) [Jeff]: Add scenarios validating fs-mount/fs-directory YAML against schema. - - [x] Tests (Robot) [Jeff]: Add Robot test that loads fs-mount built-in types. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/resource_type_fs_bench.py` for YAML load 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(resource): add fs-mount and fs-directory types"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-resource-types` to `master` with description "Add fs-mount/fs-directory built-in resource types with auto-discovery rules.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m2-resource-types` - - [x] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [x] **COMMIT (Owner: Jeff | Group: B1.dag | Branch: feature/m2-resource-dag | Planned: Day 12 | Done: Day 9, February 17, 2026) - Commit message: "feat(resource): add DAG linking and discovery"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m2-resource-dag` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Jeff]: Implement `link_child`/`unlink_child` in `ResourceRepository` with cycle detection and type compatibility enforcement. - - [x] Code [Jeff]: Add `auto_discover_children(resource_id)` that materializes child resources per type rules. - - [x] Docs [Jeff]: Document DAG rules and auto-discovery behavior in `docs/reference/resource_dag.md`. - - [x] Tests (Behave) [Jeff]: Add scenarios for link/unlink, cycle rejection, and auto_discover creation. - - [x] Tests (Robot) [Jeff]: Add Robot test that links a child and verifies tree output ordering. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/resource_dag_bench.py` for link/auto_discover performance. - - [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(resource): add DAG linking and discovery"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-resource-dag` to `master` with description "Add resource DAG linking, cycle checks, and auto-discovery with tests/docs.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m2-resource-dag` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: B1.cli | Branch: feature/m2-resource-cli-extensions | Planned: Day 13 | Done: Day 18, February 18, 2026) - Commit message: "feat(cli): add resource tree and inspect commands"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m2-resource-cli-extensions` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Implement `agents resource tree` with `--depth` and `--type` filters and deterministic ordering. - - [X] Code [Jeff]: Implement `agents resource inspect` with `--tree` and `--file` options for git-checkout/fs-mount. - - [X] Code [Jeff]: Implement `agents resource link-child`/`unlink-child` to manage DAG edges. - - [X] Docs [Jeff]: Update CLI reference with resource tree/inspect/link examples. - - [X] Tests (Behave) [Jeff]: Add scenarios for tree output ordering and link-child error cases. - - [X] Tests (Robot) [Jeff]: Add Robot test that runs resource tree/inspect on a git-checkout resource. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/resource_cli_tree_bench.py` for CLI overhead baseline. - - [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 coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(cli): add resource tree and inspect commands"` - - [X] Git [Jeff]: `git push -u origin feature/m2-resource-cli-extensions` - - [X] 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.". - -**Parallel Group B2: Project Context Policies (M3)** - **PARALLEL SUBTRACK B2.model [Jeff]**: 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. - -- [X] **COMMIT (Owner: Jeff | Group: B2.model | Branch: feature/m3-project-context-model | Planned: Day 14 | Done: Day 9, February 17, 2026 09:00:52 +0000) - Commit message: "feat(project): add context policy model"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-project-context-model` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add `ProjectContextPolicy` model with `default`/`strategize`/`execute`/`apply` view inheritance rules. - - [X] Code [Jeff]: Add validation for include/exclude resources, include/exclude path globs, and size limits. - - [X] Docs [Jeff]: Add `docs/reference/project_context_policy.md` with view inheritance examples. - - [X] Tests (Behave) [Jeff]: Add scenarios for view inheritance, empty policy defaulting, and invalid values. - - [X] Tests (Robot) [Jeff]: Add Robot test that serializes a policy and validates structure. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/project_context_policy_bench.py` for validation overhead. - - [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(project): add context policy model"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-project-context-model` to `master` with description "Add project context policy model + validation with tests/docs.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m3-project-context-model` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [x] **COMMIT (Owner: Jeff | Group: B2.cli | Branch: feature/m3-project-context-cli | Planned: Day 15 | Done: Day 9, February 17, 2026) - Commit message: "feat(cli): add project context commands"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m3-project-context-cli` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Jeff]: Implement `agents project context set/show` to persist and display context policy views. - - [x] Code [Jeff]: Stub `agents project context inspect/simulate` with `NotImplementedError` and clear messaging (ACMS wiring later). - - [x] Docs [Jeff]: Update CLI reference with project context commands and stub notes. - - [x] Tests (Behave) [Jeff]: Add scenarios for context set/show and stub errors for inspect/simulate. - - [x] Tests (Robot) [Jeff]: Add Robot CLI test that sets and shows context policy. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/project_context_cli_bench.py` for CLI parsing 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(cli): add project context commands"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m3-project-context-cli` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. -**M2 MERGE GATE**: -- Register a git-checkout resource and link it to a project via CLI. -- 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; 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: Milestones M1-M3 (M1 minimal tool runtime, M3 full registry)** - -**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 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. - -- [X] **COMMIT (Owner: Jeff | Group: C0.runtime | Branch: feature/m1-tool-runtime-core | Done: Day 6, February 14, 2026 06:18:35 +0000) - Commit message: "feat(tool): add tool runtime core"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-tool-runtime-core` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add `ToolSpec`, `ToolResult`, and `ToolError` models with namespaced tool names, JSON Schema inputs/outputs, and capability metadata (`read_only`, `writes`, `checkpointable`). - - [X] Code [Jeff]: Implement `ToolRunner` with lifecycle hooks (`discover/activate/execute/deactivate`), strict JSON-serializable IO, and error normalization. - - [X] Code [Jeff]: Add in-memory `ToolRegistry` for built-ins with list/show lookup by namespaced name and type (tool/validation). - - [X] Docs [Jeff]: Add `docs/reference/tool_runtime.md` describing tool lifecycle, capability flags, and error/result semantics. - - [X] Tests (Behave) [Jeff]: Add scenarios for tool registration, missing tool errors, capability flag validation, and lifecycle hook ordering. - - [X] Tests (Robot) [Jeff]: Add Robot test that registers a mock tool and executes it via ToolRunner. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_runtime_bench.py` for tool execution overhead 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(tool): add tool runtime core"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-tool-runtime-core` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: C0.files | Branch: feature/m1-tool-builtins | Done: Day 6, February 14, 2026 07:25:08 +0000) - Commit message: "feat(tool): add built-in file tools"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-tool-builtins` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add built-in file tools (`file.read`, `file.write`, `file.edit`, `file.delete`, `file.list`, `file.search`) with namespaced names. - - [X] Code [Jeff]: Require resource bindings to `fs-directory`/`git-checkout` slots and resolve worktree root for git-checkout. - - [X] Code [Jeff]: Wire built-in tools to ChangeSet capture hooks (create/modify/delete/move events) and include file metadata in entries. - - [X] Docs [Jeff]: Add `docs/reference/builtin_tools.md` describing file tool inputs/outputs and resource slot requirements. - - [X] Tests (Behave) [Jeff]: Add scenarios for each file tool, resource binding resolution, and ChangeSet integration. - - [X] Tests (Robot) [Jeff]: Add Robot test that runs file.write on a git-checkout sandbox and verifies ChangeSet output. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_builtin_file_bench.py` for file tool 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(tool): add built-in file tools"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-tool-builtins` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -**Parallel Group C1.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 [Jeff]**: 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` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add `Tool` model in `src/cleveragents/domain/models/core/tool.py` with namespaced name, description, source type, input/output JSON schema, and capability metadata (`read_only`, `writes`, `checkpointable`, `side_effects`). - - [X] Code [Jeff]: Enforce capability consistency (`read_only` implies `writes=false`; validation of conflicting flags). - - [X] Code [Jeff]: Add `ResourceBinding` model with slot definitions, binding modes (context, static, parameter), and required `access` level (`read_only`/`read_write`). - - [X] Code [Jeff]: Add `Validation` model as Tool subtype with `mode`, `wraps`, and `transform` fields; enforce read-only constraints. - - [X] Code [Jeff]: Enforce Validation output schema includes `passed: bool` plus optional `data`/`message`, and force `writes=false`, `checkpointable=false`, `read_only=true` for validations. - - [X] Code [Jeff]: Enforce namespace collision rules (a Validation and Tool cannot share the same namespaced name). - - [X] Code [Jeff]: Require `transform` when `wraps` is set and validate that `wraps` references an existing Tool name. - - [X] Code [Jeff]: Add enums for ToolSource, ToolType (tool/validation), and ValidationMode. - - [X] Code [Jeff]: Add `docs/schema/tool.schema.yaml` and `docs/schema/validation.schema.yaml` with required fields, `wraps`/`transform` rules, and resource binding definitions. - - [X] Code [Jeff]: Add YAML loader via `Tool.from_config()` and `Validation.from_config()` class methods that validate fields, normalize keys, and return Tool/Validation domain models. (Implemented on models directly rather than separate schema.py to match action.py pattern.) - - [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) - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_model_bench.py` for schema validation throughput (model + YAML loader). (3 benchmark suites) - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, unit_tests 2293 scenarios passed (0 failures), integration_tests 208 passed (0 failures). - - [X] Git [Jeff]: `git add .` (only after coverage check passes) - - [X] Git [Jeff]: `git commit -m "feat(tool): add tool and validation domain models"`. - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-domain` to `master` with description "Add tool + validation domain models, schema loaders, and tests.". - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage is 97% overall (tool.py 99% coverage). - -- [X] **COMMIT (Owner: Brent | Group: C1.tool.domain.tests | Branch: feature/m3-tool-domain-robot | Planned: Day 10 | Expected: Day 14) - Commit message: "test(tool): add robot tool model smoke tests"** - - [X] 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. - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m3-tool-domain-robot` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add `robot/tool_model.robot` smoke tests for Tool/Validation model creation and YAML loader outputs. - - [X] Docs [Brent]: Update `docs/reference/tool_model.md` to mention the Robot smoke suite and how to run it. - - [X] Tests (Behave) [Brent]: Add a scenario in `features/tool_model.feature` that mirrors the Robot smoke expectations for YAML loader outputs. - - [X] Tests (Robot) [Brent]: Add Robot suite that validates tool model creation and validation constraints. - - [X] Tests (ASV) [Brent]: Confirm `benchmarks/tool_model_bench.py` still passes after the new Robot suite is added. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(tool): add robot tool model smoke tests"` — committed 2026-02-17 - - [X] Git [Brent]: `git push -u origin feature/m3-tool-domain-robot` - - [X] Forgejo PR [Brent]: Open PR from `feature/m3-tool-domain-robot` to `master` with a suitable and thorough description. — merged to master via develop-brent-2 PR #132 on 2026-02-20 - - [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%. - -- [X] **COMMIT (Owner: Luis | Group: C1.tool.registry | Branch: feature/m3-tool-registry | Done: Day 6, February 14, 2026 22:14:17 +0000) - Commit message: "feat(tool): add tool registry persistence"** - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git pull origin master` - - [X] Git [Luis]: `git checkout -b feature/m3-tool-registry` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Luis]: Add DB tables for `tools`, `tool_resource_bindings`, and `validation_attachments` with resource-scoped attachments (`resource_id`, `validation_name`, `mode`, `created_at`) and indexes on tool name/type + resource_id. Migration: `alembic/versions/c1_001_tool_registry_tables.py` (depends on `b1_001_resource_registry`). 3 tables, 7 indexes, 3 CHECK constraints, 3 FKs including self-referential `wraps`. - - [X] Code [Luis]: Implement `ToolRegistryRepository` (5 methods: create/get_by_name/list_all/update/delete) + `ValidationAttachmentRepository` (4 methods: attach/detach/list_for_resource/get_by_id) and `ToolRegistryService` (8 methods) with attach/detach by resource and mode validation (required/informational). Custom errors: `DuplicateToolError`, `ToolInUseError`. - - [X] Docs [Luis]: Update `docs/reference/database_schema.md` with 3 new table sections (tools, tool_resource_bindings, validation_attachments), updated ER diagram, migration chain, and source locations. - - [X] Tests (Behave) [Luis]: Add `features/tool_registry.feature` (27 scenarios across 7 groups: create/read/list/update/delete/attachments/service) with `features/steps/tool_registry_steps.py` (598 lines). - - [X] Tests (Robot) [Luis]: Add `robot/tool_registry.robot` (4 integration tests: register-and-get, list-filter, attach-detach, duplicate-reject) with `robot/helper_tool_registry.py` (123 lines). - - [X] Tests (ASV) [Luis]: Add `benchmarks/tool_registry_bench.py` (3 ASV suites, 7 benchmarks: ORM construction, CRUD operations, attachment operations). - - [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(tool): add tool registry persistence"` - - [X] Forgejo PR [Luis]: Open PR from `feature/m3-tool-registry` to `master` with description "Add tool registry persistence with bindings and validation attachments.". - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git branch -d feature/m3-tool-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%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - **Notes (C1.tool.registry)**: - - Migration: `c1_001_tool_registry` depends on `b1_001_resource_registry`. Tables: `tools` (22 cols, PK namespaced name), `tool_resource_bindings` (10 cols, auto PK, CASCADE from tools), `validation_attachments` (8 cols, ULID PK, CASCADE from tools). - - `ToolModel.to_domain()` returns a dict (not a domain object) to decouple persistence from domain until full integration. - - `ToolRegistryRepository.delete()` pre-checks for active validation attachments and raises `ToolInUseError` with count. - - Validation attachments are resource-scoped with optional `project_name` and `plan_id` narrowing per spec. - - Second commit `fix(bench)` (2026-02-15 14:26:22 +0000) fixes `benchmarks/resource_registry_migration_bench.py` to use unique names per iteration, avoiding UNIQUE constraint failures under ASV multi-iteration runs. - - 12 files changed, +2453/-1 lines (main commit); 1 file changed, +12/-4 lines (bench fix). - -- [x] **COMMIT (Owner: Jeff | Group: C1.tool.binding | Branch: feature/m3-tool-binding | Planned: Day 15 | Done: Day 9, February 17, 2026) - Commit message: "feat(tool): add resource binding resolution"** - - [x] Git [Jeff]: `git checkout master` - - [x] Git [Jeff]: `git pull origin master` - - [x] Git [Jeff]: `git checkout -b feature/m3-tool-binding` - - [x] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Jeff]: Implement binding resolution for contextual, static, and parameter bindings with type compatibility checks. - - [x] Docs [Jeff]: Add `docs/reference/tool_bindings.md` with resolution order and examples. - - [x] Tests (Behave) [Jeff]: Add binding resolution scenarios (context vs static vs parameter). - - [x] Tests (Robot) [Jeff]: Add Robot test resolving a bound resource by name. - - [x] Tests (ASV) [Jeff]: Add `benchmarks/binding_resolution_bench.py` for resolution latency. - - [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 resource binding resolution"` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-binding` to `master` with description "Add tool resource binding resolution and docs/tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m3-tool-binding` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -- [X] **COMMIT (Owner: Jeff | Group: C1.tool.cli | Branch: feature/m3-tool-cli | Planned: Day 16 | Done: Day 10, February 18, 2026) - Commit message: "feat(cli): add tool and validation commands"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-tool-cli` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Implement `agents tool add/remove/list/show` with YAML config input, schema validation, `--type` filter, and `--format json|yaml|plain` outputs. - - [X] Code [Jeff]: Implement `agents validation add` and `agents validation attach|detach [--mode required|informational]` (resource-scoped attachments only). - - [X] Docs [Jeff]: Update CLI reference with tool/validation commands and output formats. - - [X] Tests (Behave) [Jeff]: Add CLI scenarios for tool registration and validation attachment lifecycle. - - [X] Tests (Robot) [Jeff]: Add Robot CLI suites for tool and validation commands. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_cli_bench.py` for CLI parsing overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(cli): add tool and validation commands"` - - [X] Git [Jeff]: `git push -u origin feature/m3-tool-cli` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-cli` to `master` with description "Add tool/validation CLI commands with attachment workflows and tests.". - -**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. -- [X] **COMMIT (Owner: Aditya | Group: C0.skill.schema | Branch: feature/m3-skill-schema | Done: Day 8, February 16, 2026 19:52:47 +0530) - 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` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Add `Skill`, `SkillItem`, `SkillToolRef`, `SkillInclude`, and `SkillInlineTool` models in `src/cleveragents/domain/models/core/skill.py` with namespaced naming rules. (475 lines; models: SkillToolRef, SkillInclude, SkillInlineTool, SkillMcpSource, SkillAgentSource, SkillCapabilitySummary, Skill, ResolvedToolEntry, SkillResolver) - - [X] Code [Jeff]: Implement `SkillResolver` to flatten includes into ordered tool lists, de-duplicate tools, and reject cycles with path traces. - - [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) - - [X] Tests (ASV) [Jeff]: Add `asv/benchmarks/skill_resolution_bench.py` for resolver performance. - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). NOTE: lint 0 findings, typecheck 0 errors, unit_tests 2335 scenarios passed (0 failures). - - [X] Git [Jeff]: `git add .` (only after coverage check passes) - - [X] Git [Jeff]: `git commit -m "feat(skill): add skill domain model and resolver"`. - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-domain` to `master` with description "Add skill domain model, resolver, and tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m3-skill-domain` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. Coverage 97% overall (skill.py 98%). - -- [X] **COMMIT (Owner: Brent | Group: C0.skill.domain.tests | Branch: feature/m3-skill-domain-robot | Planned: Day 10 | Expected: Day 14) - Commit message: "test(skill): add robot skill resolver smoke tests"** - - [X] 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. - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m3-skill-domain-robot` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add `robot/skill_resolution.robot` smoke tests for resolver output ordering and include de-duplication. - - [X] Docs [Brent]: Update `docs/reference/skill_resolution.md` to mention the Robot smoke suite and how to run it. - - [X] Tests (Behave) [Brent]: Add a scenario in `features/skill_resolution.feature` that mirrors the Robot smoke expectations. - - [X] Tests (Robot) [Brent]: Add Robot suite that validates resolver output for included skills and inline tools. - - [X] Tests (ASV) [Brent]: Confirm `asv/benchmarks/skill_resolution_bench.py` still passes after the new Robot suite is added. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(skill): add robot skill resolver smoke tests"` — committed 2026-02-17 - - [X] Git [Brent]: `git push -u origin feature/m3-skill-domain-robot` - - [X] Forgejo PR [Brent]: Open PR from `feature/m3-skill-domain-robot` to `master` with a suitable and thorough description. — merged to master via develop-brent-2 PR #132 on 2026-02-20 - - [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%. -- [X] **COMMIT (Owner: Luis | Group: C0.skill.registry | Branch: feature/m3-skill-registry | Done: Day 20, February 19, 2026) - 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: Day 9, February 17, 2026 14:44:40 +0000) - 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 [Jeff]**: 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.registry | Branch: feature/m3-actor-registry | Planned: Day 15 | Done: Day 10, February 18, 2026) - Commit message: "feat(actor): align actor registry persistence"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-actor-registry` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Update actor persistence to store YAML text, compiled metadata, and namespaced names with schema_version tracking. - - [X] Docs [Jeff]: Update `docs/reference/database_schema.md` for actor YAML fields. - - [X] Tests (Behave) [Jeff]: Add scenarios for actor registry add/update/remove with YAML text retention. - - [X] Tests (Robot) [Jeff]: Add Robot test that lists actors and shows YAML metadata. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/actor_registry_bench.py` for registry list performance. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(actor): align actor registry persistence"` - - [X] Git [Jeff]: `git push -u origin feature/m3-actor-registry` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-registry` to `master` with description "Align actor registry persistence with YAML text + metadata.". - -- [ ] **COMMIT (Owner: Jeff | Group: C3.cli | Branch: feature/m3-actor-cli | Planned: Day 16 | Expected: Day 22) - Commit message: "feat(cli): align actor commands to YAML"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m3-actor-cli` - - [ ] 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, namespaced names, and `--format json|yaml|plain` outputs. - - [ ] 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]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(cli): align actor commands to YAML"` - - [ ] Git [Jeff]: `git push -u origin feature/m3-actor-cli` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-actor-cli` to `master` with a suitable and thorough description -- [X] **COMMIT (Owner: Aditya | Group: C3.builtins | Branch: feature/m3-provider-actors | Done: Day -47, December 23, 2025 20:57:14 -0500) - Commit message: "Feat: Harden actor configuration handling with unsafe confirmations, graph descriptors, and actor-based plan coverage."** - - [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: Harden actor configuration handling with unsafe confirmations, graph descriptors, and actor-based plan coverage."` - - [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)** - **NOTE**: C4.adapter merged into C7.mcp (single MCP adapter commit under Aditya). C4.config already completed. - -- [X] **COMMIT (Owner: Aditya | Group: C4.config | Branch: feature/m3-mcp-config | Done: Day 5, February 13, 2026 21:41:16 +0000) - Commit message: "feat(tool): add tool and validation domain models"** - - [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 "feat(tool): add tool and validation domain models"` - - [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) -- [X] **COMMIT (Owner: Jeff | Group: C5.lifecycle | Branch: feature/m2-tool-runtime | Done: Day 6, February 14, 2026 17:09:19 +0000) - Commit message: "feat(tool): add tool lifecycle runtime"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m2-tool-runtime` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Implement `ToolRuntime`/`ToolInstance` interfaces with `discover/activate/execute/deactivate` hooks and lifecycle state tracking. - - [X] Code [Jeff]: Add `ToolExecutionContext` with resolved resource bindings, sandbox paths, plan metadata, and cancellation token. - - [X] Code [Jeff]: Add lifecycle cache with per-plan activation reuse and guaranteed `deactivate` on plan completion/cancel. - - [X] Code [Jeff]: Enforce tool capability flags (read-only/writes/checkpointable) and read-only plan gating at runtime. - - [X] Code [Jeff]: Validate tool inputs/outputs against JSON schema before/after execution; surface schema errors clearly. - - [X] Code [Jeff]: Add tool execution tracing (start/end timestamps, duration, result size) for diagnostics. - - [X] Code [Jeff]: Add cancellation propagation so long-running tools are interrupted on plan cancel. - - [X] Docs [Jeff]: Add `docs/reference/tool_lifecycle.md` describing hook ordering, capability enforcement, and failure handling. - - [X] Docs [Jeff]: Document schema validation behavior and error payload format for tool failures. - - [X] Tests (Behave) [Jeff]: Add lifecycle scenarios for activate/execute/deactivate ordering and error propagation. - - [X] Tests (Robot) [Jeff]: Add `robot/tool_lifecycle.robot` runtime smoke tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_lifecycle_bench.py` for lifecycle overhead. - - [X] Quality [Jeff]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Jeff]: `git add .` (only after nox passes) - - [X] Git [Jeff]: `git commit -m "feat(tool): add tool lifecycle runtime"`. - - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-tool-runtime` to `master` with description "Add tool lifecycle runtime, context, and tests.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m2-tool-runtime` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - -**Parallel Group C1: Actor Schema & Examples [Aditya + Jeff]** (start Day 5; C2 depends on this) -- [X] **COMMIT (Owner: Aditya | Group: C1.schema | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Done: Day 9, February 17, 2026) - Commit message: "feat(actor): add actor yaml schema models"** - - [X] Git [Aditya]: `git checkout master` - - [X] Git [Aditya]: `git pull origin master` - - [X] Git [Aditya]: `git checkout -b feature/m3-actor-schema-examples` - - [X] Git [Aditya]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Aditya]: Add schema models (ActorType, NodeType, ContextView, ToolDefinition, RouteDefinition, ActorConfigSchema) with strict validation in `src/cleveragents/actor/schema.py`. - - [X] Code [Aditya]: Add tool-node schema fields that reference Tool Registry names, including validation nodes, and require input/output schema presence. - - [X] Code [Aditya]: Add hierarchical graph node schema (`children`, `edges`, `entrypoint`, `exitpoints`) to support nested actors and subgraphs. - - [X] Code [Aditya]: Add YAML load/serialize helpers and schema version guard. - - [X] Code [Aditya]: Add graph validation rules (entrypoint exists, exitpoints reachable, no orphan nodes). - - [X] Code [Aditya]: Add cycle detection for actor graphs and explicit errors for invalid loops. - - [X] Docs [Aditya]: Add `docs/reference/actors_schema.md` with field definitions, tool node semantics, and graph constraints. - - [X] Docs [Aditya]: Add graph validation examples (valid/invalid) and error messages. - - [X] Tests (Behave) [Aditya]: Add `features/actor_schema.feature` scenarios for validation and topology errors. - - [X] Tests (Robot) [Aditya]: Add `robot/actor_schema.robot` YAML load smoke test. - - [X] Tests (ASV) [Aditya]: Add `benchmarks/actor_schema_bench.py` for YAML validation cost. - - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Aditya]: `git add .` (only after coverage check passes) - - [X] Git [Aditya]: `git commit -m "feat(actor): add actor yaml schema models"` - - [X] Forgejo PR [Aditya]: Merged via PR #93 on 2026-02-17. - - [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: Aditya | Group: C1.examples | Branch: feature/m3-actor-schema-examples | Planned: Day 12 | Done: Day 10, February 18, 2026) - Commit message: "docs(actor): add comprehensive actor YAML examples documentation"** - - [X] Git [Aditya]: `git checkout -b feature/m3-actor-schema-examples` - - [X] Git [Aditya]: `git fetch origin && git merge origin/master` - - [X] Docs [Aditya]: Add `docs/reference/actors_examples.md` with strategist, executor, reviewer, tool-only, validation-node, and graph YAML examples. (Created comprehensive 1098-line documentation with all patterns) - - [X] Docs [Aditya]: Include hierarchical actor graph examples (graph-with-subgraph, multi-level planner/executor) aligned with spec. (Added multi-level planner/executor and graph-with-subgraph examples) - - [X] Docs [Aditya]: Store example YAML files under `examples/actors/` for automated tests. (5 YAML files created: simple_llm.yaml, llm_with_tools.yaml, tool_collection.yaml, simple_graph.yaml, graph_workflow.yaml) - - [X] Tests (Behave) [Aditya]: Add `features/actor_examples.feature` to ensure all examples validate. (Created 656-line feature file with 25 scenarios, 173 steps - all passing) - - [X] Tests (Behave) [Aditya]: Add `features/steps/actor_examples_steps.py` to implement step definitions. (Created 435-line step definitions file) - - [X] Tests (Robot) [Aditya]: Add `robot/actor_examples.robot` to load each example. (Created 167-line Robot test suite with 16 tests - all passing) - - [X] Tests (Robot) [Aditya]: Add `robot/helper_actor_examples.py` to provide Robot keywords. (Created 151-line helper script) - - [X] Tests (ASV) [Aditya]: Add `benchmarks/actor_examples_load_bench.py` for YAML load throughput. (Created 106-line benchmark file with 7 benchmark classes) - - [X] Quality [Aditya]: Verify coverage >=97% via `nox -s coverage_report`. (Coverage maintained at schema validation level) - - [X] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. (Fixed all test failures: Behave 25/25, Robot 16/16, ASV 7/7 verified) - - [X] Git [Aditya]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Aditya]: `git commit -m "docs(actor): add comprehensive actor YAML examples documentation"` — committed 2026-02-18 - - [ ] Git [Aditya]: `git push -u origin feature/m3-actor-schema-examples` - - [ ] Forgejo PR [Aditya]: Open PR from `feature/m3-actor-schema-examples` to `master` with a suitable and thorough description. NOTE: Branch has additional commits after PR #93 merge; needs a new PR for the examples commits. - -**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. -- [X] **COMMIT (Owner: Aditya | Group: C2.loader | Branch: develop-aditya | Planned: Day 13 | Done: Day 11, February 19, 2026) - Commit message: "feat(actor): add actor registry and loader"** - - [X] Git [Aditya]: `git checkout master` - - [X] Git [Aditya]: `git pull origin master` - - [X] Git [Aditya]: `git checkout -b develop-aditya` - - [X] Git [Aditya]: `git fetch origin && git merge origin/master` - - [X] Code [Aditya]: Implement actor loader/registry with namespaced lookup, cache invalidation, and file discovery in `actors/` and `examples/actors/`. - - [X] Code [Aditya]: Normalize actor file paths, reject non-`.yaml` files, and emit a single consolidated error when duplicates are found across search roots. - - [X] Code [Aditya]: Store and compare a content hash for actor configs to avoid reloading unchanged actors (mtime + hash fallback). - - [X] Code [Aditya]: Add registry integration with Tool Registry so tool nodes resolve at load time. - - [X] Code [Aditya]: Validate actor namespaced names on load and apply default `local/` when namespace omitted. - - [X] Docs [Aditya]: Add `docs/reference/actors_loading.md` with discovery rules and namespaces. - - [X] Tests (Behave) [Aditya]: Add `features/actor_loading.feature` for discovery, duplicates, and namespace lookup. - - [X] Tests (Robot) [Aditya]: Add `robot/actor_loading.robot` for loader smoke tests. - - [X] Tests (ASV) [Aditya]: Add `benchmarks/actor_loading_bench.py` for registry load performance. - - [X] Git [Aditya]: `git commit -m "feat(actor): add actor registry and loader"` — committed 2026-02-19 - - [ ] 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%. - - [ ] Quality [Aditya]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Forgejo PR [Aditya]: Open PR from `develop-aditya` to `master` with a suitable and thorough description. -**Parallel Group C3: Skill Protocol & Context [Jeff]** (critical path; depends on C1) -- [X] **COMMIT (Owner: Jeff | Group: C3.protocol | Branch: feature/m3-skill-protocol | Planned: Day 16 | Done: Day 12, February 20, 2026) - Commit message: "feat(skill): add skill protocol and metadata"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-skill-protocol` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Define Skill protocol interface, SkillMetadata, SkillResult, and SkillError types in `src/cleveragents/skills/protocol.py`. - - [X] Code [Jeff]: Add `SkillDefinition` model that references Tool Registry names and optional inline tool definitions. - - [X] Code [Jeff]: Add error mapping helpers to normalize tool failures into SkillError payloads. - - [X] Code [Jeff]: Require explicit `writes`/`read_only` metadata on skills and propagate to ToolRuntime gating. - - [X] Code [Jeff]: Add schema validation for `inputs`/`outputs` in SkillDefinition to match Tool Registry schemas. - - [X] Docs [Jeff]: Add `docs/reference/skills_protocol.md` describing metadata, tool composition, and JSON schema rules. - - [X] Tests (Behave) [Jeff]: Add `features/skill_protocol.feature` for metadata validation and error capture. - - [X] Tests (Robot) [Jeff]: Add `robot/skill_protocol.robot` smoke tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/skill_protocol_bench.py` for validation throughput. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(skill): add skill protocol and metadata"` - - [X] Git [Jeff]: `git push -u origin feature/m3-skill-protocol` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add skill protocol, metadata models, and tests.". -- [X] **COMMIT (Owner: Jeff | Group: C3.context | Branch: feature/m3-skill-protocol | Planned: Day 17 | Done: Day 12, February 20, 2026) - Commit message: "feat(skill): add skill context and registry"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-skill-protocol` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Implement SkillContext (plan/resource access, sandbox path, change tracker) and SkillRegistry in `src/cleveragents/skills/context.py`. - - [X] Code [Jeff]: Wire SkillRegistry to Tool Registry for tool resolution and validation node inclusion. - - [X] Code [Jeff]: Add context helpers for resolving bound resources and exposing plan metadata. - - [X] Code [Jeff]: Include change tracking hooks so every skill execution registers a ToolInvocation in ChangeSet. - - [X] Code [Jeff]: Ensure SkillContext enforces read-only plan restrictions (block write tools when plan is read-only). - - [X] Docs [Jeff]: Add `docs/reference/skills_context.md` with context fields and helper methods. - - [X] Tests (Behave) [Jeff]: Add `features/skill_context.feature` for sandboxed access and registry resolution. - - [X] Tests (Robot) [Jeff]: Add `robot/skill_context.robot` for registry smoke tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/skill_context_bench.py` for registry resolution overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(skill): add skill context and registry"` - - [X] Git [Jeff]: `git push -u origin feature/m3-skill-protocol` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add skill context, registry, and change tracking hooks.". - - [X] **COMMIT (Owner: Jeff | Group: C3.inline | Branch: feature/m3-skill-protocol | Planned: Day 17 | Expected: Day 24) - Commit message: "feat(skill): add inline tool executor"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-skill-protocol` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` - - [X] Code [Jeff]: Implement inline tool execution with timeouts and restricted environment in `src/cleveragents/skills/inline_executor.py`. - - [X] Code [Jeff]: Ensure inline tools conform to Tool Registry schema and return structured results. - - [X] Code [Jeff]: Add safeguards for file/network access inside inline tools (local-only for MVP). - - [X] Code [Jeff]: Add max runtime and max output size guards; return structured error on timeout/overflow. - - [X] Docs [Jeff]: Add `docs/reference/skills_inline.md` with safety constraints. - - [X] Tests (Behave) [Jeff]: Add `features/skill_inline.feature` for execution and timeout handling. - - [X] Tests (Robot) [Jeff]: Add `robot/skill_inline.robot` for inline tool smoke tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/inline_tool_bench.py` for execution overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(skill): add inline tool executor"` - - [X] Git [Jeff]: `git push -u origin feature/m3-skill-protocol` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-protocol` to `master` with description "Add inline tool executor with safety constraints and tests.". - -**Parallel Group C4: Built-in Skills [Jeff + Luis]** (depends on C3) -- [X] **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"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-skill-file-search` - - [X] Code [Jeff]: Implement ReadFile, WriteFile, EditFile, and DeleteFile tools with read_only enforcement. - - [X] Code [Jeff]: Register tools in Tool Registry with resource bindings for fs/git resources and sandbox path rewrite. - - [X] Code [Jeff]: Add content size limits and encoding normalization (UTF-8) for file tools. - - [X] Code [Jeff]: Add path traversal guards (reject `..` and absolute paths outside sandbox root) and include rejected path in error. - - [X] Code [Jeff]: Make Write/Edit operations atomic (write temp file then replace) to avoid partial writes on failures. - - [X] Code [Jeff]: Add newline normalization option (preserve or enforce LF) with default preserve. - - [X] Code [Jeff]: Add binary file detection for ReadFile and emit explicit error for binary content. - - [X] Docs [Jeff]: Add `docs/reference/skills_file.md` with examples and error cases. - - [X] Docs [Jeff]: Document file size limits and binary file behavior. - - [X] Tests (Behave) [Jeff]: Add `features/skill_file_ops.feature` for read/write/edit/delete flows. - - [X] Tests (Robot) [Jeff]: Add `robot/skill_file_ops.robot` for file ops integration. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/file_tool_bench.py` for read/write throughput. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(skill): add file operation skills"` - - [X] Git [Jeff]: `git push -u origin feature/m3-skill-file-search` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-file-search` to `master` with a suitable and thorough description -- [X] **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"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-skill-file-search` - - [X] Code [Jeff]: Implement ListDir, Glob, and Grep tools with ignore patterns and size limits. - - [X] Code [Jeff]: Register tools in Tool Registry with resource bindings and sandbox awareness. - - [X] Code [Jeff]: Enforce include/exclude glob filters from project context policies. - - [X] Code [Jeff]: Skip binary files and cap per-file match counts to keep output deterministic. - - [X] Code [Jeff]: Add regex compile error handling for Grep with explicit error output. - - [X] Code [Jeff]: Add sorting for glob/list outputs to ensure deterministic ordering. - - [X] Docs [Jeff]: Add `docs/reference/skills_search.md` with examples. - - [X] Docs [Jeff]: Document grep regex behavior and binary file skipping. - - [X] Tests (Behave) [Jeff]: Add `features/skill_search.feature` for listing/globbing/searching. - - [X] Tests (Robot) [Jeff]: Add `robot/skill_search.robot` for search integration. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/search_tool_bench.py` for search performance. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(skill): add directory and search skills"` - - [X] Git [Jeff]: `git push -u origin feature/m3-skill-file-search` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m3-skill-file-search` to `master` with a suitable and thorough description -- [X] **COMMIT (Owner: Luis | Group: C4.git | Branch: feature/m3-skill-git | Done: Day 20, February 19, 2026) - Commit message: "feat(skill): add git operation skills"** - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git pull origin master` - - [X] Git [Luis]: `git checkout -b feature/m3-skill-git` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` - - [X] Code [Luis]: Implement read-only git tools (status, diff, log, blame per spec) for sandboxed repos. - - [X] Code [Luis]: Register git tools in Tool Registry with read-only capability metadata. - - [X] Code [Luis]: Add path guards to ensure git tools only run inside sandbox root. - - [X] Code [Luis]: Normalize git command output (strip color, set `GIT_PAGER=cat`) for deterministic tests. - - [X] Code [Luis]: Add safe environment variables for git execution (disable prompts, set safe.directory). - - [X] Code [Luis]: Add error mapping for common git failures (not a repo, detached HEAD) with explicit messages. - - [X] Docs [Luis]: Add `docs/reference/skills_git.md` clarifying no destructive ops in MVP. - - [X] Docs [Luis]: Document environment variables and safety settings for git tool execution. - - [X] Tests (Behave) [Luis]: Add `features/git_tools.feature` for git tool outputs (16 scenarios). - - [X] Tests (Robot) [Luis]: Add `robot/tool_git_builtins.robot` for git tool integration (5 tests). - - [X] Tests (ASV) [Luis]: Add `benchmarks/git_tool_bench.py` for diff/log performance. - - [X] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. Coverage: 97.1%. - - [X] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Luis]: `git commit -m "feat(skill): add git operation skills"` - - [ ] Git [Luis]: `git push -u origin feature/m3-skill-git` - - [ ] 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.". - -**Parallel Group C5: Tool Routing & Change Tracking [Luis + Jeff]** (depends on C3/C4) -- [X] **COMMIT (Owner: Luis | Group: C5.model | Branch: feature/m3-change-model | Done: Day 20, February 19, 2026) - Commit message: "feat(change): add ChangeSet models and invocation tracker"** - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git pull origin master` - - [X] Git [Luis]: `git checkout -b feature/m3-change-model` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` - - [X] Code [Luis]: Add ToolInvocation model and InMemoryInvocationTracker (Protocol + impl) with plan_id/skill_name/tool_name linkage, sequence ordering, change_ids, provider metadata. - - [X] Code [Luis]: SpecChangeSet stores resource references, sandbox paths, tool metadata, and timestamps via ChangeEntry fields. - - [X] Code [Luis]: Add ChangeSet serialization helper grouped_by_resource() for plan diff output. - - [X] Code [Luis]: Enforce deterministic ordering via sorted_entries() (resource_id, path, timestamp). - - [X] Code [Luis]: Link ToolInvocation to plan_id and skill/tool names for auditability. - - [X] Code [Luis]: Add ChangeType alias for ChangeOperation and per-change field validators (CREATE/DELETE hash consistency). - - [X] Code [Luis]: Content hash fields (before_hash/after_hash) and file mode already in ChangeEntry; added has_integrity_hashes property. - - [X] Code [Luis]: Add normalize_change_path() for repo-relative POSIX path normalization. - - [X] Docs [Luis]: Add `docs/reference/change_tracking.md` describing tool-to-change mapping. - - [X] Tests (Behave) [Luis]: Add `features/change_tracking.feature` with 21 scenarios for ChangeSet aggregation, invocation tracking, path normalization. - - [X] Tests (Robot) [Luis]: Add `robot/change_tracking.robot` with 5 tracker smoke tests. - - [X] Tests (ASV) [Luis]: Add `benchmarks/change_tracking_bench.py` with 4 benchmark suites. - - [X] Quality [Luis]: Verify coverage >=97% via `nox -s coverage_report`. Coverage: 97.7%. - - [X] Quality [Luis]: Run `nox` (all default sessions), all pass. - - [X] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Luis]: `git commit -m "feat(change): add ChangeSet models and invocation tracker"` - - [ ] Git [Luis]: `git push -u origin feature/m3-change-model` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-change-model` to `master` with description "Add ChangeSet models, invocation tracking, and tests.". -- [X] **COMMIT (Owner: Jeff | Group: C5.router | Branch: feature/m3-tool-router | Planned: Day 20 | Expected: Day 20) - Commit message: "feat(change): add tool router for providers"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m3-tool-router` - - [X] Code [Jeff]: Implement ToolCallRouter for OpenAI/Anthropic/LangChain tool schemas with deterministic IDs. - - [X] Code [Jeff]: Add mapping for tool/validation names and argument schemas based on Tool Registry metadata. - - [X] Code [Jeff]: Add tool-call result normalization to match ToolInvocation schema. - - [X] Code [Jeff]: Add provider-specific handling for streaming tool calls (accumulate args + finalize when complete). - - [X] Code [Jeff]: Ensure validation tools are surfaced with `tool_type=validation` in provider payloads. - - [X] Code [Jeff]: Normalize tool schemas to provider limits (field pruning, max description length) with explicit warnings. - - [X] Code [Jeff]: Add stable tool-call ID generation (plan_id + tool_name + sequence) and include in ToolInvocation metadata. - - [X] Code [Jeff]: Add error mapping for provider tool-call failures (timeout, schema error, tool not found) into ToolInvocation.error. - - [X] Code [Jeff]: Add provider metadata capture (model name, provider id, latency) for each tool call. - - [X] Docs [Jeff]: Add `docs/reference/tool_router.md` with provider-specific mappings. - - [X] Tests (Behave) [Jeff]: Add `features/tool_router.feature` for schema mapping. - - [X] Tests (Robot) [Jeff]: Add `robot/tool_router.robot` for routing smoke tests. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/tool_router_bench.py` for routing performance. - - [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 coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(change): add tool router for providers"` - - [X] Git [Jeff]: `git push -u origin feature/m3-tool-router` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m3-tool-router` to `master` with a suitable and thorough description -- [ ] **COMMIT (Owner: Luis | Group: C5.diff | Branch: feature/m3-diff-review | Planned: Day 20 | Expected: Day 22) - 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` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement DiffBuilder and ReviewArtifact models for CLI review. - - [ ] Code [Luis]: Add support for multi-resource diffs and per-resource grouping. - - [ ] Code [Luis]: Add diff output serializers for rich/plain/json formats. - - [ ] Code [Luis]: Include before/after content hashes and file modes in diff metadata for integrity checks. - - [ ] Code [Luis]: Detect binary files and include a binary marker instead of inline diff content. - - [ ] Code [Luis]: Add rename/move detection using path similarity + content hash and render as rename events. - - [ ] Code [Luis]: Add max diff size guard with truncation notes and a `truncated=true` flag in JSON output. - - [ ] Code [Luis]: Ensure diff output ordering is stable (resource name, path, change type). - - [ ] 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 `benchmarks/diff_review_bench.py` for diff building performance. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(change): add diff review artifacts"` - - [ ] Git [Luis]: `git push -u origin feature/m3-diff-review` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m3-diff-review` to `master` with a suitable and thorough description - -**NOTE**: C8.providers (built-in provider actors) DELETED — provider actors already exist via Jeff's combined batch work (5 LLM providers + actor registry). - -**M3 SUCCESS CRITERIA**: -- Actor YAML schema validated; examples load and compile to LangGraph. -- Skills execute via SkillContext; built-in file/dir/search/git skills available. -- Tool-based change tracking (no output parsing) produces ChangeSet and diff review artifacts. -- MCP adapter executes a tool against a test MCP server. -- Agent Skills packages (SKILL.md) load and register as tools with source metadata. -- Built-in provider actors available (`openai/`, `anthropic/`, `openrouter/` as configured). -- Validation pipeline runs validation attachments and blocks apply on required failure. -- Plan lifecycle uses actors for Strategize/Execute and applies ChangeSet after review. -- `nox` passes with coverage >=97% across actor/skill/change-tracking suites. - -**--- MERGE POINT 1: After M3, all workstreams coordinate ---** - ---- - - -### Section 6: Execution Pipeline, Decisions & Invariants [M1-M4] - -**Parallel Group D0: ChangeSet + Apply MVP (M1-critical)** - **PARALLEL SUBTRACK D0.alpha [Jeff]**: ChangeSet model + tool change capture - **SEQUENTIAL MERGE NOTE**: D0.alpha must land before apply pipeline work in M1. - -- [X] **COMMIT (Owner: Jeff | Group: D0.alpha | Branch: feature/m1-changeset-core | Planned: Day 9 | Done: Day 9, February 17, 2026 09:01:17 +0000) - Commit message: "feat(execute): add changeset model and change capture"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-changeset-core` - - [X] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Jeff]: Rebase `tool/builtins/changeset.py` into a spec-aligned ChangeSet domain model (ULID ids, plan_id, resource_id, tool_name, operation, path, before/after hashes, timestamps) and re-export via `domain/models/core` if needed. - - [X] Code [Jeff]: Update ChangeSetCapture to record `resource_id` + `tool_name` and attach timestamps per entry; keep write-only tools only. - - [X] Code [Jeff]: Add execution-scoped ChangeSetStore interface with in-memory implementation for M1; support `start(plan_id)`, `record(entry)`, `get(plan_id)`, `summarize(plan_id)`. - - [X] Code [Jeff]: Wire built-in file tools to pass `resource_id` and `sandbox_root` so ChangeSet entries resolve correctly in multi-resource plans. - - [X] Docs [Jeff]: Add `docs/reference/changeset_model.md` with entry examples and ULID field descriptions. - - [X] Tests (Behave) [Jeff]: Add scenarios for create/modify/delete/move capture and summary counts. - - [X] Tests (Robot) [Jeff]: Add Robot test that runs a file tool and verifies ChangeSet output. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/changeset_capture_bench.py` for change capture overhead. - - [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(execute): add changeset model and change capture"` - - [X] 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.". - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git branch -d feature/m1-changeset-core` - - [X] Quality [Jeff]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - -- [X] **COMMIT (Owner: Jeff | Group: D0b.execute | Branch: feature/m1-plan-execute | Planned: Day 11 | Expected: Day 13) - Commit message: "feat(plan): execute strategize and execute via actors"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m1-plan-execute` - - [X] Code [Jeff]: Add local-only Strategize/Execute stub actors for M1 (no LLM) with interfaces compatible with the actor registry. - - [X] Code [Jeff]: Connect PlanLifecycleService to actor execution for Strategize and Execute phases. - - [X] Code [Jeff]: Ensure Strategize is read-only and records decisions without modifying resources. - - [X] Code [Jeff]: Ensure Execute uses sandbox resources and tool calls routed through ToolRunner + ChangeSet capture; persist `changeset_id` in plan metadata. - - [X] Code [Jeff]: Add phase start/complete/fail status updates with `error_message` + `error_details` capture on failures. - - [X] Code [Jeff]: Persist decision tree root id and strategy decisions into Plan metadata after Strategize completes. - - [X] Code [Jeff]: Propagate project/action invariants into strategize context and record enforcement decisions (stubbed until D2 reconciliation). - - [X] Code [Jeff]: Capture execution metadata (tool_calls count, sandbox_refs) into Plan metadata. - - [X] Code [Jeff]: Add streaming hooks for `--stream` to emit interim status updates during Strategize/Execute. - - [X] Code [Jeff]: Add guard to prevent Execute when Plan is not in Strategize COMPLETE state. - - [X] Docs [Jeff]: Add execute/strategize integration notes, error handling, and retry guidance to `docs/reference/plan_execute.md`. - - [X] Tests (Behave) [Jeff]: Add `features/plan_actor_integration.feature` for strategy/execute flows. - - [X] Tests (Robot) [Jeff]: Add `robot/plan_actor_integration.robot` for end-to-end actor execution. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_actor_integration_bench.py` for execution overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(plan): execute strategize and execute via actors"` - - [X] Git [Jeff]: `git push -u origin feature/m1-plan-execute` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m1-plan-execute` to `master` with a suitable and thorough description. -- [X] **COMMIT (Owner: Jeff | Group: D0b.apply | Branch: feature/m2-plan-apply-review | Planned: Day 12 | Expected: Day 15) - Commit message: "feat(plan): add diff review and apply integration"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m2-plan-apply-review` - - [X] Code [Jeff]: Add `plan diff` output using ChangeSet summaries and per-resource diffs. - - [X] Code [Jeff]: Add `plan artifacts` output including ChangeSet ID, sandbox refs, and apply summary. - - [X] Code [Jeff]: Persist apply summary (files changed, validations) and apply timestamps into Plan metadata for `plan status`. - - [X] Code [Jeff]: Add merge failure handling with sandbox rollback and explicit error output. - - [X] Code [Jeff]: Add guard to prevent Apply when ChangeSet is empty unless `--allow-empty` is set. - - [X] Docs [Jeff]: Update CLI reference for `plan diff`/`plan artifacts` output formats. - - [X] Docs [Jeff]: Add apply error cases and recovery steps (re-run execute, fix validation). - - [X] Tests (Behave) [Jeff]: Add `features/plan_diff_artifacts.feature` for diff/artifact output fields. - - [X] Tests (Robot) [Jeff]: Add `robot/plan_diff_artifacts.robot` for end-to-end diff/artifacts. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/plan_diff_bench.py` for diff rendering overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(plan): add diff review and apply integration"` - - [X] Git [Jeff]: `git push -u origin feature/m2-plan-apply-review` - - [X] Forgejo PR [Jeff]: Open PR from `feature/m2-plan-apply-review` to `master` with a suitable and thorough description - - - - - - -### Section 7: Subplans & Parallelism [M5] - -**Target: Milestone M5 (+25 days)** -**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) -- [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]** - - **SEQUENTIAL ORDER**: E1.1 (Enums) → E1.2 (SubplanConfig) → E1.3 (Plan extension) → E1.4 (SubplanStatus) → E1.5 (Failure rules) → E1.6 (Tests) - - - [X] **E1.1** [Luis] Define execution enums in `src/cleveragents/domain/models/core/plan.py`: - - [X] **E1.1a** [Luis] Define `ExecutionMode` enum: - ```python - class ExecutionMode(str, Enum): - """How subplans should be executed.""" - SEQUENTIAL = "sequential" # One after another, ordered by sequence - PARALLEL = "parallel" # All at once (up to max_parallel) - DEPENDENCY_ORDERED = "dependency_ordered" # Respect DAG dependencies - ``` - - [X] Commit: "feat(domain): define ExecutionMode enum" - - [X] **E1.1b** [Luis] Define `SubplanMergeStrategy` enum (renamed from `MergeStrategy` to avoid collision with infrastructure merge): - ```python - class SubplanMergeStrategy(str, Enum): - """How to merge results from parallel subplans.""" - GIT_THREE_WAY = "git_three_way" # Use git merge-file for code - SEQUENTIAL_APPLY = "sequential_apply" # Apply in completion order - FAIL_ON_CONFLICT = "fail_on_conflict" # Error if any conflicts - LAST_WINS = "last_wins" # Later changes overwrite earlier - ``` - - [X] Commit: "feat(domain): define SubplanMergeStrategy enum" - - [X] **E1.2** [Luis] Define `SubplanConfig` model: - - [X] **E1.2a** [Luis] Create SubplanConfig dataclass: - ```python - class SubplanConfig(BaseModel): - """Configuration for subplan execution.""" - - execution_mode: ExecutionMode = Field( - default=ExecutionMode.SEQUENTIAL, - description="How to execute subplans" - ) - merge_strategy: SubplanMergeStrategy = Field( - default=SubplanMergeStrategy.GIT_THREE_WAY, - description="How to merge subplan results" - ) - max_parallel: int = Field( - default=5, ge=1, le=50, - description="Max concurrent subplans (for PARALLEL mode)" - ) - fail_fast: bool = Field( - default=False, - description="Stop all subplans on first failure" - ) - timeout_per_subplan_seconds: int | None = Field( - default=None, - description="Timeout for each subplan (None=no timeout)" - ) - retry_failed: bool = Field( - default=True, - description="Automatically retry failed subplans" - ) - max_retries: int = Field( - default=2, ge=0, le=5, - description="Max retry attempts per subplan" - ) - ``` - - [X] Commit: "feat(domain): define SubplanConfig model" - - [X] **E1.3** [Luis] Extend Plan model for subplan hierarchy: - - [X] **E1.3a** [Luis] Add parent/root plan fields (verify exist): - ```python - # In PlanIdentity model (already existed from A1) - parent_plan_id: str | None = Field( - default=None, - description="Parent plan ID if this is a subplan" - ) - root_plan_id: str | None = Field( - default=None, - description="Root plan ID (topmost ancestor)" - ) - ``` - - [X] Commit: "feat(domain): verify parent/root plan fields on Plan" - - [X] **E1.3b** [Luis] Add subplan configuration field: - ```python - subplan_config: SubplanConfig | None = Field( - default=None, - description="Config for subplan execution (set on parent plans)" - ) - subplan_statuses: list["SubplanStatus"] = Field( - default_factory=list, - description="Status tracking for spawned subplans" - ) - ``` - - [X] Commit: "feat(domain): add subplan config and status fields to Plan" - - [X] **E1.3c** [Luis] Add computed properties: - ```python - @property - def is_subplan(self) -> bool: - """Check if this plan is a subplan (has parent).""" - return self.parent_plan_id is not None - - @property - def is_root_plan(self) -> bool: - """Check if this is the root plan.""" - return self.root_plan_id is None or self.root_plan_id == self.plan_id - - @property - def depth(self) -> int: - """Distance from root plan (0 for root).""" - # Note: This requires parent chain traversal - # For efficiency, may be cached or stored - if self.is_root_plan: - return 0 - # Computed by service layer traversing parent_plan_id chain - return -1 # Placeholder, computed externally - - @property - def has_subplans(self) -> bool: - """Check if this plan has spawned subplans.""" - return len(self.subplan_statuses) > 0 - ``` - - [X] Commit: "feat(domain): add subplan computed properties to Plan" - - [X] **E1.4** [Luis] Define `SubplanStatus` tracking model: - - [X] **E1.4a** [Luis] Create SubplanStatus dataclass: - ```python - @dataclass - class SubplanStatus: - """Track status of a spawned subplan.""" - - subplan_id: str # The subplan's plan_id - action_name: str # Action used to create subplan - target_resources: list[str] # Resources subplan works on - - # Status tracking - status: ProcessingState = ProcessingState.QUEUED - started_at: datetime | None = None - completed_at: datetime | None = None - - # Results - error: str | None = None - changeset_summary: str | None = None # Brief summary of changes - files_changed: int = 0 - - # Retries - attempt_number: int = 1 - previous_attempts: list["SubplanAttempt"] = field(default_factory=list) - ``` - - [X] Commit: "feat(domain): define SubplanStatus dataclass" - - [X] **E1.4b** [Luis] Define SubplanAttempt for retry tracking: - ```python - @dataclass - class SubplanAttempt: - """Record of a subplan execution attempt.""" - attempt_number: int - started_at: datetime - completed_at: datetime | None - error: str | None - was_retried: bool - ``` - - [X] Commit: "feat(domain): define SubplanAttempt dataclass" - - [X] **E1.5** [Luis] Define subplan failure handling rules: - - [X] **E1.5a** [Luis] Create `SubplanFailureHandler` class: - ```python - class SubplanFailureHandler: - """Handle subplan failures based on configuration.""" - - def should_stop_others( - self, - config: SubplanConfig, - failed_status: SubplanStatus - ) -> bool: - """Determine if other subplans should stop.""" - if config.fail_fast: - return True - if config.execution_mode == ExecutionMode.SEQUENTIAL: - return True # Sequential always stops on failure - return False # Parallel continues others - - def should_retry( - self, - config: SubplanConfig, - status: SubplanStatus - ) -> bool: - """Determine if failed subplan should be retried.""" - if not config.retry_failed: - return False - if status.attempt_number > config.max_retries: - return False - # Don't retry on certain errors - if status.error and "ValidationError" in status.error: - return True # Validation failures can be retried - if status.error and "TimeoutError" in status.error: - return True # Timeouts can be retried - return False - ``` - - [X] Commit: "feat(domain): define SubplanFailureHandler" - - [X] **E1.5b** [Luis] Add failure state constants: - ```python - # Error = application/system bug, likely not recoverable - # Failure = task couldn't complete (tests fail, validation fail), may be retryable - - RETRIABLE_FAILURES = { - "ValidationError", - "TimeoutError", - "TemporaryResourceError", - "MergeConflictError" # May succeed with different merge strategy - } - - NON_RETRIABLE_ERRORS = { - "ConfigurationError", - "AuthenticationError", - "MissingResourceError", - "CircularDependencyError" - } - ``` - - [X] Commit: "feat(domain): define retriable vs non-retriable failures" -- [X] **COMMIT (Owner: Brent | Group: E1.tests | Branch: feature/m5-subplan-tests | Planned: Day 25 | Expected: Day 26 | Done: Day 25) - Commit message: "test(domain): add subplan model suites"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m5-subplan-tests` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add Behave feature coverage for subplan model defaults, hierarchy helpers, and retry metadata. - - [X] Code [Brent]: Add step definitions in `features/steps/subplan_model_steps.py` (plan hierarchy, defaults, dependency validation). - - [X] Docs [Brent]: Update `docs/development/testing.md` with subplan model test coverage notes. - - [X] Tests (Behave) [Brent]: Add `features/subplan_model.feature` scenarios (hierarchy flags, defaults, dependency guardrails). - - [X] Tests (Robot) [Brent]: Add `robot/subplan_model.robot` smoke coverage for CLI/status surface output. - - [X] Tests (ASV) [Brent]: Add `benchmarks/subplan_model_validation_bench.py` for model validation baseline. - - [X] Quality [Brent]: Verify coverage >=97% via `nox -s coverage_report`. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Brent]: `git add .` - - [X] Git [Brent]: `git commit -m "test(domain): add subplan model suites"` - - [X] Git [Brent]: `git push -u origin feature/m5-subplan-tests` - - [X] Forgejo PR [Brent]: Open PR from `feature/m5-subplan-tests` to `master` with description "Add subplan model Behave/Robot suites and benchmarks.". - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/m5-subplan-tests` - - -### Section 8: Large Project Autonomy & Context [M6] - -**Target: Milestone M6 (+30 days)** -**Local-mode only**: large-project autonomy is required; server connectivity remains stubbed. - -**Parallel Group G5b: Output Rendering Framework [Jeff]** (prerequisite for G6.cli polish) - -- [X] **COMMIT (Owner: Jeff | Group: G5b.render | Branch: feature/m4-output-rendering | Planned: Day 20 | Expected: Day 24) - Commit message: "feat(cli): add output rendering framework with materialization strategies"** - - [X] Git [Jeff]: `git checkout master` - - [X] Git [Jeff]: `git pull origin master` - - [X] Git [Jeff]: `git checkout -b feature/m4-output-rendering` - - [X] Code [Jeff]: Implement `OutputSession` context manager that tracks active element handles and manages concurrent producer output without interleaving. - - [X] Code [Jeff]: Implement `ElementHandle` base class with subclasses: `PanelHandle` (titled content blocks), `TableHandle` (structured rows/columns), `StatusHandle` (single-line status updates), and `ProgressHandle` (progress bars with label/tick/indeterminate modes). - - [X] Code [Jeff]: Implement `ProgressHandle` API: `set_progress(fraction)`, `set_label(text)`, `tick()`, and `indeterminate()` mode. Throttle updates in rich mode (max 10 FPS); omit in JSON mode. - - [X] Code [Jeff]: Implement 6 materialization strategies: `RichMaterializer` (in-place terminal updates via Rich), `ColorMaterializer` (ANSI codes without cursor movement), `TableMaterializer` (tabulate-style), `PlainMaterializer` (sequential buffer-flush, ASCII-only), `JsonMaterializer` (accumulate-then-serialize), `YamlMaterializer` (accumulate-then-dump). - - [X] Code [Jeff]: Add materializer selection from `--format` flag with automatic fallback (Rich → Color → Plain when terminal capabilities are insufficient). - - [X] Code [Jeff]: Port existing `format_output()` helper and command-level formatting to produce output through `OutputSession` handles instead of direct `console.print()`. - - [X] Code [Jeff]: Add unified error envelope for JSON/YAML materializers: `{"error": {"code": "...", "message": "...", "details": {...}}}`. - - [X] Docs [Jeff]: Add `docs/reference/output_rendering.md` documenting the OutputSession/ElementHandle architecture, materializer selection, and producer integration guide. - - [X] Tests (Behave) [Jeff]: Add `features/output_rendering.feature` with scenarios for each materializer, progress handle updates, concurrent producers, and format fallback. - - [X] Tests (Robot) [Jeff]: Add `robot/output_rendering.robot` for end-to-end output format verification across commands. - - [X] Tests (ASV) [Jeff]: Add `benchmarks/output_rendering_bench.py` for materializer throughput and progress handle overhead. - - [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] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Jeff]: `git commit -m "feat(cli): add output rendering framework with materialization strategies"` - - [X] Git [Jeff]: `git push -u origin feature/m4-output-rendering` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-output-rendering` to `master` with a suitable and thorough description - - **Implementation Notes (G5b.render):** - - New package: `src/cleveragents/cli/output/` with 4 modules: `handles.py`, `session.py`, `materializers.py`, `selection.py` - - All element snapshot and event data classes use Pydantic `BaseModel` (required by architecture tests) - - `OutputFormat.COLOR` added to `formatting.py` enum; `format_output_session()` bridge function added for backward compatibility - - Behave step definitions use `use_step_matcher("re")` for progress handle creation steps to avoid ambiguous pattern matches - - Vulture whitelist updated with all new public API symbols - - 50 Behave scenarios (233 steps), 1 Robot suite, 1 ASV benchmark file - -**--- MERGE POINT 2: Day 30 - Large Project Autonomy Target (LOCAL MODE ONLY) ---** - -By Day 30, the system must be able to (all in LOCAL MODE, server connectivity is deferred): -- Handle projects with 10,000+ files using hierarchical decomposition. -- Port source code from one language to another autonomously. -- Use hierarchical subplans (5+ levels deep) for large tasks. -- Correct decisions at any point without full re-execution. -- Operate entirely in local mode (ACP/LSP + server client stubs in place, not implemented). - - -**Parallel Group 10A: Async Infrastructure [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: 10A.async | Branch: feature/m6-async-infra | Planned: Day 27 | Expected: Day 36) - Commit message: "feat(async): add async command execution and workers"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-async-infra` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement async command execution per ADR-002 with cancellation and timeout handling. - - [ ] Code [Luis]: Add `AsyncJob` model and `async_jobs` table (plan_id, phase, status, payload_json, created_at, started_at, finished_at). - - [ ] Code [Luis]: Add `AsyncJobStatus` enum and enforce valid transitions (queued -> running -> succeeded/failed/cancelled). - - [ ] Code [Luis]: Add `worker_id` and `last_heartbeat` fields; mark stuck jobs failed after TTL. - - [ ] Code [Luis]: Add AsyncWorker orchestrator with polling loop, max_workers config, and graceful shutdown hooks. - - [ ] Code [Luis]: Add job enqueue hooks for plan execute/apply when async is enabled via config flag (no new CLI flags). - - [ ] Code [Luis]: Add cancellation token support and ensure cancellation propagates to tool execution. - - [ ] Code [Luis]: Add config keys `async.enabled`, `async.max_workers`, `async.poll_interval`, `async.job_timeout`, and `async.job_ttl`. - - [ ] Code [Luis]: Add job cleanup routine to prune completed jobs older than a retention threshold. - - [ ] Code [Luis]: Add worker health report (last_heartbeat, jobs processed) surfaced in `agents diagnostics`. - - [ ] Code [Luis]: Add serialization of async payloads with schema version for forward compatibility. - - [ ] Docs [Luis]: Update `docs/reference/async_architecture.md` with execution flow, job states, and shutdown rules. - - [ ] 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 `benchmarks/async_execution_bench.py` for worker scheduling overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(async): add async command execution and workers"` - - [ ] Git [Luis]: `git push -u origin feature/m6-async-infra` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-async-infra` to `master` with a suitable and thorough description -- [ ] **COMMIT (Owner: Luis | Group: 10A.retry | Branch: feature/m6-async-infra | Planned: Day 28 | Expected: Day 37) - Commit message: "feat(async): wire retry policies into services"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-async-infra` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Integrate retry/circuit breaker policies into service layer operations. - - [ ] Code [Luis]: Add retry policy configuration keys (max_attempts, base_delay, max_delay, jitter) to settings. - - [ ] Code [Luis]: Ensure retries are only applied to idempotent operations (repository reads, validation calls) and never to applies. - - [ ] Code [Luis]: Add `RetryPolicy` and `CircuitBreaker` models with per-service overrides. - - [ ] Code [Luis]: Emit structured logs for retry attempts and circuit-open events. - - [ ] Code [Luis]: Add per-service policy defaults with overrides via config (service_name -> policy mapping). - - [ ] Code [Luis]: Add guard to prevent retries on tool execution writes in read-only plans. - - [ ] Code [Luis]: Add circuit breaker half-open recovery logic and cooldown timers. - - [ ] Docs [Luis]: Document retry policy defaults and override points. - - [ ] 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 `benchmarks/retry_policy_bench.py` for retry overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(async): wire retry policies into services"` - - [ ] Git [Luis]: `git push -u origin feature/m6-async-infra` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m6-async-infra` to `master` with a suitable and thorough description - -**Parallel Group 10B: Selective Quality Review [Brent]** -- [X] **COMMIT (Owner: Brent | Group: 10B.review | Branch: feature/m6-review-playbook | Planned: Day 22 | Done: Day 22) - Commit message: "docs(qa): add review playbook and priority matrix"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m6-review-playbook` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Docs [Brent]: Create `docs/development/review_playbook.md` with focus areas and skip rules. - - [X] Docs [Brent]: Add priority matrix and review SLA guidance. - - [X] Docs [Brent]: Add checklist templates for architecture review, CLI review, and DB migration review. - - [X] Docs [Brent]: Add review checklists for security-sensitive changes (secrets, auth, server stubs) and schema migrations. - - [X] Docs [Brent]: Add a PR review routing table (which reviewer for which subsystem). - - [X] Docs [Brent]: Add examples of acceptable vs blocking findings with remediation guidance. - - [X] Docs [Brent]: Add a required test matrix section for reviewers (nox sessions + coverage). - - [X] Tests (Behave) [Brent]: Add scenarios validating review playbook references exist. - - [X] Tests (Robot) [Brent]: Add docs build smoke test covering the new guide. - - [X] Tests (ASV) [Brent]: Add `benchmarks/docs_build_bench.py` for docs build baseline. - - [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%. - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Brent]: `git add .` (only after nox passes) - - [X] Git [Brent]: `git commit -m "docs(qa): add review playbook and priority matrix"` — committed 2026-02-19 - - [X] Git [Brent]: `git push -u origin feature/m6-review-playbook` - - [X] Forgejo PR [Brent]: Open PR from `feature/m6-review-playbook` to `master` with description "Add review playbook, priority matrix, and tests.". - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git branch -d feature/m6-review-playbook` - -**Parallel Group 10C: Validation Testing Support [Brent + Luis]** -- [X] **COMMIT (Owner: Brent | Group: 10C.edge | Branch: feature/m6-validation-edge | Planned: Day 24 | Done: Day 24) - Commit message: "test(validation): add edge case suites"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m6-validation-edge` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add shared edge-case fixtures under `features/fixtures/validation/`. - - [X] Code [Brent]: Add fixtures for malformed tool outputs, missing resources, and validation timeouts. - - [X] Code [Brent]: Add fixtures for wrapped validation transforms that return invalid schema. - - [X] Code [Brent]: Add fixtures for mixed required/informational validation ordering and duplicate attachment IDs. - - [X] Docs [Brent]: Update `docs/development/testing.md` with validation test catalog. - - [X] Tests (Behave) [Brent]: Add edge-case scenarios for concurrency, conflicts, rollbacks, and timeouts. - - [X] Tests (Robot) [Brent]: Add integration coverage for edge-case suites. - - [X] Tests (ASV) [Brent]: Add `benchmarks/validation_edge_bench.py` for edge-case runtime. - - [X] Git [Brent]: `git commit -m "test(validation): add edge case suites"` — committed 2026-02-20 - - [X] Git [Brent]: `git push -u origin feature/m6-validation-edge` - - [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%. — verified 97% on develop-brent-2 (4437 scenarios, 515 robot tests) on 2026-02-20 - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. — all nox sessions pass on develop-brent-2 (lint, typecheck, unit_tests, integration_tests, coverage_report) on 2026-02-20 - - [X] Forgejo PR [Brent]: Open PR from `feature/m6-validation-edge` to `master` with a suitable and thorough description. — merged to master via develop-brent-2 PR #132 on 2026-02-20 -- [ ] **COMMIT (Owner: Luis | Group: 10C.semantic | Branch: feature/m6-validation-semantic | Planned: Day 25 | Expected: Day 31) - Commit message: "test(validation): add semantic validation suites"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m6-validation-semantic` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add semantic validation fixtures and error-pattern samples. - - [ ] Code [Luis]: Add fixtures for language-porting mismatches and dependency graph violations. - - [ ] Code [Luis]: Add fixtures for API surface changes (renamed functions, missing symbols, incompatible types). - - [ ] Code [Luis]: Add fixtures for cross-file symbol resolution and circular import detection. - - [ ] 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 `benchmarks/semantic_validation_suite_bench.py` for suite runtime. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "test(validation): add semantic validation suites"` - - [ ] Git [Luis]: `git push -u origin feature/m6-validation-semantic` - - [ ] 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` -- [X] **COMMIT (Owner: Brent | Group: 10C.performance | Branch: feature/m6-perf-scale | Planned: Day 26 | Done: Day 26) - Commit message: "test(perf): add scale test fixtures"** - - [X] Git [Brent]: `git checkout master` - - [X] Git [Brent]: `git pull origin master` - - [X] Git [Brent]: `git checkout -b feature/m6-perf-scale` - - [X] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Brent]: Add scale fixtures for 1K/5K/10K file repos in `features/fixtures/scale/`. - - [X] Code [Brent]: Add scriptless fixture generator instructions (documented, no helper scripts). - - [X] Code [Brent]: Add baseline thresholds for indexing and decomposition runtime in a documented matrix. - - [X] Code [Brent]: Add fixture metadata (file count, total size, language mix) for repeatable benchmarks. - - [X] Docs [Brent]: Add scale test runbook and environment notes. - - [X] Tests (Behave) [Brent]: Add scale test scenarios validating thresholds. - - [X] Tests (Robot) [Brent]: Add large-project Robot tests for performance runs. - - [X] Tests (ASV) [Brent]: Add `benchmarks/scale_fixture_bench.py` for baseline performance. - - [X] Git [Brent]: `git commit -m "test(perf): add scale test fixtures"` — committed 2026-02-20 - - [X] Git [Brent]: `git push -u origin feature/m6-perf-scale` - - [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%. — verified 97% on develop-brent-2 (4437 scenarios, 515 robot tests) on 2026-02-20 - - [X] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. — all nox sessions pass on develop-brent-2 (lint, typecheck, unit_tests, integration_tests, coverage_report) on 2026-02-20 - - [X] Forgejo PR [Brent]: Open PR from `feature/m6-perf-scale` to `master` with a suitable and thorough description. — merged to master via develop-brent-2 PR #132 on 2026-02-20 - ---- - -### Section 11: Security & Safety [WORKSTREAM F - Luis + Brent] - -**Target: Throughout project, critical items by Day 14** - -**Note**: Security tasks focus on runtime protections; quality gates are handled in Section 0. - -**Parallel Group SEC1: Remove eval() usage [Luis]** -- [X] **COMMIT (Owner: Luis | Group: SEC1.eval | Branch: feature/m4-security-eval | Planned: Day 11 | Expected: Day 25) - Commit message: "fix(security): remove eval-based config parsing"** - - [X] Git [Luis]: `git checkout master` - - [X] Git [Luis]: `git pull origin master` - - [X] Git [Luis]: `git checkout -b feature/m4-security-eval` - - [X] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Luis]: Audit and remove all `eval`/`exec`/`compile` usage from production config paths. - - [X] Code [Luis]: Replace any dynamic expression parsing with YAML/JSON parsing and explicit schema validation. - - [X] Code [Luis]: Add a hard error if config files contain inline Python or templating directives. - - [X] Code [Luis]: Add config scanner that flags disallowed tokens and reports file+line in errors. - - [X] Docs [Luis]: Add `docs/reference/security_eval.md` with replacement patterns. - - [X] Tests (Behave) [Luis]: Add `features/security_eval.feature` scenarios. (completed by Luis) - - [X] Tests (Robot) [Luis]: Add `robot/security_eval.robot` smoke tests. - - [X] Tests (ASV) [Luis]: Add `benchmarks/security_eval_bench.py` for config parsing baseline. - - [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] Quality [Luis]: Run `nox` (all default sessions, including benchmark). - - [X] Git [Luis]: `git add .` (only after nox passes) - - [X] Git [Luis]: `git commit -m "fix(security): remove eval-based config parsing"` - - [X] Git [Luis]: `git push -u origin feature/m4-security-eval` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-eval` to `master` with description "Remove eval-based config parsing and add security checks.". (Code review by Brent still pending) - -**Parallel Group SEC2: Template Injection Prevention [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: SEC2.template | Branch: feature/m4-security-template | Planned: Day 11 | Expected: Day 26) - Commit message: "fix(security): harden template rendering"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-security-template` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Replace unsafe template usage with a sandboxed renderer and strict token set. - - [ ] Code [Luis]: Deny attribute access, function calls, and filters; allow only `{var}` substitution with a fixed allowlist. - - [ ] Code [Luis]: Add max template length + max render output size checks with explicit errors. - - [ ] Code [Luis]: Add template allowlist validation for each template context key and log rejected keys. - - [ ] Code [Luis]: Add unit helper to pre-validate template strings at action/plan creation time. - - [ ] 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 `benchmarks/security_template_bench.py` for render baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "fix(security): harden template rendering"` - - [ ] Git [Luis]: `git push -u origin feature/m4-security-template` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-template` to `master` with a suitable and thorough description - -**Parallel Group SEC3: Exception Handling Audit [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: SEC3.exceptions | Branch: feature/m4-security-exceptions | Planned: Day 12 | Expected: Day 26) - Commit message: "fix(security): enforce explicit exception handling"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-security-exceptions` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Replace silent exception handling with explicit errors and context propagation. - - [ ] Code [Luis]: Add structured error types for config, provider, and file I/O failures and include plan_id/project_name in error details. - - [ ] Code [Luis]: Ensure unexpected exceptions are wrapped in `CleverAgentsError` with a safe, user-facing message. - - [ ] Code [Luis]: Add error code mapping table (error_code -> HTTP-like category) for CLI output consistency. - - [ ] Code [Luis]: Ensure error details are redacted for secrets before logging. - - [ ] 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 `benchmarks/security_exception_bench.py` for error path overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "fix(security): enforce explicit exception handling"` - - [ ] Git [Luis]: `git push -u origin feature/m4-security-exceptions` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-exceptions` to `master` with a suitable and thorough description - -**Parallel Group SEC4: Async Lifecycle Correctness [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: SEC4.async | Branch: feature/m4-security-async-cleanup | Planned: Day 12 | Expected: Day 26) - Commit message: "fix(security): close async resources and leaks"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-security-async-cleanup` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Close async resources, checkpoint files, and subscription leaks with retention policies. - - [ ] Code [Luis]: Add graceful cancellation handling to ensure in-flight tasks are awaited and cleaned up. - - [ ] Code [Luis]: Add a finalizer hook in async services that logs any leaked resources by name. - - [ ] Code [Luis]: Add cleanup for pending async jobs on shutdown (mark cancelled and persist reason). - - [ ] Code [Luis]: Add time-bounded shutdown sequence with explicit warnings for forced termination. - - [ ] 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 `benchmarks/security_async_cleanup_bench.py` for cleanup overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "fix(security): close async resources and leaks"` - - [ ] Git [Luis]: `git push -u origin feature/m4-security-async-cleanup` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-async-cleanup` to `master` with a suitable and thorough description -**Parallel Group SEC5: Secrets Management [Hamza]** -- [x] **COMMIT (Owner: Hamza | Group: SEC5.secrets | Branch: feature/m4-security-secrets | Planned: Day 13 | Done: Day 11, February 19, 2026) - Commit message: "feat(security): add secrets masking and validation"** - - [x] Git [Hamza]: `git checkout master` - - [x] Git [Hamza]: `git pull origin master` - - [x] Git [Hamza]: `git checkout -b feature/m4-security-secrets` - - [x] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Hamza]: Mask credentials in logs, validate required keys, and block secret leakage in outputs. - - [x] Code [Hamza]: Add a centralized redaction utility (token patterns + config keys) and integrate into CLI output formatting. - - [x] Code [Hamza]: Add `--show-secrets` guard flag (default off) for diagnostics that would otherwise print masked fields. - - [x] Code [Hamza]: Add secret detection for common key patterns (API keys, tokens) in config and env. - - [x] Code [Hamza]: Add redaction for error.details and validation outputs before printing/logging. - - [x] Docs [Hamza]: Add `docs/reference/secrets_handling.md`. - - [x] Docs [Hamza]: Include examples of masked outputs and `--show-secrets` usage. - - [x] Tests (Behave) [Hamza]: Add `features/security_secrets.feature` scenarios. - - [x] Tests (Robot) [Hamza]: Add secrets handling integration smoke tests. - - [x] Tests (ASV) [Hamza]: Add `benchmarks/security_secrets_bench.py` for masking overhead baseline. - - [x] 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%. - - [x] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Hamza]: `git add .` (only after nox passes) - - [x] Git [Hamza]: `git commit -m "feat(security): add secrets masking and validation"` - - [x] Git [Hamza]: `git push -u origin feature/m4-security-secrets` - - [x] Forgejo PR [Hamza]: Open PR from `feature/m4-security-secrets` to `hamza-dev` with description "Add secrets masking/validation and tests.". (PR #87) - - [x] Git [Hamza]: Branch kept for PR review (not deleted yet) - - [x] Git [Hamza]: Branch kept for PR review (not deleted yet) - -**Parallel Group SEC6: Read-Only Enforcement [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: SEC6.readonly | Branch: feature/m4-security-readonly | Planned: Day 13 | Expected: Day 26) - Commit message: "feat(security): enforce read-only actions"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-security-readonly` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Validate read-only actions only use read-only skills at execution time. - - [ ] Code [Luis]: Block write-capable tools in ToolRuntime when plan/action is read-only and include tool name in error. - - [ ] Code [Luis]: Add read-only enforcement to SkillContext and ChangeSet builder to prevent write artifacts. - - [ ] Code [Luis]: Add read-only enforcement in CLI commands that would mutate resources (fail fast before execution). - - [ ] Code [Luis]: Add tests for read-only enforcement on file and git tool calls. - - [ ] 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 `benchmarks/security_readonly_bench.py` for enforcement overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(security): enforce read-only actions"` - - [ ] Git [Luis]: `git push -u origin feature/m4-security-readonly` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-security-readonly` to `master` with a suitable and thorough description - - [ ] Note: Safety profile enforcement is deferred; see Section 18 POST.safety. -**Parallel Group SEC7: Audit Logging [Hamza]** -- [x] **COMMIT (Owner: Hamza | Group: SEC7.audit | Branch: feature/m4-security-audit | Planned: Day 14 | Done: Day 11, February 19, 2026) - Commit message: "feat(security): add audit logging for apply"** - - [x] Git [Hamza]: `git checkout master` - - [x] Git [Hamza]: `git pull origin master` - - [x] Git [Hamza]: `git checkout -b feature/m4-security-audit` - - [x] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Hamza]: Add audit log model, migration, and `agents audit list` CLI command. - - [x] Code [Hamza]: Record apply start/end events with plan_id, actor, resource list, and changeset hash. - - [x] Code [Hamza]: Add CLI filters for `--plan`, `--project`, and `--since` to limit audit output. - - [x] Code [Hamza]: Add `audit show ` command to view a single entry with full metadata. - - [x] Code [Hamza]: Add retention policy for audit logs (configurable days) and prune job. - - [x] Docs [Hamza]: Add `docs/reference/audit_logging.md`. - - [x] Docs [Hamza]: Document audit retention settings and CLI filter semantics. - - [x] Tests (Behave) [Hamza]: Add `features/security_audit.feature` scenarios. - - [x] Tests (Robot) [Hamza]: Add audit logging integration tests. - - [x] Tests (ASV) [Hamza]: Add `benchmarks/security_audit_bench.py` for log write overhead baseline. - - [x] 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 coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Hamza]: `git add .` (only after nox passes) - - [x] Git [Hamza]: `git commit -m "feat(security): add audit logging for apply"` - - [x] Git [Hamza]: `git push -u origin feature/m4-security-audit` - - [x] Forgejo PR [Hamza]: Open PR from `feature/m4-security-audit` to `master` with description "Add audit logging for apply with tests.". - - [x] Git [Hamza]: `git checkout master` - - [x] Git [Hamza]: `git branch -d feature/m4-security-audit` - -### Section 12: Provider Fixes & Runtime Tweaks [WORKSTREAM G - Hamza] - -**Target: Days 8-12** - -**Parallel Group PROV1: Provider Fixes [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: PROV1.fixes | Branch: feature/m4-provider-fixes | Planned: Day 8 | Expected: Day 26) - Commit message: "fix(provider): remove FakeListLLM defaults"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-provider-fixes` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Remove FakeListLLM fallback, fix auto-debug provider usage, and implement provider auto-detection. - - [ ] Code [Luis]: Update settings validation to fail fast when no providers are configured and no mock flag is set. - - [ ] Code [Luis]: Add explicit `core.mock_providers` flag and block accidental use in non-test mode. - - [ ] Code [Luis]: Add provider selection trace logging (chosen provider + reason) for diagnostics output. - - [ ] Code [Luis]: Remove any default provider auto-wiring in container that bypasses settings validation. - - [ ] Code [Luis]: Add unit helper to resolve provider by name and emit explicit error when not configured. - - [ ] Docs [Luis]: Update provider configuration docs and error messages. - - [ ] 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 `benchmarks/provider_selection_bench.py` for provider resolution baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "fix(provider): remove FakeListLLM defaults"` - - [ ] Git [Luis]: `git push -u origin feature/m4-provider-fixes` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-provider-fixes` to `master` with a suitable and thorough description - -**Parallel Group PROV2: Cost Controls & Fallback [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: PROV2.costs | Branch: feature/m4-provider-costs | Planned: Day 10 | Expected: Day 26) - Commit message: "feat(provider): add cost controls and fallback"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-provider-costs` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Track tokens/costs, enforce budgets, rate limits, and provider fallback order. - - [ ] Code [Luis]: Add cost tracking fields to plan execution metadata and surface in `plan status`. - - [ ] Code [Luis]: Add config keys for `budget_per_plan`, `budget_per_day`, and `fallback_providers` with validation. - - [ ] Code [Luis]: Emit warnings when budget is within 10% of limit and block when exceeded. - - [ ] Code [Luis]: Add per-provider cost table and default token cost estimates for offline reporting. - - [ ] Code [Luis]: Add fallback selection logic that skips providers without required capabilities (tool calling, streaming). - - [ ] Code [Luis]: Persist budget exhaustion events in plan metadata for auditability. - - [ ] 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 `benchmarks/cost_controls_bench.py` for cost check overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(provider): add cost controls and fallback"` - - [ ] Git [Luis]: `git push -u origin feature/m4-provider-costs` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-provider-costs` to `master` with a suitable and thorough description - - --- -### Section 13: Additional CLI Commands & UX [Days 10-14] - -**Parallel Group CLI0: Core System Commands [Hamza]** -- [x] **COMMIT (Owner: Hamza | Group: CLI0.core | Branch: feature/m4-cli-core | Planned: Day 10 | Done: Day 10, February 18, 2026) - Commit message: "feat(cli): add version/info/diagnostics"** - - [x] Git [Hamza]: `git checkout master` - - [x] Git [Hamza]: `git pull origin master` - - [x] Git [Hamza]: `git checkout -b feature/m4-cli-core` - - [x] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Hamza]: Implement `version`, `info`, and `diagnostics` commands with rich/plain/json/yaml output parity. - - [x] Code [Hamza]: Add diagnostics checks for config file, database, providers, and filesystem permissions per spec. - - [x] Code [Hamza]: Include build metadata in `version` (semver, git sha, build date) and expose in JSON/YAML outputs. - - [x] Code [Hamza]: Add `diagnostics --check` to exit non-zero when any check fails; report total pass/fail counts. - - [x] Code [Hamza]: Add `diagnostics --format json/yaml` output schema with explicit check names and statuses. - - [x] Code [Hamza]: Add detection for missing data dir and invalid config path with actionable error messages. - - [x] Docs [Hamza]: Update CLI reference with core system commands and sample outputs. - - [x] Docs [Hamza]: Add diagnostics check list and expected remediation steps. - - [x] Tests (Behave) [Hamza]: Add `features/cli_core.feature` scenarios for each command output. - - [x] Tests (Robot) [Hamza]: Add core command smoke tests. - - [x] Tests (ASV) [Hamza]: Add `benchmarks/cli_core_bench.py` for command runtime baseline. - - [x] 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%. - - [x] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Hamza]: `git add .` (only after nox passes) - - [x] Git [Hamza]: `git commit -m "feat(cli): add version/info/diagnostics"` - - [x] Git [Hamza]: `git push -u origin feature/m4-cli-core` - - [x] Forgejo PR [Hamza]: Open PR from `feature/m4-cli-core` to `master` with description "Add core CLI system commands and diagnostics with tests.". - -**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 | Planned: Day 11 | Expected: Day 26) - 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]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(cli): add action and plan CLI extensions"` (run after the coverage check below passes) - - [ ] Git [Jeff]: `git push -u origin feature/m4-cli-extensions` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m4-cli-extensions` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: CLI1.beta | Branch: feature/m4-cli-extension-tests | Planned: Day 12 | Expected: Day 26) - 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]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(cli): cover action and plan extensions"` (run after the coverage check below passes) - - [ ] Git [Brent]: `git push -u origin feature/m4-cli-extension-tests` - - [ ] Forgejo PR [Brent]: Open PR from `feature/m4-cli-extension-tests` to `master` with a suitable and thorough description ---- - -### Section 14: Concurrency & Cleanup [Days 12-14] - -**Parallel Group CONC1: Plan Locking [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: CONC1.lock | Branch: feature/m4-concurrency-locks | Planned: Day 12 | Expected: Day 26) - Commit message: "feat(concurrency): add plan and project locks"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-concurrency-locks` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement plan-level and project-level locks with timeouts. - - [ ] Code [Luis]: Add `locks` table with owner_id, resource_type, resource_id, acquired_at, expires_at. - - [ ] Code [Luis]: Ensure locks are enforced in PlanLifecycleService transitions and SubplanService scheduling. - - [ ] Code [Luis]: Add lock renewal for long-running phases and release locks on graceful shutdown. - - [ ] Code [Luis]: Allow re-entrant lock acquisition for the same owner and reject conflicting owners with explicit error. - - [ ] Code [Luis]: Add lock cleanup routine to purge expired locks on startup. - - [ ] Code [Luis]: Add `agents diagnostics` check to report stale locks count. - - [ ] Docs [Luis]: Add `docs/reference/concurrency.md` with lock behavior. - - [ ] 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 `benchmarks/concurrency_lock_bench.py` for lock overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(concurrency): add plan and project locks"` - - [ ] Git [Luis]: `git push -u origin feature/m4-concurrency-locks` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-concurrency-locks` to `master` with a suitable and thorough description - -**Parallel Group CONC2: Resumable Execution [Luis]** -- [ ] **COMMIT (Owner: Luis | Group: CONC2.resume | Branch: feature/m4-concurrency-resume | Planned: Day 13 | Expected: Day 26) - Commit message: "feat(concurrency): add plan resume"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m4-concurrency-resume` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Persist step-level progress and implement `plan resume` with graceful shutdown handling. - - [ ] Code [Luis]: Add resume checkpoints tied to decision IDs and sandbox checkpoints. - - [ ] Code [Luis]: Validate resume eligibility (non-terminal plans only) and emit clear error for invalid states. - - [ ] Code [Luis]: Add `plan resume --dry-run` to show where execution will resume without changing state. - - [ ] Code [Luis]: Add resume metadata in plan (last_completed_step, last_checkpoint_id). - - [ ] Code [Luis]: Add CLI output for resume summary (phase, step, decision_id) before executing. - - [ ] Docs [Luis]: Update plan lifecycle docs for resume behavior. - - [ ] 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 `benchmarks/plan_resume_bench.py` for resume overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(concurrency): add plan resume"` - - [ ] Git [Luis]: `git push -u origin feature/m4-concurrency-resume` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m4-concurrency-resume` to `master` with a suitable and thorough description -**Parallel Group CONC3: Garbage Collection [Hamza]** -- [x] **COMMIT (Owner: Hamza | Group: CONC3.gc | Branch: feature/m4-concurrency-cleanup | Planned: Day 13 | Done: Day 11, February 19, 2026) - Commit message: "feat(ops): add cleanup commands"** - - [x] Git [Hamza]: `git checkout master` - - [x] Git [Hamza]: `git pull origin master` - - [x] Git [Hamza]: `git checkout -b feature/m4-concurrency-cleanup` - - [x] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [x] Code [Hamza]: Add cleanup for sandboxes, checkpoints, and stale sessions with CLI commands. - - [x] Code [Hamza]: Add retention policy settings for sandbox age, checkpoint count, and session inactivity. - - [x] Code [Hamza]: Add `cleanup --dry-run` output (counts + paths) and `--all` override for full purge. - - [x] Code [Hamza]: Ensure cleanup skips active sandboxes and running plans (log skipped items). - - [x] Code [Hamza]: Add per-resource cleanup summaries (sandboxes/checkpoints/sessions) to output. - - [x] Code [Hamza]: Add config keys for cleanup scheduling (manual-only in MVP; stub schedule flag). - - [x] Docs [Hamza]: Document cleanup commands and retention defaults. - - [x] Docs [Hamza]: Include example `cleanup --dry-run` output and warnings. - - [x] Tests (Behave) [Hamza]: Add `features/garbage_collection.feature` scenarios. - - [x] Tests (Robot) [Hamza]: Add cleanup integration smoke tests. - - [x] Tests (ASV) [Hamza]: Add `benchmarks/cleanup_bench.py` for cleanup overhead baseline. - - [x] 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 coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Hamza]: Run `nox` (all default sessions, including benchmark). - - [x] Git [Hamza]: `git add .` (only after nox passes) - - [x] Git [Hamza]: `git commit -m "feat(ops): add cleanup commands"` - - [x] Git [Hamza]: `git push -u origin feature/m4-concurrency-cleanup` - - [x] Forgejo PR [Hamza]: Open PR from `feature/m4-concurrency-cleanup` to `master` with description "Add cleanup commands and retention policies with tests.". - - -### Section 18: Deferred Work - -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 | Planned: Day 31 | Expected: Day 39) - 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 `examples/resource-types/`: `file`, `directory`, `commit`, `branch`, `tag`, `tree`. - - [ ] Code [Hamza]: Set `resource_kind: virtual`, `user_addable: false`, and no sandbox strategy; encode allowed children per spec. - - [ ] Code [Hamza]: Add equivalence metadata fields (content hash/name/permissions for `file`/`directory`; git object identity for `commit`/`branch`/`tag`/`tree`). - - [ ] Code [Hamza]: Extend bootstrap registration to include these virtual types and hide them from `resource add` scaffolding. - - [ ] 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]: Verify coverage >=97% via `nox -s coverage_report`. If coverage is <97% then review the current unit test coverage report at `build/coverage.xml` and use it to write new Behave based unit tests to improve code coverage. Specifically, write Behave style unit tests that are descriptively named and specifically improves coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. Only mark this as complete once coverage is >=97%, if not repeat this task as many times as is needed until coverage reaches >=97%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add virtual core resource types"` - - [ ] Git [Hamza]: `git push -u origin feature/post-resource-types-virtual-core` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-virtual-core` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.physical | Branch: feature/post-resource-types-physical | Planned: Day 32 | Expected: Day 40) - Commit message: "feat(resource): add deferred physical resource types"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/post-resource-types-physical` - - [ ] 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 for git object taxonomy: `git`, `git-remote`, `git-branch`, `git-tag`, `git-commit`, `git-tree`, `git-tree-entry`, `git-stash`, `git-submodule`. - - [ ] Code [Hamza]: Add filesystem link types: `fs-symlink`, `fs-hardlink` with correct parent/child constraints. - - [ ] Code [Hamza]: Extend auto-discovery rules for git object graph (bounded depth, filtered by type) and fs link detection. - - [ ] 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 `benchmarks/resource_type_deferred_physical_bench.py` for registry load overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred physical resource types"` - - [ ] Git [Hamza]: `git push -u origin feature/post-resource-types-physical` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-physical` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.resource-types.virtual | Branch: feature/post-resource-types-virtual | Planned: Day 33 | Expected: Day 41) - Commit message: "feat(resource): add deferred virtual resource types"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/post-resource-types-virtual` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add built-in virtual resource types: `remote`, `submodule`, `symlink` with equivalence metadata rules. - - [ ] Code [Hamza]: Update registry bootstrap to include deferred virtual types and hide them from `resource add` scaffolding. - - [ ] 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 `benchmarks/resource_type_deferred_virtual_bench.py` for registry load overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add deferred virtual resource types"` - - [ ] Git [Hamza]: `git push -u origin feature/post-resource-types-virtual` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/post-resource-types-virtual` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.safety-profile | Branch: feature/post-safety-profile | Planned: Day 32 | Expected: Day 40) - Commit message: "feat(security): add safety profile model and enforcement stubs"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/post-safety-profile` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add `SafetyProfile` model with allowed skill categories, sandbox/checkpoint requirements, human-approval flag, and max cost/retry limits per spec. - - [ ] Code [Luis]: Add `safety_profile` field to Action model and persistence mapping (no legacy compatibility). - - [ ] Code [Luis]: Add plan-level safety resolution stub (plan > action > project > global) that returns NotImplementedError for enforcement in local mode. - - [ ] 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 `benchmarks/safety_profile_model_bench.py` for validation overhead. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(security): add safety profile model and enforcement stubs"` - - [ ] Git [Luis]: `git push -u origin feature/post-safety-profile` - - [ ] Forgejo PR [Luis]: Open PR from `feature/post-safety-profile` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Brent | Group: POST.safety-profile-tests | Branch: feature/post-safety-profile-tests | Planned: Day 33 | Expected: Day 41) - Commit message: "test(security): cover safety profile enforcement"** - - [ ] Git [Brent]: `git checkout master` - - [ ] Git [Brent]: `git pull origin master` - - [ ] Git [Brent]: `git checkout -b feature/post-safety-profile-tests` - - [ ] Git [Brent]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Tests (Behave) [Brent]: Add scenarios for safety profile allow/deny rules and missing profile errors (stub enforcement expected). - - [ ] Tests (Behave) [Brent]: Add scenarios for cost/retry bounds validation on action creation. - - [ ] Tests (Robot) [Brent]: Add Robot test that verifies safety profile appears in `action show` output. - - [ ] Docs [Brent]: Add test fixture notes for safety profile YAML examples in `docs/development/testing.md`. - - [ ] Tests (ASV) [Brent]: Add `benchmarks/safety_profile_tests_bench.py` for scenario runtime baseline. - - [ ] 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%. - - [ ] Quality [Brent]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Brent]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Brent]: `git commit -m "test(security): cover safety profile enforcement"` - - [ ] Git [Brent]: `git push -u origin feature/post-safety-profile-tests` - - [ ] Forgejo PR [Brent]: Open PR from `feature/post-safety-profile-tests` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.resource | Branch: feature/m7-post-resource-equivalence | Planned: Day 34 | Expected: Day 42) - Commit message: "feat(resource): add virtual resource equivalence tracking"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-equivalence` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add `virtual_resource_links` table mapping virtual resource ULID to physical resource ULIDs with uniqueness constraints. - - [ ] Code [Hamza]: Add `ResourceEquivalenceService` to create/merge virtual resources and update links on content divergence. - - [ ] Code [Hamza]: Add helper to compute equivalence key (hash or name) for auto-linking during resource discovery. - - [ ] Code [Hamza]: Add `agents resource equivalence list/add/remove` CLI to manage equivalence sets (post-M6). - - [ ] Code [Hamza]: Add conflict policy for equivalence (prefer physical over virtual; log divergence events). - - [ ] Code [Hamza]: Add equivalence reconciliation job to re-hash linked resources on schedule. - - [ ] Code [Hamza]: Add guard to prevent linking resources of incompatible types (type mismatch error). - - [ ] Docs [Hamza]: Update `docs/reference/resource_model.md` with physical/virtual equivalence rules and examples. - - [ ] 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 `benchmarks/virtual_resource_bench.py` for equivalence update overhead. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add virtual resource equivalence tracking"` - - [ ] Git [Hamza]: `git push -u origin feature/m7-post-resource-equivalence` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-equivalence` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 35 | Expected: Day 43) - Commit message: "feat(client): add server http client"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-server` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add HTTP client with health check, version negotiation, and OpenAPI codegen integration. - - [ ] Code [Luis]: Add config keys for server base URL, API token, and TLS verification; wire into Settings. - - [ ] Code [Luis]: Map server error responses into domain errors with retry hints. - - [ ] Code [Luis]: Add per-request timeout + retry policy hooks with exponential backoff for idempotent calls. - - [ ] Code [Luis]: Add pagination helpers for list endpoints (actions/skills/tools/projects). - - [ ] Code [Luis]: Add request/response logging with redaction for auth headers. - - [ ] Code [Luis]: Add TLS verification toggle and explicit warning when disabled. - - [ ] Docs [Luis]: Add `docs/reference/server_client_http.md` with configuration and connection errors. - - [ ] 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 `benchmarks/server_http_client_bench.py` for connection overhead baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(client): add server http client"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-server` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 36 | Expected: Day 44) - Commit message: "feat(client): add plan sync and remote execution"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-server` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Sync actions, request remote plan execution/apply/status, and reconcile remote plan IDs. - - [ ] Code [Luis]: Add conflict resolution policy (local wins vs server wins) with explicit CLI errors on ambiguity. - - [ ] Code [Luis]: Add plan sync scope flags (`--actions/--skills/--tools/--projects`) and default to minimal sync. - - [ ] Code [Luis]: Persist server-side IDs in local metadata for later reconciliation. - - [ ] Code [Luis]: Add sync summary output (items created/updated/skipped) for CLI display. - - [ ] Code [Luis]: Add dry-run mode to show what would sync without executing changes. - - [ ] Docs [Luis]: Document sync semantics and conflict handling in `docs/reference/server_sync.md`. - - [ ] 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 `benchmarks/server_sync_bench.py` for sync throughput baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(client): add plan sync and remote execution"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-server` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 37 | Expected: Day 45) - Commit message: "feat(client): add websocket updates"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-server` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add WebSocket client for plan updates with reconnect/backoff policy. - - [ ] Code [Luis]: Define event schema mapping for plan status/progress/log stream updates. - - [ ] Code [Luis]: Add heartbeat/ping handling and resume from last event ID on reconnect. - - [ ] Code [Luis]: Add event version negotiation and explicit error for incompatible server schema. - - [ ] Code [Luis]: Add event de-duplication by event_id and ordered delivery guarantees. - - [ ] Code [Luis]: Add configurable reconnect backoff parameters in settings. - - [ ] Docs [Luis]: Add `docs/reference/server_websocket.md` with event types and reconnect rules. - - [ ] 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 `benchmarks/server_ws_bench.py` for message handling baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(client): add websocket updates"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-server` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-server` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.server | Branch: feature/m7-post-server | Planned: Day 38 | Expected: Day 46) - Commit message: "feat(client): add remote project support"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m7-post-server` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add remote resource selection and server execution request wiring. - - [ ] Code [Hamza]: Add project-name resolution rules for remote namespaces and server aliases. - - [ ] Code [Hamza]: Add `agents project list --remote` and `plan use --remote` scaffolding (server-only). - - [ ] Code [Hamza]: Add explicit error when remote project is not found or user lacks access. - - [ ] Code [Hamza]: Add remote project caching with TTL to minimize repeated server calls. - - [ ] Code [Hamza]: Add CLI output for remote project list (namespace, id, last_updated). - - [ ] Docs [Hamza]: Add `docs/reference/server_remote_projects.md` with project selection semantics. - - [ ] 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 `benchmarks/server_remote_project_bench.py` for request overhead baseline. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(client): add remote project support"` - - [ ] Git [Hamza]: `git push -u origin feature/m7-post-server` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-server` to `master` with a suitable and thorough description - -- [X] **COMMIT (Owner: Rui | Group: POST.repl | Branch: feature/m7-post-repl | Planned: Day 36 | Expected: Day 44) - Commit message: "feat(cli): add interactive repl"** - - [X] Git [Rui]: `git checkout master` - - [X] Git [Rui]: `git pull origin master` - - [X] Git [Rui]: `git checkout -b feature/m7-post-repl` - - [X] Git [Rui]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [X] Code [Rui]: Implement `agents repl` command that dispatches to existing CLI commands with shared config handling. - - [X] Code [Rui]: Add history support with opt-out (`--no-history`) and default path `~/.cleveragents/history`. - - [X] Code [Rui]: Add tab-completion for top-level commands and last command repetition (`!!`). - - [X] Code [Rui]: Add prompt context (active project/plan) and graceful handling of Ctrl+C/Ctrl+D. - - [X] Code [Rui]: Add multi-line input support for long commands and quoted strings. - - [X] Code [Rui]: Add `:help` and `:exit` built-in REPL commands. - - [X] Docs [Rui]: Add REPL usage guide with supported commands and exit behavior. - - [X] Docs [Rui]: Document history file location and privacy considerations. - - [X] Tests (Behave) [Rui]: Add REPL behavior scenarios (history on/off, unknown command, exit). - - [X] Tests (Robot) [Rui]: Add REPL smoke tests for command dispatch. - - [X] Tests (ASV) [Rui]: Add `benchmarks/repl_bench.py` for REPL startup baseline. - - [X] 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 coverage on whichever file has the most uncovered lines by writing tests that will target the uncovered lines in the report. Once that is done rerun `nox -s coverage_report` to verify all tests pass and coverage is above >=97%. 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] Quality [Rui]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [X] Git [Rui]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [X] Git [Rui]: `git commit -m "feat(cli): add interactive repl"` - - [X] Git [Rui]: `git push -u origin feature/m7-post-repl` - - [X] Forgejo PR [Rui]: Open PR from `feature/m7-post-repl` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.auth | Branch: feature/m7-post-auth | Planned: Day 37 | Expected: Day 45) - Commit message: "feat(cli): add auth and team commands"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-auth` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add `agents auth login/logout/status` and `agents team list/use` commands with stubbed responses when server is disabled. - - [ ] Code [Luis]: Add config keys for auth token storage, active team, and default namespace (client-only stubs). - - [ ] Code [Luis]: Wire stubbed commands to `AuthClient` and `ServerClient` interfaces (raise NotImplementedError when no server). - - [ ] Code [Luis]: Add secure token storage via OS keyring (fallback to encrypted file when unavailable). - - [ ] Code [Luis]: Add `auth logout` cleanup to remove tokens and clear active team/namespace. - - [ ] Code [Luis]: Add token format validation and redaction in all outputs. - - [ ] Docs [Luis]: Document auth/team workflows and local-only stub behavior. - - [ ] 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 `benchmarks/auth_cli_bench.py` for auth command baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(cli): add auth and team commands"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-auth` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-auth` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Jeff | Group: POST.tui | Branch: feature/m7-post-tui | Planned: Day 38 | Expected: Day 46) - Commit message: "feat(ui): add TUI/Web interface"** - - [ ] Git [Jeff]: `git checkout master` - - [ ] Git [Jeff]: `git pull origin master` - - [ ] Git [Jeff]: `git checkout -b feature/m7-post-tui` - - [ ] Git [Jeff]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Jeff]: Define UI data-provider interface (plans, sessions, validations, diffs, logs) backed by local services. - - [ ] Code [Jeff]: Implement minimal TUI with plan list, plan detail, diff viewer, and validation summary panes. - - [ ] Code [Jeff]: Add Web UI stub that serves the same data via local-only routes (read-only by default). - - [ ] Code [Jeff]: Add auto-refresh interval config and manual refresh keybinds for TUI. - - [ ] 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 `benchmarks/ui_render_bench.py` for UI render baseline. - - [ ] 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%. - - [ ] Quality [Jeff]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Jeff]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Jeff]: `git commit -m "feat(ui): add TUI/Web interface"` - - [ ] Git [Jeff]: `git push -u origin feature/m7-post-tui` - - [ ] Forgejo PR [Jeff]: Open PR from `feature/m7-post-tui` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.dbresources | Branch: feature/m7-post-resource-db | Planned: Day 39 | Expected: Day 47) - Commit message: "feat(resource): add database resources"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-db` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add database resource types (postgres, mysql, sqlite, duckdb) with connection args and auth handling. - - [ ] Code [Hamza]: Implement sandbox strategy using transaction wrappers and read-only toggles. - - [ ] Code [Hamza]: Add connection validation and safe error messaging (mask credentials in logs). - - [ ] 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 `benchmarks/db_resource_bench.py` for resource registration baseline. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add database resources"` - - [ ] Git [Hamza]: `git push -u origin feature/m7-post-resource-db` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-db` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Hamza | Group: POST.cloud | Branch: feature/m7-post-resource-cloud | Planned: Day 40 | Expected: Day 48) - Commit message: "feat(resource): add cloud infrastructure resources"** - - [ ] Git [Hamza]: `git checkout master` - - [ ] Git [Hamza]: `git pull origin master` - - [ ] Git [Hamza]: `git checkout -b feature/m7-post-resource-cloud` - - [ ] Git [Hamza]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Hamza]: Add cloud resource types (aws, gcp, azure) with credential fields and region/tenant metadata. - - [ ] Code [Hamza]: Add stubbed sandbox strategies that validate configuration and return NotImplementedError for execution. - - [ ] Code [Hamza]: Add credential resolution from environment variables and profile names (no secrets logged). - - [ ] 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 `benchmarks/cloud_resource_bench.py` for resource registration baseline. - - [ ] 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%. - - [ ] Quality [Hamza]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Hamza]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Hamza]: `git commit -m "feat(resource): add cloud infrastructure resources"` - - [ ] Git [Hamza]: `git push -u origin feature/m7-post-resource-cloud` - - [ ] Forgejo PR [Hamza]: Open PR from `feature/m7-post-resource-cloud` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.permissions | Branch: feature/m7-post-permissions | Planned: Day 39 | Expected: Day 47) - Commit message: "feat(security): add permission system"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-permissions` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Implement namespace/project/plan/skill permission model (role bindings, default deny, allow overrides). - - [ ] Code [Luis]: Add enforcement hooks at CLI/service boundaries (server-only; local mode returns permissive defaults). - - [ ] Code [Luis]: Add role enums (owner/admin/editor/viewer) and default role mapping for local mode. - - [ ] 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 `benchmarks/permission_check_bench.py` for enforcement baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(security): add permission system"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-permissions` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-permissions` to `master` with a suitable and thorough description - -- [ ] **COMMIT (Owner: Luis | Group: POST.safety | Branch: feature/m7-post-safety | Planned: Day 40 | Expected: Day 45) - Commit message: "feat(security): add safety profile enforcement"** - - [ ] Git [Luis]: `git checkout master` - - [ ] Git [Luis]: `git pull origin master` - - [ ] Git [Luis]: `git checkout -b feature/m7-post-safety` - - [ ] Git [Luis]: `git fetch origin && git merge origin/master` (run before final tests and before commit) - - [ ] Code [Luis]: Add SafetyProfile model, CLI flags, and execution enforcement hooks (server-only for now). - - [ ] Code [Luis]: Add safety profile resolution order (plan > project > global) with defaults. - - [ ] Code [Luis]: Add policy validation for forbidden tools/resources and explicit denial messages. - - [ ] 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 `benchmarks/safety_profile_bench.py` for enforcement baseline. - - [ ] 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%. - - [ ] Quality [Luis]: Run `nox` (all default sessions, including benchmark), fix any errors if needed ensuring nox passes across **entire** code base, do not ignore any failure even if it seems unrelated to this commit, fix it. - - [ ] Git [Luis]: Perform an appropriate `git add` command to add all the files that should be part of this commit to the git index - - [ ] Git [Luis]: `git commit -m "feat(security): add safety profile enforcement"` - - [ ] Git [Luis]: `git push -u origin feature/m7-post-safety` - - [ ] Forgejo PR [Luis]: Open PR from `feature/m7-post-safety` to `master` with a suitable and thorough description diff --git a/robot/actor_hierarchy.robot b/robot/actor_hierarchy.robot new file mode 100644 index 000000000..0dfd86087 --- /dev/null +++ b/robot/actor_hierarchy.robot @@ -0,0 +1,48 @@ +*** Settings *** +Documentation Smoke tests for hierarchical actor YAML extensions +Resource ${CURDIR}/common.resource +Suite Setup Setup Test Environment +Suite Teardown Cleanup Test Environment + +*** Variables *** +${HELPER} ${CURDIR}/helper_actor_hierarchy.py + +*** Test Cases *** +Discover Hierarchical Actor Example + [Documentation] Load hierarchical workflow example and verify extensions + ${result}= Run Process ${PYTHON} ${HELPER} discover-hierarchical cwd=${WORKSPACE} + Log ${result.stdout} + Log ${result.stderr} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} actor-loaded: workflows/dev-workflow + Should Contain ${result.stdout} skills-count: 2 + Should Contain ${result.stdout} lsp-configured: True + +Parse Actor With LSP Binding + [Documentation] Validate that per-node LSP bindings parse correctly + ${result}= Run Process ${PYTHON} ${HELPER} parse-lsp-binding cwd=${WORKSPACE} + Log ${result.stdout} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} lsp-binding-server: local/pyright + Should Contain ${result.stdout} lsp-binding-langs: python + +Parse Actor With Tool Sources + [Documentation] Validate that per-node tool-source references parse correctly + ${result}= Run Process ${PYTHON} ${HELPER} parse-tool-sources cwd=${WORKSPACE} + Log ${result.stdout} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} tool-sources-count: 2 + +Parse Actor With Subgraph Actor Ref + [Documentation] Validate subgraph node with actor_ref + ${result}= Run Process ${PYTHON} ${HELPER} parse-subgraph-ref cwd=${WORKSPACE} + Log ${result.stdout} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} actor-ref: local/code-reviewer + +Reject Invalid LSP Binding + [Documentation] Reject actor with non-namespaced LSP server + ${result}= Run Process ${PYTHON} ${HELPER} reject-bad-lsp cwd=${WORKSPACE} + Log ${result.stdout} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} validation-error: lsp_binding diff --git a/robot/actor_loading.robot b/robot/actor_loading.robot index a8b775fad..33b2cdc88 100644 --- a/robot/actor_loading.robot +++ b/robot/actor_loading.robot @@ -45,3 +45,14 @@ Default Namespace Applied Log ${result.stdout} Should Be Equal As Integers ${result.rc} 0 Should Contain ${result.stdout} namespace-default-ok: local/bare-name + +Load Hierarchical Actor YAML Via Loader + [Documentation] Discover hierarchical_workflow.yaml via ActorLoader and verify graph properties + ${result}= Run Process ${PYTHON} ${HELPER} discover-hierarchical cwd=${WORKSPACE} + Log ${result.stdout} + Log ${result.stderr} + Should Be Equal As Integers ${result.rc} 0 + Should Contain ${result.stdout} actor-loaded: workflows/dev-workflow + Should Contain ${result.stdout} actor-type: graph + Should Contain ${result.stdout} node-count: 3 + Should Contain ${result.stdout} edge-count: 2 diff --git a/robot/helper_actor_hierarchy.py b/robot/helper_actor_hierarchy.py new file mode 100644 index 000000000..71d1149df --- /dev/null +++ b/robot/helper_actor_hierarchy.py @@ -0,0 +1,193 @@ +"""Robot Framework helper for hierarchical actor YAML smoke tests. + +Usage: + python robot/helper_actor_hierarchy.py discover-hierarchical + python robot/helper_actor_hierarchy.py parse-lsp-binding + python robot/helper_actor_hierarchy.py parse-tool-sources + python robot/helper_actor_hierarchy.py parse-subgraph-ref + python robot/helper_actor_hierarchy.py reject-bad-lsp +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +_SRC = str(Path(__file__).resolve().parents[1] / "src") +if _SRC not in sys.path: + sys.path.insert(0, _SRC) + +from cleveragents.actor.loader import ActorLoader # noqa: E402 +from cleveragents.actor.schema import ActorConfigSchema # noqa: E402 + + +def main() -> int: + if len(sys.argv) < 2: + print("Usage: helper_actor_hierarchy.py ") + return 1 + + cmd = sys.argv[1] + dispatch = { + "discover-hierarchical": _discover_hierarchical, + "parse-lsp-binding": _parse_lsp_binding, + "parse-tool-sources": _parse_tool_sources, + "parse-subgraph-ref": _parse_subgraph_ref, + "reject-bad-lsp": _reject_bad_lsp, + } + handler = dispatch.get(cmd) + if handler is None: + print(f"Unknown command: {cmd}") + return 1 + return handler() + + +def _discover_hierarchical() -> int: + project_root = Path(__file__).resolve().parents[1] + examples_dir = project_root / "examples" / "actors" + loader = ActorLoader(search_roots=[examples_dir]) + actors = loader.discover() + for actor in actors: + if actor.name == "workflows/dev-workflow": + print(f"actor-loaded: {actor.name}") + print(f"skills-count: {len(actor.skills)}") + print(f"lsp-configured: {actor.lsp is not None}") + return 0 + print("actor-not-found: workflows/dev-workflow") + return 1 + + +def _parse_lsp_binding() -> int: + data = { + "name": "local/lsp-test", + "type": "graph", + "description": "LSP binding test", + "model": "gpt-4", + "route": { + "nodes": [ + { + "id": "coder", + "type": "agent", + "name": "Coder", + "description": "Codes with LSP", + "config": {"model": "gpt-4"}, + "lsp_binding": { + "server": "local/pyright", + "languages": ["python"], + }, + }, + ], + "edges": [], + "entry_node": "coder", + "exit_nodes": ["coder"], + }, + } + config = ActorConfigSchema.model_validate(data) + node = config.route.nodes[0] # type: ignore[union-attr] + if node.lsp_binding: + print(f"lsp-binding-server: {node.lsp_binding.server}") + print(f"lsp-binding-langs: {', '.join(node.lsp_binding.languages)}") + return 0 + + +def _parse_tool_sources() -> int: + data = { + "name": "local/ts-test", + "type": "graph", + "description": "Tool sources test", + "model": "gpt-4", + "route": { + "nodes": [ + { + "id": "exec", + "type": "agent", + "name": "Executor", + "description": "Executor with tool sources", + "config": {}, + "tool_sources": [ + {"type": "skill", "name": "local/file-ops"}, + {"type": "mcp", "name": "local/filesystem"}, + ], + }, + ], + "edges": [], + "entry_node": "exec", + "exit_nodes": ["exec"], + }, + } + config = ActorConfigSchema.model_validate(data) + node = config.route.nodes[0] # type: ignore[union-attr] + print(f"tool-sources-count: {len(node.tool_sources)}") + return 0 + + +def _parse_subgraph_ref() -> int: + data = { + "name": "local/sg-test", + "type": "graph", + "description": "Subgraph ref test", + "model": "gpt-4", + "route": { + "nodes": [ + { + "id": "main", + "type": "agent", + "name": "Main", + "description": "Main agent", + "config": {}, + }, + { + "id": "review", + "type": "subgraph", + "name": "Review", + "description": "Subgraph review", + "actor_ref": "local/code-reviewer", + }, + ], + "edges": [{"from_node": "main", "to_node": "review"}], + "entry_node": "main", + "exit_nodes": ["review"], + }, + } + config = ActorConfigSchema.model_validate(data) + node = config.route.nodes[1] # type: ignore[union-attr] + print(f"actor-ref: {node.actor_ref}") + return 0 + + +def _reject_bad_lsp() -> int: + data = { + "name": "local/bad-lsp-test", + "type": "graph", + "description": "Bad LSP test", + "model": "gpt-4", + "route": { + "nodes": [ + { + "id": "n", + "type": "agent", + "name": "N", + "description": "Bad LSP", + "config": {}, + "lsp_binding": {"server": "no-slash"}, + }, + ], + "edges": [], + "entry_node": "n", + "exit_nodes": ["n"], + }, + } + try: + ActorConfigSchema.model_validate(data) + print("validation-unexpected-success") + return 1 + except Exception as exc: + err = str(exc).lower() + if "lsp_binding" in err: + print("validation-error: lsp_binding") + else: + print(f"validation-error-other: {exc}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/robot/helper_actor_loading.py b/robot/helper_actor_loading.py index f7587a782..66e44cfb7 100644 --- a/robot/helper_actor_loading.py +++ b/robot/helper_actor_loading.py @@ -6,6 +6,7 @@ and loading. Exit code 0 = success, 1 = failure. Usage: python robot/helper_actor_loading.py discover python robot/helper_actor_loading.py discover-examples + python robot/helper_actor_loading.py discover-hierarchical python robot/helper_actor_loading.py discover-invalid python robot/helper_actor_loading.py namespace-default """ @@ -38,6 +39,10 @@ def main() -> int: project_root = Path(__file__).resolve().parents[1] return _discover(project_root / "examples" / "actors") + if command == "discover-hierarchical": + project_root = Path(__file__).resolve().parents[1] + return _discover_hierarchical(project_root / "examples" / "actors") + if command == "discover-invalid": directory = sys.argv[2] return _discover_invalid(Path(directory)) @@ -58,6 +63,25 @@ def _discover(directory: Path) -> int: return 0 +def _discover_hierarchical(examples_dir: Path) -> int: + """Load the hierarchical workflow example via ActorLoader and print key stats.""" + loader = ActorLoader(search_roots=[examples_dir]) + actors = loader.discover() + target = next((a for a in actors if a.name == "workflows/dev-workflow"), None) + if target is None: + print("hierarchical-actor-not-found") + return 1 + print(f"actor-loaded: {target.name}") + print(f"actor-type: {target.type.value}") + route = target.route + if route is not None: + print(f"node-count: {len(route.nodes)}") + print(f"edge-count: {len(route.edges)}") + lsp_configured = bool(getattr(target, "lsp", None)) + print(f"lsp-configured: {lsp_configured}") + return 0 + + def _discover_invalid(directory: Path) -> int: loader = ActorLoader(search_roots=[directory]) try: diff --git a/src/cleveragents/actor/loader.py b/src/cleveragents/actor/loader.py index 659c54f4a..b0f900bb3 100644 --- a/src/cleveragents/actor/loader.py +++ b/src/cleveragents/actor/loader.py @@ -127,7 +127,14 @@ class ActorLoader: try: raw = yaml.safe_load(content) except yaml.YAMLError as exc: - errors.append(f"Invalid YAML in {path.name}: {exc}") + mark = getattr(exc, "problem_mark", None) + location = ( + f" at line {mark.line + 1}, column {mark.column + 1}" + if mark is not None + else "" + ) + problem = getattr(exc, "problem", str(exc)) + errors.append(f"Invalid YAML in {path.name}{location}: {problem}") continue if not isinstance(raw, dict): @@ -141,7 +148,26 @@ class ActorLoader: try: config = ActorConfigSchema.model_validate(raw) except Exception as exc: - errors.append(f"Schema validation failed for {path.name}: {exc}") + from pydantic import ValidationError as PydanticValidationError + + if isinstance(exc, PydanticValidationError): + field_errors = [] + for err in exc.errors(): + field_path = ".".join(str(loc) for loc in err["loc"]) + field_errors.append(f" {field_path}: {err['msg']}") + detail = "\n".join(field_errors) + hint = ( + " Hint: see docs/reference/actor_config.md " + "for the correct schema format." + ) + errors.append( + f"Schema validation failed for {path.name}:" + f"\n{detail}\n{hint}" + ) + else: + errors.append( + f"Schema validation failed for {path.name}: {exc}" + ) continue name = config.name diff --git a/src/cleveragents/actor/schema.py b/src/cleveragents/actor/schema.py index b136bd2ea..b22132213 100644 --- a/src/cleveragents/actor/schema.py +++ b/src/cleveragents/actor/schema.py @@ -272,6 +272,89 @@ class ContextConfigSchema(BaseModel): ) +# ============================================================================ +# LSP and Tool-Source Models (for per-node bindings) +# ============================================================================ + + +class NodeLspBinding(BaseModel): + """Per-node LSP server binding configuration. + + Allows individual graph nodes to override or specify their own LSP + server bindings independently of the actor-level ``lsp`` setting. + + Three binding modes: + 1. Explicit: set ``server`` to a namespaced server name. + 2. Language-based: set ``languages`` to match servers by language. + 3. Auto: set ``auto=True`` to let the runtime resolve automatically. + + Attributes: + server: Namespaced LSP server name (e.g. ``local/pyright``). + languages: Languages for language-based binding resolution. + auto: If ``True``, runtime resolves servers from project resources. + capabilities: Optional capability filter for this node. + """ + + server: str | None = Field(default=None, description="LSP server name") + languages: list[str] = Field( + default_factory=list, description="Languages for binding" + ) + auto: bool = Field(default=False, description="Auto-resolve binding") + capabilities: list[str] | None = Field( + default=None, description="LSP capability filter" + ) + + @field_validator("server") + @classmethod + def validate_server_namespace(cls, v: str | None) -> str | None: + if v is not None and "/" not in v: + msg = f"lsp_binding.server must be namespaced (namespace/name): '{v}'" + raise ValueError(msg) + return v + + +class ToolSourceRef(BaseModel): + """Reference to a tool source available to a graph node. + + Allows nodes to declare where their tools come from — skills, + MCP servers, or builtin tool groups. + + Attributes: + type: Source type (``skill``, ``mcp``, ``builtin``, ``custom``). + name: Namespaced name for skill/mcp sources. + group: Group identifier for builtin sources. + """ + + type: str = Field(..., description="Source type: skill, mcp, builtin, custom") + name: str | None = Field(default=None, description="Namespaced source name") + group: str | None = Field(default=None, description="Builtin group name") + + @field_validator("type") + @classmethod + def validate_source_type(cls, v: str) -> str: + allowed = {"skill", "mcp", "builtin", "custom"} + if v not in allowed: + msg = f"tool_sources type must be one of {sorted(allowed)}, got '{v}'" + raise ValueError(msg) + return v + + +class LspContextEnrichment(BaseModel): + """Controls automatic LSP context enrichment injected into ACMS. + + Attributes: + diagnostics: Inject file diagnostics into context (default True). + type_annotations: Inject type info into context (default False). + max_diagnostics_per_file: Cap on diagnostics per file (default 50). + """ + + diagnostics: bool = Field(default=True, description="Inject diagnostics") + type_annotations: bool = Field(default=False, description="Inject type annotations") + max_diagnostics_per_file: int = Field( + default=50, description="Max diagnostics per file" + ) + + # ============================================================================ # Graph Models (for ActorType.GRAPH - multi-node workflows) # ============================================================================ @@ -357,6 +440,16 @@ class NodeDefinition(BaseModel): name: str = Field(..., description="Node name") description: str = Field(..., description="Node description") config: dict[str, Any] = Field(default_factory=dict, description="Node config") + lsp_binding: NodeLspBinding | None = Field( + default=None, description="Per-node LSP binding" + ) + tool_sources: list[ToolSourceRef] = Field( + default_factory=list, description="Tool source references" + ) + actor_ref: str | None = Field( + default=None, + description="Namespaced actor reference for subgraph nodes", + ) @field_validator("id") @classmethod @@ -367,6 +460,15 @@ class NodeDefinition(BaseModel): raise ValueError(msg) return v + @field_validator("actor_ref") + @classmethod + def validate_actor_ref(cls, v: str | None) -> str | None: + """Ensure actor_ref follows namespace/name format when set.""" + if v is not None and "/" not in v: + msg = f"actor_ref must be namespaced (namespace/name): '{v}'" + raise ValueError(msg) + return v + class RouteDefinition(BaseModel): """ @@ -427,8 +529,16 @@ class RouteDefinition(BaseModel): """Ensure all node IDs are unique.""" ids = [node.id for node in v] if len(ids) != len(set(ids)): - duplicates = [id for id in ids if ids.count(id) > 1] - msg = f"Duplicate node IDs found: {set(duplicates)}" + seen: set[str] = set() + duplicates: list[str] = [] + for nid in ids: + if nid in seen and nid not in duplicates: + duplicates.append(nid) + seen.add(nid) + msg = ( + f"route.nodes: Duplicate node IDs found: " + f"{duplicates}. Each node ID must be unique." + ) raise ValueError(msg) return v @@ -437,30 +547,75 @@ class RouteDefinition(BaseModel): Validate all node references in edges and entry/exit points. Raises: - ValueError: If any reference points to non-existent node + ValueError: If any reference points to non-existent node. + Messages include field paths for precise debugging. """ node_ids = {node.id for node in self.nodes} + valid_list = ", ".join(sorted(node_ids)) if node_ids else "(none)" - # Validate entry node if self.entry_node not in node_ids: - msg = f"Entry node '{self.entry_node}' not found in nodes" + msg = ( + f"Entry node '{self.entry_node}' not found in " + f"route.entry_node. Valid node IDs: [{valid_list}]" + ) raise ValueError(msg) - # Validate exit nodes for exit_node in self.exit_nodes: if exit_node not in node_ids: - msg = f"Exit node '{exit_node}' not found in nodes" + msg = ( + f"Exit node '{exit_node}' not found in " + f"route.exit_nodes. Valid node IDs: [{valid_list}]" + ) raise ValueError(msg) - # Validate edge references - for edge in self.edges: + for idx, edge in enumerate(self.edges): if edge.from_node not in node_ids: - msg = f"Edge from_node '{edge.from_node}' not found in nodes" + msg = ( + f"Edge from_node '{edge.from_node}' not found at " + f"route.edges[{idx}]. Valid node IDs: [{valid_list}]" + ) raise ValueError(msg) if edge.to_node not in node_ids: - msg = f"Edge to_node '{edge.to_node}' not found in nodes" + msg = ( + f"Edge to_node '{edge.to_node}' not found at " + f"route.edges[{idx}]. Valid node IDs: [{valid_list}]" + ) raise ValueError(msg) + # Check all nodes are reachable from entry_node via BFS. + # Adjacency is built from both explicit edges and implicit routing + # targets embedded in conditional node configs (route_to keys). + adj: dict[str, list[str]] = {node.id: [] for node in self.nodes} + for edge in self.edges: + adj[edge.from_node].append(edge.to_node) + for node in self.nodes: + if node.type == NodeType.CONDITIONAL and isinstance(node.config, dict): + for cond in node.config.get("conditions", []): + if isinstance(cond, dict) and "route_to" in cond: + target = str(cond["route_to"]) + if target in node_ids: + adj[node.id].append(target) + + reachable: set[str] = set() + queue: list[str] = [self.entry_node] + while queue: + current = queue.pop() + if current in reachable: + continue + reachable.add(current) + queue.extend(adj.get(current, [])) + + unreachable = sorted(node_ids - reachable) + if unreachable: + nodes_str = ", ".join(f"'{n}'" for n in unreachable) + msg = ( + f"route: nodes {nodes_str} are unreachable from entry node " + f"'{self.entry_node}' at route.nodes. " + "Hint: add edges connecting these nodes to the graph " + "or remove them." + ) + raise ValueError(msg) + def detect_cycles(self) -> list[str]: """ Detect cycles in the graph using DFS. @@ -582,6 +737,27 @@ class ActorConfigSchema(BaseModel): default=None, description="Graph topology (for GRAPH type)" ) + # Skills + skills: list[str] = Field( + default_factory=list, + description="Namespaced skill references (e.g. local/file-ops)", + ) + + # LSP configuration + lsp: list[str] | dict[str, Any] | None = Field( + default=None, + description="LSP server bindings: list of server names, " + "language-based object, or {auto: true}", + ) + lsp_capabilities: list[str] | str | None = Field( + default=None, + description="LSP capability filter: list or 'all'", + ) + lsp_context_enrichment: LspContextEnrichment | None = Field( + default=None, + description="Automatic LSP context enrichment settings", + ) + # Environment variables env_vars: dict[str, str] = Field( default_factory=dict, description="Environment variable mappings" @@ -639,7 +815,12 @@ class ActorConfigSchema(BaseModel): self.route.validate_references() cycles = self.route.detect_cycles() if cycles: - msg = f"Graph contains cycles involving nodes: {cycles}" + nodes_str = " → ".join(cycles) + msg = ( + f"route: graph contains a cycle involving " + f"nodes: [{nodes_str}]. " + f"Hint: remove or redirect edges to break the cycle." + ) raise ValueError(msg) return self @@ -702,10 +883,13 @@ __all__ = [ "ContextConfigSchema", "ContextView", "EdgeDefinition", + "LspContextEnrichment", "MemoryConfig", "NodeDefinition", + "NodeLspBinding", "NodeType", "RouteDefinition", "ToolDefinition", "ToolParameter", + "ToolSourceRef", ]