@blxzer/cursor-trellis 0.4.2 → 0.4.3

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

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Stage 3 Personal Lite: no-Git Close, dual surfaces, budgeted context pack."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common import kernel_command as kernel_command_mod
+from common.kernel_command import kernel_start, kernel_expected_revision
+from common.lite_context import (
+    LITE_BASELINE_MODULES,
+    LITE_PACK_SOURCE,
+    LiteContextPackError,
+    build_lite_context_pack,
+)
+from common.task_gates import validate_archive, validate_start_execution_check
+from common.task_store import cmd_archive, cmd_create
+from common.test_kernel_command import FAKE_KERNEL, _record
+
+
+LITE_VERIFY = """# Verification Evidence
+
+- validation: python -c "print('ok')"
+- acceptance: Lite path completed without Parent or Git
+- durable learning: no durable learning
+"""
+
+PLACEHOLDER_VERIFY = """# Verification Evidence
+
+- validation: TBD
+- acceptance: TODO
+- durable learning: TBD
+"""
+
+
+@pytest.fixture
+def lite_repo(tmp_path, monkeypatch):
+    repo = tmp_path / "repo"
+    (repo / ".cstl" / "tasks").mkdir(parents=True)
+    (repo / ".cstl" / ".developer").write_text("tester\n", encoding="utf-8")
+    script = tmp_path / "fake_kernel.py"
+    script.write_text(FAKE_KERNEL, encoding="utf-8")
+    monkeypatch.setattr("common.task_store.get_repo_root", lambda: repo)
+    monkeypatch.setattr("common.task_store.get_developer", lambda _repo=None: "tester")
+    monkeypatch.setattr("common.task_store.is_monorepo", lambda _repo: False)
+    monkeypatch.setattr("common.task_store._has_subagent_platform", lambda _repo: False)
+    monkeypatch.setattr("common.paths.get_repo_root", lambda: repo)
+    monkeypatch.setattr("common.artifact_locale.get_repo_root", lambda: repo)
+    monkeypatch.setattr(
+        kernel_command_mod,
+        "kernel_cli_argv",
+        lambda: [sys.executable, str(script)],
+    )
+    assert not (repo / ".git").exists()
+    return repo
+
+
+def _only_task_dir(repo: Path) -> Path:
+    tasks = [
+        p
+        for p in (repo / ".cstl" / "tasks").iterdir()
+        if p.is_dir() and p.name != "archive"
+    ]
+    assert len(tasks) == 1
+    return tasks[0]
+
+
+def test_lite_context_pack_budget_and_exclusions() -> None:
+    pack = build_lite_context_pack(
+        phase="verify",
+        artifacts=[
+            {
+                "role": "definition",
+                "path": "prd.md",
+                "content": "# Lite\n\n## Acceptance Criteria\n\n- [x] Close without Git\n",
+            },
+            {
+                "role": "evidence",
+                "path": "verify.md",
+                "content": "- validation: core test\n- acceptance: done\n",
+            },
+        ],
+    )
+    assert pack["source"] == LITE_PACK_SOURCE
+    assert pack["modules"]["baseline"] == list(LITE_BASELINE_MODULES)
+    assert pack["budget"]["estimatedTokens"] <= pack["budget"]["maxEstimatedTokens"]
+    assert any(item["role"] == "retrieval-router" for item in pack["selected"])
+    assert not any(
+        item["module"]
+        in (
+            "parent-child",
+            "vcs-integration",
+            "personal-memory",
+            "retention-storage",
+            "retrieval-extended",
+        )
+        for item in pack["selected"]
+    )
+
+    with pytest.raises(LiteContextPackError) as dump:
+        build_lite_context_pack(phase="define", include_full_workflow=True)
+    assert dump.value.code == "WORKFLOW_DUMP"
+
+    with pytest.raises(LiteContextPackError) as parent:
+        build_lite_context_pack(phase="execute", activated_modules=["parent-child"])
+    assert parent.value.code == "ON_DEMAND_INACTIVE"
+
+    tight = build_lite_context_pack(
+        phase="verify",
+        max_items=1,
+        max_estimated_tokens=80,
+        artifacts=[
+            {"role": "definition", "path": "prd.md", "content": "x" * 400},
+            {"role": "evidence", "path": "verify.md", "content": "y" * 400},
+        ],
+    )
+    assert tight["budget"]["itemsUsed"] == 1
+    assert tight["omitted"]
+    assert "budget limits caused Lite pack omission" in tight["warnings"]
+
+
+def test_create_start_check_and_no_git_archive(lite_repo: Path) -> None:
+    rc = cmd_create(
+        argparse.Namespace(
+            title="Personal Lite Slice",
+            slug="personal-lite-slice",
+            description="no parent no git",
+            assignee="tester",
+            priority="P2",
+            parent=None,
+            package=None,
+        )
+    )
+    assert rc == 0
+    task_dir = _only_task_dir(lite_repo)
+    assert (task_dir / "prd.md").is_file()
+    assert (task_dir / "verify.md").is_file()
+    assert not (task_dir / "task-map.md").is_file()
+    data = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert data["status"] == "planning"
+    assert data["parent"] is None
+    assert data["children"] == []
+
+    check = validate_start_execution_check(task_dir, data)
+    assert check.ok
+    assert data.get("execution_approval") is None
+
+    (task_dir / "verify.md").write_text(PLACEHOLDER_VERIFY, encoding="utf-8")
+    fake = validate_archive(task_dir, data)
+    assert not fake.ok
+    assert any("verify.md" in err for err in fake.errors)
+
+    (task_dir / "verify.md").write_text(LITE_VERIFY, encoding="utf-8")
+    started = kernel_start(
+        task_dir,
+        _record(
+            id=data["id"],
+            name=data["name"],
+            title=data["title"],
+            status="in_progress",
+        ),
+        {"execution_approval": {"approved_by": "user"}},
+        expected_revision=kernel_expected_revision(task_dir),
+        actor="task.py start-execution --approved",
+        idempotency_key="start:personal-lite-slice",
+    )
+    assert started["legacy"]["status"] == "in_progress"
+
+    rc = cmd_archive(
+        argparse.Namespace(
+            name=task_dir.name,
+            check=False,
+            no_commit=False,
+            archive_integrated_children=False,
+        )
+    )
+    assert rc == 0
+    assert not (lite_repo / ".git").exists()
+    archived_root = lite_repo / ".cstl" / "tasks" / "archive"
+    archived = list(archived_root.rglob("task.json")) if archived_root.is_dir() else []
+    assert archived, "Lite Close should still move or keep Outcome on disk"
+    closed = json.loads(archived[0].read_text(encoding="utf-8"))
+    assert closed["status"] == "completed"

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

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Stage 5 Topology / On-demand 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.ondemand_topology import (
+    ONDEMAND_OWNERS,
+    STAGE5_ONDEMAND_MODULES,
+    TopologyError,
+    apply_kernel_graph_projection,
+    apply_retention,
+    assert_integration_authority,
+    assign_parent,
+    capture_candidate,
+    confirm_decompose,
+    default_topology,
+    expand_depends_on_to_requires,
+    project_task_map_graph,
+    propose_decompose,
+    resident_on_demand_modules,
+    unmet_requires,
+)
+from common.task_map import ensure_task_map
+
+
+def test_capture_and_decompose_do_not_create() -> None:
+    candidate = capture_candidate("later")
+    assert candidate["task_created"] is False
+    proposal = propose_decompose("parent-a", ["child-a"])
+    assert proposal["confirmed"] is False
+    assert proposal["children_created"] == []
+    confirmed = confirm_decompose(proposal)
+    assert confirmed["confirmed"] is True
+    assert confirmed["children_created"] == ["child-a"]
+
+
+def test_default_topology_parent_id_alone_is_single() -> None:
+    linked = default_topology(parent="parent-a", children=[])
+    assert linked["kind"] == "single"
+    assert linked["parent_id"] == "parent-a"
+    controller = default_topology(parent=None, children=["child-a"])
+    assert controller["kind"] == "parent-child"
+
+
+def test_assign_parent_keeps_ordinary_child_single() -> None:
+    linked = assign_parent({"parent_id": None, "children": []}, "parent-a")
+    assert linked["kind"] == "single"
+    assert linked["parent_id"] == "parent-a"
+    nested = assign_parent({"parent_id": None, "children": ["child-a"]}, "grand")
+    assert nested["kind"] == "parent-child"
+    assert nested["children"] == ["child-a"]
+
+
+def test_second_parent_and_child_integrate_rejected() -> None:
+    topology = {"parent_id": "parent-a", "children": []}
+    with pytest.raises(TopologyError, match="second parent"):
+        assign_parent(topology, "parent-b")
+    with pytest.raises(TopologyError, match="Integration authority"):
+        assert_integration_authority("child")
+    assert_integration_authority("parent")
+
+
+def test_requires_blocks_advisory_does_not() -> None:
+    graph = expand_depends_on_to_requires(
+        {"edges": [{"from": "here", "to": "hint", "type": "advisory"}]},
+        "here",
+        ["upstream"],
+    )
+    assert unmet_requires(graph, [], from_id="here") == ["upstream"]
+    assert unmet_requires(graph, ["upstream"], from_id="here") == []
+    assert unmet_requires(graph, [], from_id="other") == []
+
+
+def test_task_map_is_kernel_graph_projection(tmp_path: Path) -> None:
+    parent_dir = tmp_path / "parent"
+    parent_dir.mkdir()
+    extras = {
+        "topology": {
+            "kind": "parent-child",
+            "parent_id": "parent-a",
+            "children": ["child-a"],
+        },
+        "dependency_graph": {
+            "edges": [{"from": "child-a", "to": "upstream", "type": "requires"}],
+        },
+    }
+    projection = project_task_map_graph(extras["topology"], extras["dependency_graph"])
+    assert projection["graph_authority"] == "kernel-extras"
+    assert projection["children"] == [{"id": "child-a", "depends_on": ["upstream"]}]
+
+    data = ensure_task_map(
+        parent_dir,
+        {"id": "parent-a", **extras},
+        ["child-a"],
+    )
+    assert data["graph_authority"] == "kernel-extras"
+    assert data["topology_kind"] == "parent-child"
+    child = next(item for item in data["children"] if item["id"] == "child-a")
+    assert child["depends_on"] == ["upstream"]
+    apply_kernel_graph_projection(data, extras)
+    assert data["graph_authority"] == "kernel-extras"
+
+
+def test_ondemand_defaults_and_retention_outcome() -> None:
+    extras = {
+        "ondemand_modules": {
+            "registered": list(STAGE5_ONDEMAND_MODULES),
+            "active": [],
+            "owners": dict(ONDEMAND_OWNERS),
+        }
+    }
+    assert resident_on_demand_modules(extras) == []
+    assert ONDEMAND_OWNERS["integration-handoff"] == "parent-child"
+    assert ONDEMAND_OWNERS["session-transfer"] == "session-transfer"
+    assert apply_retention("completed") == "completed"

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

@@ -11,6 +11,7 @@ import pytest
 
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
+from common import kernel_command as kernel_command_mod
 from common.pool_store import (
     check_plan,
     find_item_path,
@@ -26,6 +27,19 @@ from common.pool_store import (
     validate_pool,
     write_item_frontmatter,
 )
+from common.test_kernel_command import FAKE_KERNEL
+
+
+@pytest.fixture(autouse=True)
+def fake_kernel(tmp_path, monkeypatch):
+    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 script
 
 ITEM_TEMPLATE = """\
 ---
@@ -205,6 +219,9 @@ def test_link_item_task_writes_both_sides_idempotent(tmp_path: Path) -> None:
     assert get_linked_tasks(item) == ["08-09-some-task"]
     data = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
     assert get_pool_items(data) == ["P01"]
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 1
+    assert kernel["audit"][-1]["idempotencyKey"].startswith("patch:pool-link:")
 
     second = link_item_task(repo, "P01", "08-09-some-task")
     assert second.ok

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

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Parent-Child / VCS task.json writers go through Kernel patch."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common import kernel_command as kernel_command_mod
+from common.kernel_command import KernelCliNotFound
+from common.task_store import (
+    cmd_add_subtask,
+    cmd_remove_subtask,
+    cmd_set_base_branch,
+    cmd_set_branch,
+    cmd_set_depends_mode,
+    cmd_set_deps,
+    cmd_set_scope,
+)
+from common.test_kernel_command import FAKE_KERNEL
+
+
+def _write_task(tasks_dir: Path, dir_name: str, **fields) -> Path:
+    task_dir = tasks_dir / dir_name
+    task_dir.mkdir(parents=True, exist_ok=True)
+    data = {
+        "id": dir_name,
+        "name": dir_name,
+        "title": dir_name,
+        "status": "planning",
+        "children": [],
+        "parent": None,
+        "meta": {},
+    }
+    data.update(fields)
+    (task_dir / "task.json").write_text(
+        json.dumps(data, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+    return task_dir
+
+
+def _read(task_dir: Path) -> dict:
+    return json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+
+
+@pytest.fixture
+def sandbox(tmp_path, monkeypatch):
+    repo = tmp_path / "repo"
+    tasks_dir = repo / ".cstl" / "tasks"
+    tasks_dir.mkdir(parents=True)
+    monkeypatch.setattr("common.task_store.get_repo_root", lambda: repo)
+    monkeypatch.setattr("common.task_dependencies.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
+
+
+def test_add_and_remove_subtask_go_through_kernel(sandbox) -> None:
+    _repo, tasks_dir = sandbox
+    parent_dir = _write_task(tasks_dir, "parent-x")
+    child_dir = _write_task(tasks_dir, "child-a")
+
+    rc = cmd_add_subtask(
+        argparse.Namespace(parent_dir="parent-x", child_dir="child-a")
+    )
+    assert rc == 0
+
+    parent = _read(parent_dir)
+    child = _read(child_dir)
+    assert parent["children"] == ["child-a"]
+    assert child["parent"] == "parent-x"
+    assert parent["status"] == "planning"
+    assert child["status"] == "planning"
+    assert (parent_dir / "kernel.json").is_file()
+    assert (child_dir / "kernel.json").is_file()
+    parent_kernel = json.loads((parent_dir / "kernel.json").read_text(encoding="utf-8"))
+    child_kernel = json.loads((child_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert parent_kernel["revision"] >= 1
+    assert child_kernel["revision"] >= 1
+    assert (parent_dir / "task-map.md").is_file()
+
+    rc = cmd_remove_subtask(
+        argparse.Namespace(parent_dir="parent-x", child_dir="child-a")
+    )
+    assert rc == 0
+    parent = _read(parent_dir)
+    child = _read(child_dir)
+    assert parent["children"] == []
+    assert child["parent"] is None
+    assert parent["status"] == "planning"
+
+
+def test_set_branch_base_and_scope_go_through_kernel(sandbox) -> None:
+    _repo, tasks_dir = sandbox
+    task_dir = _write_task(tasks_dir, "task-x")
+
+    assert cmd_set_branch(argparse.Namespace(dir="task-x", branch="feat/demo")) == 0
+    data = _read(task_dir)
+    assert data["branch"] == "feat/demo"
+    assert data["status"] == "planning"
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 1
+    first_revision = kernel["revision"]
+
+    assert cmd_set_base_branch(
+        argparse.Namespace(dir="task-x", base_branch="feat/stage0-clean-baseline")
+    ) == 0
+    data = _read(task_dir)
+    assert data["base_branch"] == "feat/stage0-clean-baseline"
+    assert data["branch"] == "feat/demo"
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] > first_revision
+
+    assert cmd_set_scope(argparse.Namespace(dir="task-x", scope="cli")) == 0
+    data = _read(task_dir)
+    assert data["scope"] == "cli"
+    assert data["status"] == "planning"
+
+
+def test_set_deps_and_depends_mode_go_through_kernel(sandbox) -> None:
+    _repo, tasks_dir = sandbox
+    task_dir = _write_task(tasks_dir, "task-x")
+
+    assert cmd_set_deps(argparse.Namespace(dir="task-x", dep=["dep-a", "pool:P28"])) == 0
+    data = _read(task_dir)
+    assert data["depends_on"] == ["dep-a", "pool:P28"]
+    assert data["status"] == "planning"
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 1
+    assert kernel["audit"][-1]["idempotencyKey"].startswith("patch:set-deps:")
+
+    assert cmd_set_depends_mode(argparse.Namespace(dir="task-x", mode="block")) == 0
+    data = _read(task_dir)
+    assert data["meta"]["depends_mode"] == "block"
+    assert data["depends_on"] == ["dep-a", "pool:P28"]
+    assert data["status"] == "planning"
+
+
+def test_set_branch_does_not_fallback_when_kernel_cli_missing(sandbox, monkeypatch) -> None:
+    _repo, tasks_dir = sandbox
+    task_dir = _write_task(tasks_dir, "task-x")
+
+    def _missing():
+        raise KernelCliNotFound("Kernel CLI not found")
+
+    monkeypatch.setattr(kernel_command_mod, "kernel_cli_argv", _missing)
+    rc = cmd_set_branch(argparse.Namespace(dir="task-x", branch="feat/demo"))
+    assert rc == 1
+    data = _read(task_dir)
+    assert "branch" not in data or data.get("branch") in (None, "")
+    assert not (task_dir / "kernel.json").is_file()

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

@@ -3,6 +3,9 @@
 """
 Workflow Phase Extraction.
 
+Convenience reader for the human-overview copy of `.cstl/workflow.md`.
+That file is not the runtime SSOT — Kernel extras and `task.json` are.
+
 Extracts step-level content from .cstl/workflow.md and optionally filters
 platform-specific blocks.
 

package/dist/templates/trellis/scripts/get_context.py

@@ -5,6 +5,7 @@ Get Session Context for AI Agent.
 Usage:
     python3 get_context.py                              Output context in text format
     python3 get_context.py --json                       Output context in JSON format
+    python3 get_context.py --mode lite --json           Personal Lite budgeted pack
     python3 get_context.py --mode retrieval-pack --json Output scored retrieval pack JSON
 """
 

package/dist/templates/trellis/scripts/pool.py

@@ -101,6 +101,11 @@ def cmd_show(args: argparse.Namespace) -> int:
     print(f"title: {item.title or '<missing>'}")
     print(f"status: {item.status or '<missing>'}")
     print(f"type: {item.type or '<missing>'}")
+    priority = item.frontmatter.get("priority")
+    if isinstance(priority, str) and priority.strip():
+        print(f"priority: {priority.strip()}")
+    else:
+        print("priority: <unlabeled>")
     print(f"path: {item.path}")
     if not item.linked_tasks:
         print("linked_tasks: []")