@blxzer/pactile 0.5.0 → 0.6.0-beta.2

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

@@ -1,190 +0,0 @@
-#!/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

@@ -1,141 +0,0 @@
-#!/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

@@ -1,237 +0,0 @@
-#!/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)