@blxzer/pactile 0.5.0

package/dist/templates/pactile/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 / ".pactile" / "tasks").mkdir(parents=True)
+    (repo / ".pactile" / ".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 / ".pactile" / "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 / ".pactile" / "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/pactile/scripts/common/test_observable_defaults.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""Tests for P1 observable defaults (verify seed, jsonl seed, dashboard summary)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.artifact_locale import default_verify_content
+from common.task_dashboard import format_verify_summary, render_task_dashboard
+from common.task_store import _resolve_seed_spec_paths, _write_seed_jsonl
+
+
+def test_default_verify_content_has_standard_sections() -> None:
+    content = default_verify_content(locale="en")
+    for heading in (
+        "## Planning check",
+        "## Execution evidence",
+        "### Validation commands",
+        "### Acceptance",
+        "### Durable learning",
+    ):
+        assert heading in content
+
+
+def test_write_seed_jsonl_uses_real_spec_paths(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    spec_root = repo_root / ".pactile" / "spec" / "guides"
+    spec_root.mkdir(parents=True)
+    (spec_root / "index.md").write_text("# index.md\n", encoding="utf-8")
+    framework_root = repo_root / ".pactile" / "framework"
+    framework_root.mkdir(parents=True)
+    for name in ("verification-strength-guide.md", "injection-budget-guide.md"):
+        (framework_root / name).write_text(f"# {name}\n", encoding="utf-8")
+
+    task_dir = repo_root / ".pactile" / "tasks" / "08-07-test-seed"
+    task_dir.mkdir(parents=True)
+    task_data = {"id": "test-seed", "package": None, "scope": None, "children": []}
+
+    jsonl_path = task_dir / "implement.jsonl"
+    _write_seed_jsonl(jsonl_path, repo_root, task_dir, task_data)
+
+    rows = [json.loads(line) for line in jsonl_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    assert len(rows) >= 2
+    assert all("file" in row for row in rows)
+    assert all(row["file"].startswith(".pactile/spec/") or row["file"].startswith(".pactile/framework/") for row in rows)
+    assert all("_example" not in row for row in rows)
+    for row in rows:
+        assert (repo_root / row["file"]).is_file()
+
+
+def test_resolve_seed_spec_paths_prefers_existing_guides(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    guides = repo_root / ".pactile" / "spec" / "guides"
+    guides.mkdir(parents=True)
+    (guides / "index.md").write_text("# index\n", encoding="utf-8")
+    framework_root = repo_root / ".pactile" / "framework"
+    framework_root.mkdir(parents=True)
+    (framework_root / "verification-strength-guide.md").write_text("# verify\n", encoding="utf-8")
+
+    task_dir = repo_root / ".pactile" / "tasks" / "08-07-test-paths"
+    task_dir.mkdir(parents=True)
+    paths = _resolve_seed_spec_paths(repo_root, task_dir, {"children": []})
+    assert len(paths) >= 2
+    assert all((repo_root / rel).is_file() for rel in paths)
+
+
+def test_format_verify_summary_missing_without_file(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: missing]"
+
+
+def test_format_verify_summary_partial_from_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "Validation commands: pytest -q — pass\n",
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: partial]"
+
+
+def test_format_verify_summary_ok_when_all_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "\n".join(
+            [
+                "Validation commands: pytest -q — pass",
+                "Check evidence: pactile-check — pass",
+                "Final acceptance evidence: all AC met",
+                "Durable learning decision: no durable learning",
+                "Reviewed change-set: git diff main..HEAD",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: ok]"
+
+
+def test_render_task_dashboard_includes_verify_summary(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".pactile" / "tasks"
+    task_dir = tasks_dir / "08-07-dashboard-task"
+    task_dir.mkdir(parents=True)
+    (task_dir / "task.json").write_text(
+        json.dumps(
+            {
+                "id": "dashboard-task",
+                "name": "dashboard-task",
+                "title": "dashboard-task",
+                "status": "planning",
+                "assignee": "dev",
+                "children": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    (task_dir / "verify.md").write_text(
+        "Validation commands: echo ok — pass\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.chdir(repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_repo_root", lambda: repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_tasks_dir", lambda _root=None: tasks_dir)
+    monkeypatch.setattr("common.task_dashboard.get_developer", lambda _root=None: "dev")
+    monkeypatch.setattr(
+        "common.active_task.resolve_selected_task",
+        lambda *_args, **_kwargs: type("Sel", (), {"task_path": None, "source": None})(),
+    )
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "[verify: partial]" in dashboard
+    assert "08-07-dashboard-task" in dashboard

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

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""Stage 5 Topology / On-demand Python projection."""
+
+from __future__ import annotations
+
+import json
+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,
+    ONDEMAND_TRIGGER_HINTS,
+    STAGE5_ONDEMAND_MODULES,
+    TopologyError,
+    activate_ondemand_module,
+    apply_kernel_graph_projection,
+    apply_retention,
+    assert_integration_authority,
+    assign_parent,
+    capture_candidate,
+    confirm_decompose,
+    deactivate_ondemand_module,
+    default_topology,
+    expand_depends_on_to_requires,
+    is_ondemand_module_active,
+    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_worker_orchestration_hints_include_isolatable_window() -> None:
+    assert "isolatable-group-dispatch-window" in ONDEMAND_TRIGGER_HINTS["worker-orchestration"]
+
+
+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"
+    assert "independent-check" in STAGE5_ONDEMAND_MODULES
+    assert "retrieval-extended" in STAGE5_ONDEMAND_MODULES
+    assert "integration-handoff" not in STAGE5_ONDEMAND_MODULES
+    assert len(STAGE5_ONDEMAND_MODULES) == 12
+
+
+def test_first_legal_trigger_writes_active_and_triggers() -> None:
+    extras: dict = {}
+    activate_ondemand_module(
+        extras,
+        "worker-orchestration",
+        reason="user-dispatch",
+        at="2026-08-31T00:00:00Z",
+    )
+    activate_ondemand_module(
+        extras,
+        "retrieval-extended",
+        reason="collected-evidence-ranking",
+        at="2026-08-31T00:00:01Z",
+    )
+    activate_ondemand_module(
+        extras,
+        "independent-check",
+        reason="rigor-full",
+        at="2026-08-31T00:00:02Z",
+    )
+    block = extras["ondemand_modules"]
+    assert "worker-orchestration" in block["active"]
+    assert "retrieval-extended" in block["active"]
+    assert "independent-check" in block["active"]
+    assert [row["module"] for row in block["triggers"]] == [
+        "worker-orchestration",
+        "retrieval-extended",
+        "independent-check",
+    ]
+    with pytest.raises(TopologyError, match="owner mapping"):
+        activate_ondemand_module(extras, "integration-handoff", reason="handoff")
+
+    hook_names = {item.get("hook") for item in extras["event_bridge"]["subscriptions"]}
+    assert "inject-subagent-context.py" in hook_names
+    assert "inject-retrieval-plan.py" in hook_names
+    deactivate_ondemand_module(extras, "worker-orchestration")
+    hook_names = {item.get("hook") for item in extras["event_bridge"]["subscriptions"]}
+    assert "inject-subagent-context.py" not in hook_names
+    assert "inject-retrieval-plan.py" in hook_names
+
+
+def test_unwritten_ondemand_is_not_active(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "task.json").write_text(
+        json.dumps({"id": "t", "ondemand_modules": {"active": []}}),
+        encoding="utf-8",
+    )
+    assert is_ondemand_module_active(task_dir, "worker-orchestration") is False
+    (task_dir / "task.json").write_text(
+        json.dumps(
+            {
+                "id": "t",
+                "ondemand_modules": {"active": ["worker-orchestration"]},
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert is_ondemand_module_active(task_dir, "worker-orchestration") is True
+
+
+def test_missing_execute_agent_rejects_start_and_close(tmp_path: Path) -> None:
+    from common.task_gates import validate_archive, validate_start_execution_check
+
+    task_dir = tmp_path / "slot-off"
+    task_dir.mkdir()
+    (task_dir / "prd.md").write_text(
+        "# PRD\n\n## Acceptance Criteria\n\n- [ ] one\n",
+        encoding="utf-8",
+    )
+    (task_dir / "verify.md").write_text(
+        "# Verification Evidence\n\n"
+        "- validation: python -c \"print('ok')\"\n"
+        "- acceptance: done\n"
+        "- durable learning: no durable learning\n",
+        encoding="utf-8",
+    )
+    data = {
+        "id": "slot-off",
+        "status": "planning",
+        "baseline_modules": {
+            "active": [
+                "intake-basic",
+                "define-basic",
+                "approval-personal",
+                "verify-basic",
+                "close-basic",
+                "context-progressive",
+                "observability-local",
+            ]
+        },
+    }
+    check = validate_start_execution_check(task_dir, data)
+    assert not check.ok
+    assert any("missing required lifecycle slot: execute-agent" in err for err in check.errors)
+
+    data["status"] = "in_progress"
+    archive = validate_archive(task_dir, data)
+    assert not archive.ok
+    assert any("missing required lifecycle slot: execute-agent" in err for err in archive.errors)