@blxzer/pactile 0.5.0

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

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""Stage 4 Full Quality: required_controls, ledger, graded Independent Check."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.full_quality import (
+    FULL_BASELINE_CONTROLS,
+    evaluate_independent_check,
+    full_quality_archive_errors,
+    resolve_required_controls,
+    rigor_from_required_controls,
+)
+from common.task_gates import (
+    task_closeout_profile,
+    validate_archive,
+    wave_c_stop_read_confirmed,
+)
+
+LITE_VERIFY = """# Verification Evidence
+
+- validation: python -c "print('ok')"
+- acceptance: Lite path completed without Parent or Git
+- durable learning: no durable learning
+"""
+
+
+def test_resolve_controls_does_not_require_design_for_standard_full() -> None:
+    standard = resolve_required_controls(rigor="full", verification_profile="standard")
+    assert standard["controls"] == list(FULL_BASELINE_CONTROLS)
+    assert "design" not in standard["controls"]
+
+    architecture = resolve_required_controls(
+        rigor="full", verification_profile="architecture"
+    )
+    assert "design" in architecture["controls"]
+
+
+def test_closeout_does_not_infer_from_files_or_children(tmp_path: Path) -> None:
+    task_dir = tmp_path / "inferred"
+    task_dir.mkdir()
+    (task_dir / "design.md").write_text("# design\n", encoding="utf-8")
+    (task_dir / "implement.md").write_text("# implement\n", encoding="utf-8")
+    assert task_closeout_profile(task_dir, {"children": ["c1"]}) == "lite"
+    assert task_closeout_profile(task_dir, {}) == "lite"
+
+
+def test_closeout_reads_legacy_classification_but_prefers_topology(
+    tmp_path: Path,
+) -> None:
+    task_dir = tmp_path / "legacy"
+    task_dir.mkdir()
+    assert (
+        task_closeout_profile(
+            task_dir,
+            {"meta": {"classification": "parent"}, "children": []},
+        )
+        == "parent"
+    )
+    assert (
+        task_closeout_profile(
+            task_dir,
+            {
+                "required_controls": resolve_required_controls(rigor="lite"),
+                "topology": {"kind": "parent-child", "parent_id": None, "children": ["c1"]},
+            },
+        )
+        == "parent"
+    )
+
+
+def test_closeout_stops_leftover_after_wave_c_confirm(tmp_path: Path) -> None:
+    (tmp_path / ".pactile").mkdir()
+    (tmp_path / ".pactile" / ".p36-wave-c.json").write_text(
+        '{"schema_version": 1, "wave": "C", "confirmed": true, "confirmedAt": "2026-08-29T00:00:00Z"}\n',
+        encoding="utf-8",
+    )
+    child = tmp_path / ".pactile" / "tasks" / "linked-child"
+    child.mkdir(parents=True)
+    assert wave_c_stop_read_confirmed(child) is True
+    assert (
+        task_closeout_profile(
+            child,
+            {
+                "parent": "parent-a",
+                "children": [],
+                "meta": {"classification": "parent"},
+                "kind": "parent",
+                "topology": {"kind": "single", "parent_id": "parent-a", "children": []},
+            },
+        )
+        == "lite"
+    )
+    parent = tmp_path / ".pactile" / "tasks" / "controller"
+    parent.mkdir(parents=True)
+    assert (
+        task_closeout_profile(
+            parent,
+            {
+                "required_controls": resolve_required_controls(rigor="lite"),
+                "topology": {
+                    "kind": "parent-child",
+                    "parent_id": None,
+                    "children": ["linked-child"],
+                },
+            },
+        )
+        == "parent"
+    )
+
+
+def test_closeout_profile_prefers_required_controls_over_files(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "design.md").write_text("# design\n", encoding="utf-8")
+    (task_dir / "implement.md").write_text("# implement\n", encoding="utf-8")
+    lite = {
+        "children": [],
+        "required_controls": resolve_required_controls(rigor="lite"),
+    }
+    assert task_closeout_profile(task_dir, lite) == "lite"
+    assert rigor_from_required_controls(lite) == "lite"
+
+    full = {
+        "children": [],
+        "required_controls": resolve_required_controls(rigor="full"),
+    }
+    assert task_closeout_profile(tmp_path / "no-design", full) == "full"
+
+
+def test_archive_full_requires_ledger_and_check(tmp_path: Path) -> None:
+    task_dir = tmp_path / "full"
+    task_dir.mkdir()
+    (task_dir / "prd.md").write_text(
+        "# Full\n\n## Acceptance Criteria\n\n- [x] Ledger maps AC\n",
+        encoding="utf-8",
+    )
+    (task_dir / "implement.md").write_text("execution_mode: inline\n", encoding="utf-8")
+    (task_dir / "verify.md").write_text(LITE_VERIFY, encoding="utf-8")
+    data = {
+        "status": "in_progress",
+        "children": [],
+        "parent": None,
+        "required_controls": resolve_required_controls(rigor="full"),
+    }
+    missing = full_quality_archive_errors(task_dir, data)
+    assert any("ledger" in err for err in missing)
+
+    data["ac_evidence_ledger"] = {
+        "items": [{"ac_id": "AC-1", "evidence_ref": "verify.md#validation"}],
+        "source_fingerprint": "stale",
+    }
+    data["independent_check"] = evaluate_independent_check(
+        mode="self-review",
+        independent_worker_available=False,
+        evidence="self-review notes",
+        code_fingerprint="code-v1",
+    )
+    stale = full_quality_archive_errors(task_dir, data)
+    assert any("stale" in err for err in stale)
+
+    blocked = evaluate_independent_check(
+        mode="true-independent",
+        independent_worker_available=False,
+        evidence="would-be independent",
+        code_fingerprint="code-v1",
+    )
+    assert blocked["result"] == "BLOCKED"
+    data["independent_check"] = blocked
+    blocked_errors = full_quality_archive_errors(task_dir, data)
+    assert any("PASS" in err or "independent worker" in err for err in blocked_errors)
+
+
+def test_lite_archive_does_not_require_independent_check(tmp_path: Path) -> None:
+    task_dir = tmp_path / "lite-quality"
+    task_dir.mkdir()
+    (task_dir / "prd.md").write_text(
+        "# Lite\n\n## Acceptance Criteria\n\n- [x] Close\n",
+        encoding="utf-8",
+    )
+    (task_dir / "verify.md").write_text(LITE_VERIFY, encoding="utf-8")
+    data = {
+        "id": "lite-quality",
+        "name": "lite-quality",
+        "title": "Lite",
+        "status": "in_progress",
+        "children": [],
+        "parent": None,
+    }
+    guard = validate_archive(task_dir, data)
+    assert guard.ok
+    assert guard.closeout_profile == "lite"
+    assert full_quality_archive_errors(task_dir, data) == []

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

@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+"""Characterization tests for Stage 2 Python → Kernel Command shim."""
+
+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 import kernel_command as kernel_command_mod
+from common.kernel_command import (
+    KERNEL_PROJECTION_EXTRA_KEYS,
+    KernelCommandError,
+    kernel_archive,
+    kernel_create,
+    kernel_expected_revision,
+    kernel_patch,
+    kernel_projection_extras,
+    kernel_record_gate,
+    kernel_start,
+    run_kernel_command,
+    to_kernel_record,
+)
+from common.artifact_locale import set_task_artifact_locale
+from common.task_gates import (
+    KERNEL_PROJECTION_EXTRA_KEYS as GATES_PROJECTION_EXTRA_KEYS,
+    collect_kernel_projection_extras,
+    write_gate_record,
+)
+
+FAKE_KERNEL = r"""
+import json
+import sys
+from pathlib import Path
+
+req = json.loads(sys.stdin.read())
+op = req.get("op")
+task_dir = Path(req["taskDir"])
+task_dir.mkdir(parents=True, exist_ok=True)
+kernel_path = task_dir / "kernel.json"
+task_path = task_dir / "task.json"
+
+def dump(payload, code=0):
+    sys.stdout.write(json.dumps(payload) + "\n")
+    sys.exit(code)
+
+def read_kernel():
+    if kernel_path.is_file():
+        return json.loads(kernel_path.read_text(encoding="utf-8"))
+    return {
+        "schemaVersion": 1,
+        "identity": {"taskId": "missing"},
+        "revision": 0,
+        "phase": "define",
+        "condition": "ready",
+        "outcome": None,
+        "audit": [],
+        "gates": {"schemaVersion": 1, "transitions": {}},
+        "projection": None,
+    }
+
+if op == "read":
+    kernel = read_kernel()
+    status = "planning"
+    if task_path.is_file():
+        status = json.loads(task_path.read_text(encoding="utf-8")).get("status", "planning")
+    dump({
+        "ok": True,
+        "op": "read",
+        "kernel": kernel,
+        "persisted": kernel_path.is_file(),
+        "legacy": {
+            "status": status,
+            "id": kernel["identity"]["taskId"],
+            "name": kernel["identity"]["taskId"],
+            "title": "",
+        },
+    })
+
+record = req.get("record") or {}
+existing_task = {}
+if task_path.is_file():
+    existing_task = json.loads(task_path.read_text(encoding="utf-8"))
+
+status_by_op = {
+    "create": "planning",
+    "start": "in_progress",
+    "archive": "completed",
+}
+if op == "patch":
+    status = existing_task.get("status") or (record.get("status") if isinstance(record, dict) else None) or "planning"
+elif op == "record-gate" and existing_task:
+    status = existing_task.get("status", "planning")
+else:
+    status = status_by_op.get(op, "planning")
+
+prev = read_kernel()
+revision = int(prev.get("revision") or 0) + 1
+task_id = "task"
+if isinstance(record, dict) and record.get("id"):
+    task_id = record["id"]
+elif prev.get("identity", {}).get("taskId"):
+    task_id = prev["identity"]["taskId"]
+
+phase_by_op = {
+    "create": "define",
+    "start": "execute",
+    "archive": "close",
+    "record-gate": prev.get("phase", "define"),
+    "patch": prev.get("phase", "define"),
+}
+kernel = {
+    "schemaVersion": 1,
+    "identity": {"taskId": task_id},
+    "revision": revision,
+    "phase": phase_by_op.get(op, "define"),
+    "condition": "ready",
+    "outcome": "completed" if op == "archive" else None,
+    "audit": list(prev.get("audit") or []) + [{
+        "id": "a1",
+        "idempotencyKey": req.get("idempotencyKey"),
+        "actor": req.get("actor"),
+    }],
+    "gates": prev.get("gates") or {"schemaVersion": 1, "transitions": {}},
+    "projection": {"status": status, "record": record, "extras": req.get("extras") or {}},
+}
+if op == "record-gate":
+    kernel["gates"].setdefault("transitions", {}).setdefault(req["transition"], {})[req["gate"]] = req["record"]
+
+kernel_path.write_text(json.dumps(kernel, indent=2), encoding="utf-8")
+projected = dict(existing_task)
+if op != "record-gate" and isinstance(record, dict) and record:
+    projected.update(record)
+    if isinstance(record.get("meta"), dict) and isinstance(existing_task.get("meta"), dict):
+        projected["meta"] = {**existing_task["meta"], **record["meta"]}
+    projected["status"] = status
+projected.update(req.get("extras") or {})
+if projected:
+    task_path.write_text(json.dumps(projected, indent=2), encoding="utf-8")
+
+dump({
+    "ok": True,
+    "op": op,
+    "kernel": kernel,
+    "persisted": True,
+    "projected": True,
+    "idempotent": False,
+    "legacy": {"status": status, "id": task_id, "name": task_id, "title": ""},
+    "audit": kernel["audit"][-1],
+})
+"""
+
+
+@pytest.fixture
+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
+
+
+def _record(**overrides):
+    data = {
+        "id": "shim-demo",
+        "name": "shim-demo",
+        "title": "Shim Demo",
+        "description": "",
+        "status": "planning",
+        "dev_type": None,
+        "scope": None,
+        "package": None,
+        "priority": "P2",
+        "creator": "tester",
+        "assignee": "tester",
+        "createdAt": "2026-08-28",
+        "completedAt": None,
+        "branch": None,
+        "base_branch": "main",
+        "worktree_path": None,
+        "commit": None,
+        "pr_url": None,
+        "subtasks": [],
+        "children": [],
+        "parent": None,
+        "relatedFiles": [],
+        "notes": "",
+        "meta": {},
+    }
+    data.update(overrides)
+    return data
+
+
+def test_to_kernel_record_fills_canonical_fields():
+    record = to_kernel_record({"id": "a", "name": "a", "title": "A"})
+    assert record["status"] == "planning"
+    assert record["priority"] == "P2"
+    assert record["children"] == []
+    assert record["meta"] == {}
+
+
+def test_create_updates_kernel_json(fake_kernel, tmp_path):
+    task_dir = tmp_path / "task"
+    result = kernel_create(
+        task_dir,
+        _record(),
+        actor="task.py create",
+        idempotency_key="create:shim-demo",
+    )
+    assert result["ok"] is True
+    assert (task_dir / "kernel.json").is_file()
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 1
+    task = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert task["status"] == "planning"
+
+
+def test_start_projects_in_progress(fake_kernel, tmp_path):
+    task_dir = tmp_path / "task"
+    kernel_create(task_dir, _record(), actor="a", idempotency_key="create:shim-demo")
+    rev = kernel_expected_revision(task_dir)
+    started = kernel_start(
+        task_dir,
+        _record(status="in_progress"),
+        {"execution_approval": {"approved_by": "user"}},
+        expected_revision=rev,
+        actor="task.py start-execution --approved",
+        idempotency_key="start:shim-demo",
+    )
+    assert started["legacy"]["status"] == "in_progress"
+    task = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert task["status"] == "in_progress"
+    assert task["execution_approval"]["approved_by"] == "user"
+
+
+def test_record_gate_and_archive_go_through_kernel(fake_kernel, tmp_path):
+    task_dir = tmp_path / "task"
+    kernel_create(task_dir, _record(), actor="a", idempotency_key="create:shim-demo")
+    data = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    gate = {"result": "PASS", "evidence": "verify.md", "reviewer": "tester"}
+    write_gate_record(data, "start-execution", "code-review", gate)
+    extras = collect_kernel_projection_extras(data)
+    kernel_record_gate(
+        task_dir,
+        expected_revision=kernel_expected_revision(task_dir),
+        actor="task.py record-gate",
+        idempotency_key="gate:code-review",
+        transition="start-execution",
+        gate="code-review",
+        record=gate,
+        extras=extras,
+        evidence="verify.md",
+    )
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["gates"]["transitions"]["start-execution"]["code-review"]["result"] == "PASS"
+
+    archived = kernel_archive(
+        task_dir,
+        _record(status="completed", completedAt="2026-08-28"),
+        extras,
+        expected_revision=kernel_expected_revision(task_dir),
+        actor="task.py archive",
+        idempotency_key="archive:shim-demo",
+    )
+    assert archived["kernel"]["phase"] == "close"
+    task = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert task["status"] == "completed"
+
+
+def test_half_conversion_is_not_success(tmp_path, monkeypatch):
+    script = tmp_path / "failing_kernel.py"
+    script.write_text(
+        "import json,sys\n"
+        "json.loads(sys.stdin.read())\n"
+        "sys.stdout.write(json.dumps({"
+        '"ok": False, "error": {"code": "HALF_CONVERSION", "message": "projection failed"},'
+        '"halfConversion": {"kernelPersisted": True, "projectionPersisted": False}'
+        "})+'\\n')\n"
+        "sys.exit(1)\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        kernel_command_mod,
+        "kernel_cli_argv",
+        lambda: [sys.executable, str(script)],
+    )
+    with pytest.raises(KernelCommandError) as exc:
+        run_kernel_command({"op": "create", "taskDir": str(tmp_path / "t")})
+    assert "HALF_CONVERSION" in str(exc.value)
+    assert exc.value.result["halfConversion"]["kernelPersisted"] is True
+    assert exc.value.result["halfConversion"]["projectionPersisted"] is False
+
+
+def test_kernel_patch_updates_meta_and_kernel_revision(fake_kernel, tmp_path):
+    task_dir = tmp_path / "task"
+    kernel_create(task_dir, _record(), actor="a", idempotency_key="create:shim-demo")
+    data = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    data["meta"] = {"pool_items": ["P28"]}
+    patched = kernel_patch(
+        task_dir,
+        data,
+        kernel_projection_extras(data),
+        expected_revision=kernel_expected_revision(task_dir),
+        actor="pool.py link",
+        idempotency_key="patch:pool-link:task:P28",
+    )
+    assert patched["ok"] is True
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 2
+    assert kernel["audit"][-1]["idempotencyKey"] == "patch:pool-link:task:P28"
+    task = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert task["status"] == "planning"
+    assert task["meta"]["pool_items"] == ["P28"]
+
+
+def test_set_task_artifact_locale_goes_through_kernel(fake_kernel, tmp_path):
+    task_dir = tmp_path / "task"
+    kernel_create(task_dir, _record(), actor="a", idempotency_key="create:shim-demo")
+    set_task_artifact_locale(task_dir, "en")
+    kernel = json.loads((task_dir / "kernel.json").read_text(encoding="utf-8"))
+    assert kernel["revision"] >= 2
+    task = json.loads((task_dir / "task.json").read_text(encoding="utf-8"))
+    assert task["meta"]["artifact_locale"] == "en"
+    assert task["status"] == "planning"
+
+
+def test_projection_extra_keys_include_baseline_modules() -> None:
+    assert "baseline_modules" in KERNEL_PROJECTION_EXTRA_KEYS
+    assert tuple(KERNEL_PROJECTION_EXTRA_KEYS) == tuple(GATES_PROJECTION_EXTRA_KEYS)