@blxzer/cursor-trellis 0.4.2 → 0.4.3

package/dist/templates/trellis/scripts/common/task_store.py

@@ -40,8 +40,17 @@ from .config import (
     validate_package,
 )
 from .cli_environment import format_git_repo_errors, print_environment_repair_hints
-from .git import run_git
-from .io import read_json, write_json
+from .git import is_git_worktree, run_git
+from .io import read_json
+from .kernel_command import (
+    KernelCliNotFound,
+    KernelCommandError,
+    kernel_archive,
+    kernel_create,
+    kernel_expected_revision,
+    kernel_patch,
+    print_kernel_error,
+)
 from .log import Colors, colored
 from .paths import (
     DIR_ARCHIVE,
@@ -62,10 +71,13 @@ from .task_gates import (
     BASELINE_GATE,
     archive_repair_hints,
     build_spec_update_scaffold,
+    collect_kernel_projection_extras,
     prepare_archive_evidence,
+    task_closeout_profile,
     validate_archive,
     write_gate_record,
 )
+from .ondemand_topology import TopologyError, assign_parent, default_topology
 from .task_map import (
     CHILD_STATES,
     CHILD_REPORT_STATES,
@@ -345,6 +357,35 @@ def _default_prd_content(
     return default_prd_content(title, description, locale, root)
 
 
+def _kernel_patch_task_json(
+    task_dir: Path,
+    data: dict,
+    *,
+    actor: str,
+    op: str,
+    evidence: str,
+) -> bool:
+    """Persist mutated task.json fields through Kernel patch (not task-map.md)."""
+    extras = collect_kernel_projection_extras(data)
+    if "depends_on" in data:
+        extras["depends_on"] = data["depends_on"]
+    try:
+        expected = kernel_expected_revision(task_dir)
+        kernel_patch(
+            task_dir,
+            data,
+            extras,
+            expected_revision=expected,
+            actor=actor,
+            idempotency_key=f"patch:{op}:{task_dir.name}:r{expected}",
+            evidence=evidence,
+        )
+        return True
+    except (KernelCliNotFound, KernelCommandError) as err:
+        print_kernel_error(err)
+        return False
+
+
 # =============================================================================
 # Command: create
 # =============================================================================
@@ -445,7 +486,33 @@ def cmd_create(args: argparse.Namespace) -> int:
         "meta": {},
     }
 
-    write_json(task_json_path, task_data)
+    parent_dir = None
+    parent_data = None
+    if args.parent:
+        parent_dir = resolve_task_dir(args.parent, repo_root)
+        parent_json_path = parent_dir / FILE_TASK_JSON
+        if not parent_json_path.is_file():
+            print(colored(f"Warning: Parent task.json not found: {args.parent}", Colors.YELLOW), file=sys.stderr)
+        else:
+            parent_data = read_json(parent_json_path)
+            if parent_data:
+                task_data["parent"] = parent_dir.name
+
+    try:
+        kernel_create(
+            task_dir,
+            task_data,
+            actor="task.py create",
+            idempotency_key=f"create:{slug}",
+            evidence="task.py create",
+        )
+    except (KernelCliNotFound, KernelCommandError) as err:
+        print_kernel_error(err)
+        return 1
+
+    persisted = read_json(task_json_path)
+    if persisted:
+        task_data = persisted
 
     prd_path = task_dir / "prd.md"
     if not prd_path.exists():
@@ -473,39 +540,35 @@ def cmd_create(args: argparse.Namespace) -> int:
                 _write_seed_jsonl(jsonl_path, repo_root, task_dir, task_data)
         seeded_jsonl = True
 
-    # Handle --parent: establish bidirectional link
-    if args.parent:
-        parent_dir = resolve_task_dir(args.parent, repo_root)
-        parent_json_path = parent_dir / FILE_TASK_JSON
-        if not parent_json_path.is_file():
-            print(colored(f"Warning: Parent task.json not found: {args.parent}", Colors.YELLOW), file=sys.stderr)
-        else:
-            parent_data = read_json(parent_json_path)
-            if parent_data:
-                # Add child to parent's children list
-                parent_children = parent_data.get("children", [])
-                if dir_name not in parent_children:
-                    parent_children.append(dir_name)
-                    parent_data["children"] = parent_children
-                    write_json(parent_json_path, parent_data)
-
-                # Set parent in child's task.json
-                task_data["parent"] = parent_dir.name
-                write_json(task_json_path, task_data)
-                ensure_task_map(
-                    parent_dir,
-                    parent_data,
-                    list(parent_data.get("children", [])),
-                    f"Linked Child `{dir_name}`.",
-                )
-
-                print(colored(f"Linked as child of: {parent_dir.name}", Colors.GREEN), file=sys.stderr)
+    # Handle --parent: child's `parent` is in the Kernel create record above;
+    # parent `children[]` goes through Kernel patch. task-map.md stays Python.
+    if parent_dir is not None and parent_data:
+        parent_children = parent_data.get("children", [])
+        if dir_name not in parent_children:
+            parent_children.append(dir_name)
+            parent_data["children"] = parent_children
+            if not _kernel_patch_task_json(
+                parent_dir,
+                parent_data,
+                actor="task.py create",
+                op="create-parent-link",
+                evidence="children[]",
+            ):
+                return 1
+        ensure_task_map(
+            parent_dir,
+            parent_data,
+            list(parent_data.get("children", [])),
+            f"Linked Child `{dir_name}`.",
+        )
+        print(colored(f"Linked as child of: {parent_dir.name}", Colors.GREEN), file=sys.stderr)
 
     print(colored(f"Created task: {dir_name}", Colors.GREEN), file=sys.stderr)
     print("", file=sys.stderr)
     print(colored("Next steps:", Colors.BLUE), file=sys.stderr)
     print("  - Fill prd.md with requirements and acceptance criteria", file=sys.stderr)
     print(f"  - Select it when ready: python ./.cstl/scripts/task.py select {DIR_WORKFLOW}/{DIR_TASKS}/{dir_name}", file=sys.stderr)
+    print("  - Personal Lite: Definition=prd.md, Evidence=verify.md; start-execution --check is not approval", file=sys.stderr)
     print("  - Lightweight task: PRD-only is valid", file=sys.stderr)
     print("  - Complex task: add design.md and implement.md before task.py start-execution --check", file=sys.stderr)
     if seeded_jsonl:
@@ -636,7 +699,21 @@ def _archive_one_task(
             write_gate_record(data, "full-task-complete", BASELINE_GATE, guard.baseline_record)
         data["status"] = "completed"
         data["completedAt"] = today
-        write_json(task_json_path, data)
+        extras = collect_kernel_projection_extras(data)
+        try:
+            expected = kernel_expected_revision(task_dir)
+            kernel_archive(
+                task_dir,
+                data,
+                extras,
+                expected_revision=expected,
+                actor="task.py archive",
+                idempotency_key=f"archive:{dir_name}:{today}",
+                evidence="task.py archive",
+            )
+        except (KernelCliNotFound, KernelCommandError) as err:
+            print_kernel_error(err)
+            return False, [], None
 
         task_children = data.get("children", [])
         if task_children:
@@ -648,14 +725,32 @@ def _archive_one_task(
                         child_data = read_json(child_json)
                         if child_data:
                             child_data["parent"] = None
-                            write_json(child_json, child_data)
+                            if not _kernel_patch_task_json(
+                                child_dir_path,
+                                child_data,
+                                actor="task.py archive",
+                                op="archive-clear-parent",
+                                evidence="parent",
+                            ):
+                                return False, modified_children, None
                             modified_children.append(child_dir_path.name)
 
     from .active_task import clear_task_from_sessions
 
+    profile = task_closeout_profile(task_dir, task_data) if task_data else "lite"
     clear_task_from_sessions(str(task_dir), repo_root)
     result = archive_task_complete(task_dir, repo_root)
     if "archived_to" not in result:
+        if profile == "lite":
+            print(
+                colored(
+                    "Close Outcome written; physical archive/retention skipped "
+                    "(not a Lite completion condition).",
+                    Colors.YELLOW,
+                ),
+                file=sys.stderr,
+            )
+            return True, modified_children, f"{DIR_WORKFLOW}/{DIR_TASKS}/{dir_name}"
         return False, modified_children, None
 
     archive_dest = Path(result["archived_to"])
@@ -667,15 +762,25 @@ def _archive_one_task(
 
     if not no_commit:
         if not _auto_commit_archive(dir_name, repo_root, modified_children):
-            print(
-                colored(
-                    "Archive moved on disk, but git auto-commit did not complete. "
-                    "Resolve `git status` before continuing.",
-                    Colors.RED,
-                ),
-                file=sys.stderr,
-            )
-            return False, modified_children, None
+            if profile == "lite":
+                print(
+                    colored(
+                        "Lite Close Outcome stands; git auto-commit skipped or failed "
+                        "(VCS is On-demand, not a completion condition).",
+                        Colors.YELLOW,
+                    ),
+                    file=sys.stderr,
+                )
+            else:
+                print(
+                    colored(
+                        "Archive moved on disk, but git auto-commit did not complete. "
+                        "Resolve `git status` before continuing.",
+                        Colors.RED,
+                    ),
+                    file=sys.stderr,
+                )
+                return False, modified_children, None
 
     rel = f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}/{year_month}/{dir_name}"
     archived_json = archive_dest / FILE_TASK_JSON
@@ -858,6 +963,14 @@ def _auto_commit_archive(
     set to ``false``, this function returns immediately without
     touching git (the archive directory move on disk is unaffected).
     """
+    if not is_git_worktree(repo_root):
+        print(
+            "[OK] no Git worktree — skipping archive auto-commit "
+            "(Close Outcome already written).",
+            file=sys.stderr,
+        )
+        return True
+
     if not get_session_auto_commit(repo_root):
         print(
             "[OK] session_auto_commit: false — skipping git stage/commit.",
@@ -967,9 +1080,49 @@ def cmd_add_subtask(args: argparse.Namespace) -> int:
     # Set parent in child's task.json
     child_data["parent"] = parent_dir.name
 
-    # Write both
-    write_json(parent_json_path, parent_data)
-    write_json(child_json_path, child_data)
+    parent_id = str(parent_data.get("id") or parent_dir.name)
+    parent_existing = (
+        parent_data.get("topology")
+        if isinstance(parent_data.get("topology"), dict)
+        else {}
+    )
+    parent_data["topology"] = default_topology(
+        parent=parent_existing.get("parent_id") or parent_data.get("parent"),
+        children=parent_children,
+    )
+    child_existing = (
+        child_data.get("topology")
+        if isinstance(child_data.get("topology"), dict)
+        else {}
+    )
+    child_children = list(
+        child_existing.get("children") or child_data.get("children") or []
+    )
+    try:
+        child_data["topology"] = assign_parent(
+            default_topology(parent=None, children=child_children),
+            parent_id,
+        )
+    except TopologyError as err:
+        print(colored(f"Error: {err}", Colors.RED), file=sys.stderr)
+        return 1
+
+    if not _kernel_patch_task_json(
+        parent_dir,
+        parent_data,
+        actor="task.py add-subtask",
+        op="add-subtask",
+        evidence="children[]",
+    ):
+        return 1
+    if not _kernel_patch_task_json(
+        child_dir,
+        child_data,
+        actor="task.py add-subtask",
+        op="add-subtask",
+        evidence="parent",
+    ):
+        return 1
     ensure_task_map(
         parent_dir,
         parent_data,
@@ -1020,9 +1173,41 @@ def cmd_remove_subtask(args: argparse.Namespace) -> int:
     # Clear parent in child's task.json
     child_data["parent"] = None
 
-    # Write both
-    write_json(parent_json_path, parent_data)
-    write_json(child_json_path, child_data)
+    parent_existing = (
+        parent_data.get("topology")
+        if isinstance(parent_data.get("topology"), dict)
+        else {}
+    )
+    parent_data["topology"] = default_topology(
+        parent=parent_existing.get("parent_id") or parent_data.get("parent"),
+        children=parent_children,
+    )
+    child_existing = (
+        child_data.get("topology")
+        if isinstance(child_data.get("topology"), dict)
+        else {}
+    )
+    child_data["topology"] = default_topology(
+        parent=None,
+        children=list(child_existing.get("children") or child_data.get("children") or []),
+    )
+
+    if not _kernel_patch_task_json(
+        parent_dir,
+        parent_data,
+        actor="task.py remove-subtask",
+        op="remove-subtask",
+        evidence="children[]",
+    ):
+        return 1
+    if not _kernel_patch_task_json(
+        child_dir,
+        child_data,
+        actor="task.py remove-subtask",
+        op="remove-subtask",
+        evidence="parent",
+    ):
+        return 1
     remove_child_from_task_map(parent_dir, parent_data, child_dir_name)
 
     print(colored(f"Unlinked: {child_dir.name} from {parent_dir.name}", Colors.GREEN), file=sys.stderr)
@@ -1108,7 +1293,14 @@ def cmd_prepare_child_worktree(args: argparse.Namespace) -> int:
 
     child_data["branch"] = branch
     child_data["worktree_path"] = worktree_rel
-    write_json(child_json_path, child_data)
+    if not _kernel_patch_task_json(
+        child_dir,
+        child_data,
+        actor="task.py prepare-child-worktree",
+        op="prepare-child-worktree",
+        evidence="branch,worktree_path",
+    ):
+        return 1
 
     ok, map_errors = record_child_worktree(
         parent_dir,
@@ -1147,7 +1339,7 @@ def append_depends_ignore_event(
     """Append a depends-ignore audit event to meta.depends_ignore_events.
 
     Mutates task_data in memory; the caller persists it in the SAME
-    write_json as the mutation it accompanies (execution approval / child
+    Kernel patch as the mutation it accompanies (execution approval / child
     state), so the event can never dangle as a separate stale write. The
     list is capped at MAX_IGNORE_EVENTS (FIFO drops the oldest entry).
     """
@@ -1236,8 +1428,13 @@ def _guard_child_working_deps(
         evidence=args.evidence,
         reason=getattr(args, "reason", None),
     )
-    child_json_path = child_dir / FILE_TASK_JSON
-    if not write_json(child_json_path, child_data):
+    if not _kernel_patch_task_json(
+        child_dir,
+        child_data,
+        actor="task.py set-child-state",
+        op="depends-ignore",
+        evidence=str(args.evidence or "ignore-deps"),
+    ):
         print(
             colored("Error: failed to write task.json (ignore event)", Colors.RED),
             file=sys.stderr,
@@ -1772,7 +1969,14 @@ def cmd_set_branch(args: argparse.Namespace) -> int:
         return 1
 
     data["branch"] = branch
-    write_json(task_json, data)
+    if not _kernel_patch_task_json(
+        target_dir,
+        data,
+        actor="task.py set-branch",
+        op="set-branch",
+        evidence="branch",
+    ):
+        return 1
 
     print(colored(f"✓ Branch set to: {branch}", Colors.GREEN))
     return 0
@@ -1806,7 +2010,14 @@ def cmd_set_base_branch(args: argparse.Namespace) -> int:
         return 1
 
     data["base_branch"] = base_branch
-    write_json(task_json, data)
+    if not _kernel_patch_task_json(
+        target_dir,
+        data,
+        actor="task.py set-base-branch",
+        op="set-base-branch",
+        evidence="base_branch",
+    ):
+        return 1
 
     print(colored(f"✓ Base branch set to: {base_branch}", Colors.GREEN))
     print(f"  PR will target: {base_branch}")
@@ -1838,7 +2049,14 @@ def cmd_set_scope(args: argparse.Namespace) -> int:
         return 1
 
     data["scope"] = scope
-    write_json(task_json, data)
+    if not _kernel_patch_task_json(
+        target_dir,
+        data,
+        actor="task.py set-scope",
+        op="set-scope",
+        evidence="scope",
+    ):
+        return 1
 
     print(colored(f"✓ Scope set to: {scope}", Colors.GREEN))
     return 0
@@ -1880,7 +2098,13 @@ def cmd_set_deps(args: argparse.Namespace) -> int:
         if resolve_dep_ref(ref, repo_root=repo_root).kind == KIND_MISSING
     ]
 
-    if not write_json(task_json, data):
+    if not _kernel_patch_task_json(
+        target_dir,
+        data,
+        actor="task.py set-deps",
+        op="set-deps",
+        evidence="depends_on",
+    ):
         print(colored("Error: failed to write task.json", Colors.RED), file=sys.stderr)
         return 1
 
@@ -1950,7 +2174,13 @@ def cmd_set_depends_mode(args: argparse.Namespace) -> int:
         data["meta"] = meta
     meta["depends_mode"] = args.mode
 
-    if not write_json(task_json, data):
+    if not _kernel_patch_task_json(
+        target_dir,
+        data,
+        actor="task.py set-depends-mode",
+        op="set-depends-mode",
+        evidence="meta.depends_mode",
+    ):
         print(colored("Error: failed to write task.json", Colors.RED), file=sys.stderr)
         return 1
 

package/dist/templates/trellis/scripts/common/test_adapter_middleware.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Stage 6 Event Bridge / Middleware Python projection."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.adapter_middleware import (
+    EXTERNAL_KNOWLEDGE_CAPABILITY,
+    RETRIEVAL_INTENTS,
+    AdapterMiddlewareError,
+    assert_external_knowledge,
+    dispatch_hook_event,
+    normalize_capability_router,
+    probe_smart_search_readiness,
+)
+
+
+def test_dispatch_skips_unsubscribed_modules() -> None:
+    last = dispatch_hook_event(
+        {
+            "subscriptions": [
+                {"event": "sessionStart", "module": "observability-local"},
+                {"event": "stop", "module": "retrieval-extended"},
+            ]
+        },
+        "sessionStart",
+        source="cursor-hooks",
+    )
+    assert last["delivered"] == ["observability-local"]
+    assert last["skipped"] == ["retrieval-extended"]
+
+
+def test_missing_smart_search_is_not_ready() -> None:
+    readiness = probe_smart_search_readiness(available=False)
+    assert readiness["status"] == "missing"
+    assert readiness["capability"] == EXTERNAL_KNOWLEDGE_CAPABILITY
+    extras = {"required_capabilities": [EXTERNAL_KNOWLEDGE_CAPABILITY]}
+    with pytest.raises(AdapterMiddlewareError, match="not ready"):
+        assert_external_knowledge(extras, readiness, phase="start")
+    extras["external_knowledge_policy"] = "degrade"
+    assert_external_knowledge(extras, readiness, phase="start")
+    assert extras["profile_health"] == "degraded"
+    assert_external_knowledge({}, readiness, phase="archive")
+
+
+def test_capability_router_rejects_optional_tool_names() -> None:
+    router = normalize_capability_router(None)
+    assert tuple(key for key in RETRIEVAL_INTENTS if router.get(key)) == RETRIEVAL_INTENTS
+    with pytest.raises(AdapterMiddlewareError, match="Optional tool"):
+        normalize_capability_router({"codegraph": True})

package/dist/templates/trellis/scripts/common/test_depends_mode_block.py

@@ -25,6 +25,8 @@ from common.task_dependencies import (
     read_depends_mode,
 )
 from common.task_gates import validate_start_execution, validate_start_execution_check
+from common import kernel_command as kernel_command_mod
+from common.test_kernel_command import FAKE_KERNEL
 
 
 # =============================================================================
@@ -69,6 +71,13 @@ def sandbox(tmp_path, monkeypatch):
     tasks_dir.mkdir(parents=True)
     monkeypatch.setattr("common.task_dependencies.get_repo_root", lambda: repo)
     monkeypatch.setattr("common.task_store.get_repo_root", lambda: repo)
+    script = tmp_path / "fake_kernel.py"
+    script.write_text(FAKE_KERNEL, encoding="utf-8")
+    monkeypatch.setattr(
+        kernel_command_mod,
+        "kernel_cli_argv",
+        lambda: [sys.executable, str(script)],
+    )
     return repo, tasks_dir