microcoreos 0.4.2__tar.gz → 0.4.4__tar.gz

{microcoreos-0.4.2 → microcoreos-0.4.4}/AI_CONTEXT.md

@@ -321,7 +321,7 @@ Async SQLite Persistence Tool (sqlite):
 - **Events emitted**: none
 - **Events consumed**: none
 - **Dependencies**: container, http, logger
-- **Plugins**: devtools.DiscoveryNamingLinterPlugin, devtools.DocPathLinterPlugin, devtools.DomainIsolationLinterPlugin, devtools.EventContractLinterPlugin, devtools.EventSchemasPlugin, devtools.FieldDivergenceLinterPlugin, devtools.RouteCollisionLinterPlugin, devtools.TableOwnershipLinterPlugin, devtools.ToolDocDriftLinterPlugin
+- **Plugins**: devtools.DiscoveryNamingLinterPlugin, devtools.DomainIsolationLinterPlugin, devtools.EventContractLinterPlugin, devtools.EventSchemasPlugin, devtools.FieldDivergenceLinterPlugin, devtools.RouteCollisionLinterPlugin, devtools.TableOwnershipLinterPlugin, devtools.ToolDocDriftLinterPlugin
 
 ### `system`
 - **Tables**: none

{microcoreos-0.4.2 → microcoreos-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: microcoreos
-Version: 0.4.2
+Version: 0.4.4
 Summary: Atomic Microkernel Architecture optimized for AI-Driven Development
 License: MIT
 License-File: LICENSE
@@ -124,7 +124,8 @@ Use that rather than `uv add 'microcoreos[auth]'`. The extra is only the **depen
 | Command | Purpose |
 |---|---|
 | `microcoreos status` | Reports active plan progress and `AI_CONTEXT.md` freshness |
-| `microcoreos plan validate` | Validates active plan YAML (`plans/active_plan.yaml`) offline against 18 rules |
+| `microcoreos plan validate` | Validates active plan YAML (`plans/active_plan.yaml`) offline against 19 rules (`--fix` to sync checklist first) |
+| `microcoreos plan sync` | Generates or updates execution checklist (`plans/active_plan.md`) preserving progress |
 | `microcoreos migrate` | Applies SQL migrations AND regenerates `AI_CONTEXT.md` (the AI context manifest) |
 | `microcoreos schema` | Inspects live database schema and normalized tables |
 

{microcoreos-0.4.2 → microcoreos-0.4.4}/README.md

@@ -83,7 +83,8 @@ Use that rather than `uv add 'microcoreos[auth]'`. The extra is only the **depen
 | Command | Purpose |
 |---|---|
 | `microcoreos status` | Reports active plan progress and `AI_CONTEXT.md` freshness |
-| `microcoreos plan validate` | Validates active plan YAML (`plans/active_plan.yaml`) offline against 18 rules |
+| `microcoreos plan validate` | Validates active plan YAML (`plans/active_plan.yaml`) offline against 19 rules (`--fix` to sync checklist first) |
+| `microcoreos plan sync` | Generates or updates execution checklist (`plans/active_plan.md`) preserving progress |
 | `microcoreos migrate` | Applies SQL migrations AND regenerates `AI_CONTEXT.md` (the AI context manifest) |
 | `microcoreos schema` | Inspects live database schema and normalized tables |
 

{microcoreos-0.4.2 → microcoreos-0.4.4}/docs/CLI.md

@@ -11,12 +11,14 @@ microcoreos [run] [--boot-tool <tool>]           Boot the Kernel
 microcoreos dev                                  Boot with auto-reload
 
 microcoreos status                               Active plan, progress, manifest age
-microcoreos plan validate [path]                 The 18 plan rules, offline
+microcoreos plan validate [path] [--fix]         The 18 plan rules, offline
+microcoreos plan sync [path]                     Sync execution checklist from plan
 microcoreos plan probe [path]                    What each feature actually touches
 microcoreos migrate                              Migrations + regenerate AI_CONTEXT.md
 microcoreos schema                               The live tables and columns
 ```
 
+
 **Every example below needs a `uv run` prefix** (or an activated venv): the
 console script lives in `.venv/bin`, so a bare `microcoreos` is "command not
 found". And `<angle brackets>` mark a placeholder — type the value, not the
@@ -203,6 +205,8 @@ observed failing.
 ```bash
 microcoreos status                   # before anything else
 microcoreos plan validate            # defaults to plans/active_plan.yaml
+microcoreos plan validate --fix      # sync checklist then validate
+microcoreos plan sync                # generate / sync plans/active_plan.md from plan
 microcoreos plan validate draft.yaml # or any path
 microcoreos migrate                  # after writing phase 0
 microcoreos schema                   # verify what landed in the database
@@ -216,6 +220,12 @@ and any loose `.py` in the project root — every deliverable has a declared hom
 under `domains/`, `tools/` or `tests/`, so one at the root is an agent's
 scratch file left behind. Reported, never deleted.
 
+**`plan sync`** — generates or updates `plans/active_plan.md` directly from
+`plans/active_plan.yaml`, preserving existing checkmarks `[x]` while generating
+exact task paths for Phase 0, Phase 2 and Phase 3. Eliminates manual checklist
+authoring and Rule 15 mismatches.
+
+
 **`plan probe`** — the other half of the question. `validate` asks whether the
 PLAN is well formed; this drives every feature with recording stand-ins for its
 tools and prints every call it makes.

{microcoreos-0.4.2 → microcoreos-0.4.4}/domains/system/plugins/system_logs_stream_plugin.py

@@ -22,10 +22,16 @@ class SystemLogsStreamPlugin(BasePlugin):
             tags=["System"],
         )
 
-    def _on_log(self, level: str, message: str, timestamp: str, identity: str):
+    def _on_log(self, level: str, message: str, timestamp: str, identity: str, trace_id: str = None):
         if not self._queues:
             return
-        record = {"level": level, "message": message, "timestamp": timestamp, "identity": identity}
+        record = {
+            "level": level,
+            "message": message,
+            "timestamp": timestamp,
+            "identity": identity,
+            "trace_id": trace_id,
+        }
         try:
             loop = asyncio.get_running_loop()
             for q in list(self._queues):

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/cli.py

@@ -34,6 +34,7 @@ USAGE = """MicroCoreOS — development tooling
 Usage:
   microcoreos-dev status                  Active plan, progress, manifest age
   microcoreos-dev plan validate [path]    Validate the plan offline (no server)
+  microcoreos-dev plan sync [path]        Sync execution checklist from plan
   microcoreos-dev plan probe [path]       Drive each feature, report what it touches
   microcoreos-dev migrate                 Apply migrations + regenerate AI_CONTEXT.md
   microcoreos-dev schema                  Print the live tables and columns
@@ -44,6 +45,7 @@ project (the directory holding tools/, domains/ and plans/).
 """
 
 
+
 def dispatch(name: str, argv: list[str]) -> int:
     """Run one pipeline command by name — the seam `microcoreos` calls.
 

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/pipeline.py

@@ -285,27 +285,59 @@ def schema(argv: list[str]) -> int:
 
 # ── plan validate ────────────────────────────────────────────────────────────
 
-PLAN_USAGE = """Usage: microcoreos plan <validate|probe> [path]
+PLAN_USAGE = """Usage: microcoreos plan <validate|probe|sync> [path] [--fix]
 
-  validate  the 19 rules, offline — is the PLAN well formed
+  validate  the 19 rules, offline — is the PLAN well formed (--fix to sync checklist first)
   probe     drive each feature and record what it touches — does the CODE
             match the plan it was written from
+  sync      generate or sync plans/active_plan.md from the active plan
 
   path      defaults to plans/active_plan.yaml
 """
 
 
 def plan(argv: list[str]) -> int:
-    if not argv or argv[0] not in ("validate", "probe"):
+    if not argv or argv[0] not in ("validate", "probe", "sync"):
         print(PLAN_USAGE)
         return 2
-    path = argv[1] if len(argv) > 1 else PLAN_PATH
-    return _plan_validate(path) if argv[0] == "validate" else _run_probe(path)
+    cmd = argv[0]
+    rest = argv[1:]
+    fix = "--fix" in rest
+    args = [a for a in rest if a != "--fix"]
+    path = args[0] if args else PLAN_PATH
+
+    if cmd == "sync":
+        return _plan_sync(path)
+    elif cmd == "validate":
+        if fix:
+            sync_res = _plan_sync(path)
+            if sync_res != 0:
+                return sync_res
+        return _plan_validate(path)
+    else:  # probe
+        return _run_probe(path)
+
+
+def _plan_sync(path: str) -> int:
+    """Generate or update plans/active_plan.md from the plan file."""
+    root = ensure_project_on_path()
+    if not require_project(root):
+        return 2
+
+    from microcoreos_dev.plan.sync import sync_checklist
+
+    success, msg = sync_checklist(path, CHECKLIST_PATH)
+    if not success:
+        print(f"\n❌ {msg}\n")
+        return 1
+    print(f"✅ {msg}")
+    return 0
 
 
 def _plan_validate(path: str) -> int:
     """Run the 16 plan rules offline — no server, no jq, no curl.
 
+
     The validator was already pure (a Plan plus a LiveSnapshot in, violations
     out); only the snapshot needed the running system, and everything in it
     except live subscribers can be read straight off the disk. So the gate

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/plan/__init__.py

@@ -19,8 +19,10 @@ from microcoreos_dev.plan.schema import (
     PlanLanguage,
     PlanLink,
     PlanMigration,
+    PlanPhase0,
     PlanPublish,
     PlanRoute,
+    PlanTool,
     PlanViolation,
     ValidatePlanData,
     unknown_plan_keys,
@@ -40,6 +42,10 @@ from microcoreos_dev.plan.rules import (
     run_validation,
     validate_yaml,
 )
+from microcoreos_dev.plan.sync import (
+    generate_checklist,
+    sync_checklist,
+)
 
 __all__ = [
     "DURABLE_DRIVERS",
@@ -51,11 +57,14 @@ __all__ = [
     "PlanLanguage",
     "PlanLink",
     "PlanMigration",
+    "PlanPhase0",
     "PlanPublish",
     "PlanRoute",
+    "PlanTool",
     "PlanValidator",
     "PlanViolation",
     "ValidatePlanData",
+    "generate_checklist",
     "offline_snapshot",
     "parse_plan_yaml",
     "run_validation",
@@ -63,6 +72,8 @@ __all__ = [
     "scan_live_events",
     "scan_live_routes",
     "scan_live_tables",
+    "sync_checklist",
     "unknown_plan_keys",
     "validate_yaml",
 ]
+

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/plan/rules.py

@@ -19,6 +19,7 @@ from microcoreos_dev.plan.schema import (
     Plan,
     PlanFeature,
     PlanLanguage,
+    PlanTool,
     PlanViolation,
     ValidatePlanData,
     unknown_plan_keys,
@@ -388,8 +389,13 @@ class PlanValidator:
                     declared.append((flow.name, path))
         for migration in self.plan.phase_0.migrations:
             declared.append((migration.file, migration.file))
-        for path in self.plan.phase_0.models + self.plan.phase_0.tools:
+        for path in self.plan.phase_0.models:
             declared.append((path, path))
+        for tool in self.plan.phase_0.tools:
+            if isinstance(tool, PlanTool):
+                declared.append((tool.name, tool.file))
+            else:
+                declared.append((tool, tool))
 
         def covered(path: str) -> bool:
             # substring match, path or basename — no coupling to the

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/plan/scan.py

@@ -208,25 +208,37 @@ def scan_live_events(domains_dir: str = "domains") -> tuple[set[str], dict[str,
                     tree = ast.parse(f.read())
             except Exception:
                 continue
+
+            # First pass: map each node to its enclosing ClassDef name if any
+            class_map = {}
             for klass in [n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]:
-                for node in ast.walk(klass):
-                    if not (isinstance(node, ast.Call)
-                            and isinstance(node.func, ast.Attribute)
-                            and node.args
-                            and isinstance(node.args[0], ast.Constant)
-                            and isinstance(node.args[0].value, str)):
-                        continue
+                for child in ast.walk(klass):
+                    class_map[child] = klass.name
+
+            for node in ast.walk(tree):
+                if not (isinstance(node, ast.Call)
+                        and isinstance(node.func, ast.Attribute)):
+                    continue
+                event = None
+                if node.args and isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
                     event = node.args[0].value
-                    if node.func.attr == "publish":
-                        published.add(event)
-                    elif node.func.attr == "subscribe":
-                        handler = "handler"
-                        if len(node.args) > 1 and isinstance(node.args[1], ast.Attribute):
-                            handler = node.args[1].attr
-                        subscribers.setdefault(event, []).append(f"{klass.name}.{handler}")
+                for kw in node.keywords:
+                    if kw.arg in ("event", "topic") and isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                        event = kw.value.value
+                if not event:
+                    continue
+                if node.func.attr == "publish":
+                    published.add(event)
+                elif node.func.attr == "subscribe":
+                    handler = "handler"
+                    if len(node.args) > 1 and isinstance(node.args[1], ast.Attribute):
+                        handler = node.args[1].attr
+                    owner = class_map.get(node, filename[:-3])
+                    subscribers.setdefault(event, []).append(f"{owner}.{handler}")
     return published, subscribers
 
 
+
 def offline_snapshot(domains_dir: str = "domains") -> LiveSnapshot:
     """What the repo on disk already occupies, with no system running."""
     tables = scan_live_tables(domains_dir)

{microcoreos-0.4.2 → microcoreos-0.4.4}/microcoreos_dev/plan/schema.py

@@ -4,8 +4,15 @@ Vocabulary only: what a plan may say, and which keys no field claims. The rules
 that judge a plan live in `rules.py`; what the repo on disk already occupies
 lives in `scan.py`.
 """
-from typing import Optional, Literal, get_args
-from pydantic import BaseModel, ConfigDict, Field
+import re
+from typing import Optional, Literal, Union, get_args
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+
+def payload_model_name(event: str) -> str:
+    """'order.paid' -> 'OrderPaidPayload' (AGENTS.md rule 10's spelling)."""
+    parts = [p for p in re.split(r"[^0-9A-Za-z]+", event) if p]
+    return ("".join(p[:1].upper() + p[1:] for p in parts) + "Payload") if parts else "EventPayload"
 
 
 class PlanRoute(BaseModel):
@@ -21,10 +28,17 @@ class PlanMigration(BaseModel):
     columns: dict[str, dict[str, str]] = {}
 
 
+class PlanTool(BaseModel):
+    name: str
+    file: str
+    contract: list[str] = []
+    infra_errors: bool = False
+
+
 class PlanPhase0(BaseModel):
     migrations: list[PlanMigration] = []
     models: list[str] = []
-    tools: list[str] = []
+    tools: list[Union[PlanTool, str]] = []
 
 
 class PlanDbContract(BaseModel):
@@ -37,11 +51,29 @@ class PlanPublish(BaseModel):
     model: Optional[str] = None
     payload: dict = {}
 
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_str(cls, data):
+        if isinstance(data, str):
+            return {
+                "event": data,
+                "model": payload_model_name(data),
+                "payload": {},
+            }
+        return data
+
 
 class PlanConsume(BaseModel):
     event: str
     requires: list[str] = []
 
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_str(cls, data):
+        if isinstance(data, str):
+            return {"event": data, "requires": []}
+        return data
+
 
 class PlanFeature(BaseModel):
     plugin: str
@@ -64,6 +96,16 @@ class PlanFeature(BaseModel):
 
     model_config = ConfigDict(populate_by_name=True)
 
+    @field_validator("publishes", "consumes", mode="before")
+    @classmethod
+    def _ensure_list(cls, data):
+        if data is None:
+            return []
+        if isinstance(data, (str, dict)):
+            return [data]
+        return data
+
+
 
 class PlanLink(BaseModel):
     consumes: str

microcoreos-0.4.4/microcoreos_dev/plan/sync.py

@@ -0,0 +1,140 @@
+"""Checklist generator & synchronizer for MicroCoreOS execution plans.
+
+Reads a Plan object (from `plans/active_plan.yaml`) and generates or updates
+the markdown execution checklist at `plans/active_plan.md`.
+
+Preserves existing `[x]` / `[X]` progress so synchronizing a plan does not
+reset completed tasks, while ensuring 100% path coverage for Rule 15 and
+eliminating the template marker so Rule 0 passes.
+"""
+import os
+from typing import Optional
+
+from microcoreos_dev.plan.schema import Plan, PlanTool
+
+
+def generate_checklist(plan: Plan, existing_checklist: Optional[str] = None) -> str:
+    """Generate or update the markdown checklist from a Plan instance.
+
+    Every file:, test:, migration, model and tool path is generated with a checkbox.
+    If existing_checklist contains checked boxes (`- [x]` or `- [X]`) for a path,
+    that checkmark is preserved in the updated output.
+    """
+    done_paths = set()
+    if existing_checklist:
+        for line in existing_checklist.splitlines():
+            stripped = line.strip()
+            if stripped.startswith(("- [x]", "- [X]", "* [x]", "* [X]")):
+                for token in line.split():
+                    clean = token.strip("`(),*[]\"'")
+                    if "/" in clean or clean.endswith((".py", ".sql")) or clean.startswith("microcoreos"):
+                        done_paths.add(clean)
+                        done_paths.add(os.path.basename(clean))
+
+    def mark(path: str) -> str:
+        if path in done_paths or os.path.basename(path) in done_paths:
+            return "- [x]"
+        return "- [ ]"
+
+    lines = [
+        "# Active Integration Plan — Execution Checklist",
+        "",
+        "> This file is the checklist / state machine for orchestrating subagents.",
+        "> The formal contract (routes, columns, events, flows) lives in `plans/active_plan.yaml`.",
+        "> The coordinator agent updates the task status as features are verified.",
+        "",
+    ]
+
+    # Phase 0: Foundation
+    p0 = plan.phase_0
+    has_p0 = bool(p0.tools or p0.migrations or p0.models)
+    if has_p0:
+        lines.append("## 🛠️ Phase 0: Foundation (Serial — built 1:1 from the plan's `phase_0`)")
+        for tool in p0.tools:
+            name = tool.name if isinstance(tool, PlanTool) else str(tool)
+            file_path = tool.file if isinstance(tool, PlanTool) else str(tool)
+            lines.append(f"{mark(file_path)} Task T_{name}: Tool `{name}` (`{file_path}`)")
+        for migration in p0.migrations:
+            lines.append(f"{mark(migration.file)} Task M_{os.path.basename(migration.file)}: SQL Migration (`{migration.file}`)")
+            if migration.tables:
+                lines.append(f"  * **Tables owned**: `{migration.tables}`")
+        for model in p0.models:
+            lines.append(f"{mark(model)} Task D_{os.path.basename(model)}: Model (`{model}`)")
+        migrate_cmd = "microcoreos migrate"
+        lines.append(f"{mark(migrate_cmd)} Task P0_Migrate: Apply migrations (`{migrate_cmd}`)")
+        lines.append("")
+
+    # Phase 2: Plugins & Features
+    if plan.features:
+        lines.append("## 💻 Phase 2: Plugins & Features (Parallel)")
+        for idx, feat in enumerate(plan.features, 1):
+            lines.append(f"{mark(feat.file)} Task P{idx}: Feature Plugin `{feat.plugin}` (`{feat.file}`)")
+            details = []
+            if feat.route:
+                details.append(f"**Route**: `{feat.route.method.upper()} {feat.route.path}`")
+            if feat.publishes:
+                events = [p.event for p in feat.publishes]
+                details.append(f"**Publishes**: `{events}`")
+            if feat.consumes:
+                events = [c.event for c in feat.consumes]
+                details.append(f"**Consumes**: `{events}`")
+            if feat.tools:
+                details.append(f"**Tools**: `{feat.tools}`")
+            for d in details:
+                lines.append(f"  * {d}")
+            if feat.test:
+                lines.append(f"{mark(feat.test)} Task P{idx}_Test: Unit Test (`{feat.test}`)")
+        lines.append("")
+
+    # Phase 3: Integration & Flow Verification
+    if plan.flows:
+        lines.append("## 🚦 Phase 3: Integration & Flow Verification (End-to-End)")
+        for idx, flow in enumerate(plan.flows, 1):
+            if flow.e2e_test:
+                lines.append(f"{mark(flow.e2e_test)} Task F{idx}_E2E: Flow `{flow.name}` E2E test (`{flow.e2e_test}`)")
+            if flow.sad_path_test:
+                lines.append(f"{mark(flow.sad_path_test)} Task F{idx}_Sad: Flow `{flow.name}` Sad-path test (`{flow.sad_path_test}`)")
+            for link in flow.links:
+                if link.idempotency_test:
+                    lines.append(f"{mark(link.idempotency_test)} Task F{idx}_Idempotent: `{link.consumes} → {link.consumer}` (`{link.idempotency_test}`)")
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def sync_checklist(plan_path: str = os.path.join("plans", "active_plan.yaml"),
+                   checklist_path: str = os.path.join("plans", "active_plan.md")) -> tuple[bool, str]:
+    """Read plan_path, update checklist_path, and return (success, message)."""
+    if not os.path.isfile(plan_path):
+        return False, f"No plan file found at {plan_path}"
+
+    from microcoreos_dev.plan.rules import parse_plan_yaml
+
+    with open(plan_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    plan_dict, err = parse_plan_yaml(content)
+    if err:
+        return False, f"Could not parse plan: {err}"
+
+    try:
+        plan = Plan(**plan_dict)
+    except Exception as e:
+        return False, f"Plan schema error: {e}"
+
+    existing = None
+    if os.path.isfile(checklist_path):
+        with open(checklist_path, "r", encoding="utf-8") as f:
+            existing = f.read()
+
+    generated = generate_checklist(plan, existing)
+
+    # Ensure parent dir exists
+    parent = os.path.dirname(checklist_path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    with open(checklist_path, "w", encoding="utf-8") as f:
+        f.write(generated)
+
+    return True, f"Synchronized {checklist_path} from {plan_path}"

{microcoreos-0.4.2 → microcoreos-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "microcoreos"
-version = "0.4.2"
+version = "0.4.4"
 description = "Atomic Microkernel Architecture optimized for AI-Driven Development"
 license = {text = "MIT"}
 readme = "README.md"

{microcoreos-0.4.2 → microcoreos-0.4.4}/tests/dev/test_pipeline.py

@@ -676,3 +676,49 @@ def test_probe_accepts_the_route_and_events_the_plan_declares(tmp_path, monkeypa
     monkeypatch.chdir(_route_project(tmp_path))
 
     assert cli.main(["plan", "probe"]) == 0
+
+
+def test_plan_sync_cli_generates_active_plan_md(tmp_path, monkeypatch, capsys):
+    project = _probe_project(tmp_path)
+    monkeypatch.chdir(project)
+
+    checklist_file = project / "plans" / "active_plan.md"
+    assert not checklist_file.exists()
+
+    code = cli.main(["plan", "sync"])
+    assert code == 0
+    assert checklist_file.exists()
+
+    content = checklist_file.read_text(encoding="utf-8")
+    assert "CounterPlugin" in content
+    assert "domains/shop/plugins/counter_plugin.py" in content
+    assert "tests/test_counter_plugin.py" in content
+    assert "<!-- template: true -->" not in content
+
+
+def test_plan_validate_fix_cli_syncs_checklist(tmp_path, monkeypatch, capsys):
+    valid_plan_yaml = """
+plan:
+  domain: shop
+  features:
+    - plugin: CounterPlugin
+      file: domains/shop/plugins/counter_plugin.py
+      publishes: ["order.counted"]
+      tools: [event_bus]
+      test: tests/test_counter_plugin.py
+"""
+    project = _probe_project(tmp_path, plan=valid_plan_yaml)
+    monkeypatch.chdir(project)
+
+    # Place a template checklist
+    checklist_file = project / "plans" / "active_plan.md"
+    checklist_file.write_text("<!-- template: true -->\n- [ ] dummy", encoding="utf-8")
+
+    code = cli.main(["plan", "validate", "--fix"])
+    # Validation will pass because --fix updated the checklist with the real tasks
+    assert code == 0
+    content = checklist_file.read_text(encoding="utf-8")
+    assert "<!-- template: true -->" not in content
+    assert "counter_plugin.py" in content
+
+