@blxzer/pactile 0.5.0

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

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""Tests for RB-010: cross-source conflict resolution integration."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, cast
+
+# Ensure the scripts directory is importable
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.retrieval_evidence import (
+    SOURCE_ARTIFACT_SEARCH,
+    SOURCE_CODEBASE_EVIDENCE,
+    SOURCE_SESSION_MEMORY,
+    SOURCE_SMART_SEARCH,
+    SOURCE_TASK_ARTIFACTS,
+    VALIDATION_CANDIDATE,
+    VALIDATION_UNVERIFIED,
+    VALIDATION_VERIFIED,
+    ScoredEvidence,
+    resolve_cross_source_conflicts,
+)
+from common.retrieval_pack import build_retrieval_pack
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _scored(
+    source: str = SOURCE_TASK_ARTIFACTS,
+    kind: str = "local-artifact",
+    reference: str = "ref.md",
+    title: str = "Test evidence",
+    status: str = "ok",
+    trust: str = "high",
+    confidence: str = "high",
+    relevance: int = 80,
+    freshness: int = 90,
+    source_authority: int = 95,
+    validation_state: str = VALIDATION_VERIFIED,
+    score: int = 90,
+    reasons: list[str] | None = None,
+    warnings: list[str] | None = None,
+) -> ScoredEvidence:
+    return ScoredEvidence(
+        source=source,
+        kind=kind,
+        reference=reference,
+        title=title,
+        status=status,
+        trust=trust,
+        confidence=confidence,
+        relevance=relevance,
+        freshness=freshness,
+        source_authority=source_authority,
+        validation_state=validation_state,
+        score=score,
+        reasons=reasons or [],
+        warnings=warnings or [],
+    )
+
+
+def _artifact_result(path: str = "spec/guide.md", title: str = "Guide", score: int = 85) -> dict[str, Any]:
+    return {"path": path, "title": title, "score": score}
+
+
+def _session_result(path: str = "memory/old.md", title: str = "Old memory", score: int = 60) -> dict[str, Any]:
+    return {"path": path, "title": title, "score": score}
+
+
+def _manifest(query: str = "test query", status: str = "ok") -> dict[str, Any]:
+    return {"query": query, "status": status, "manifestPath": "research/smart-search/run-1/manifest.json"}
+
+
+def _codebase_candidate(path: str = "src/main.py", title: str = "Main module") -> dict[str, Any]:
+    return {"path": path, "title": title}
+
+
+# ---------------------------------------------------------------------------
+# 1. resolve_cross_source_conflicts basic functionality
+# ---------------------------------------------------------------------------
+
+class TestResolveCrossSourceConflictsBasic:
+    """Migrate the 5 core PoC scenarios from RB-009."""
+
+    def test_no_conflicts_single_source(self):
+        items = [
+            _scored(source=SOURCE_TASK_ARTIFACTS, reference="a.md", title="Task A"),
+            _scored(source=SOURCE_TASK_ARTIFACTS, reference="b.md", title="Task B"),
+        ]
+        result = resolve_cross_source_conflicts(items)
+        assert result["total"] == 2
+        assert result["metrics"]["conflictCount"] == 0
+        assert result["metrics"]["blockingConflictCount"] == 0
+        assert result["metrics"]["downgradeCount"] == 0
+
+    def test_no_conflicts_different_titles(self):
+        items = [
+            _scored(source=SOURCE_TASK_ARTIFACTS, title="Auth design", reference="auth.md"),
+            _scored(source=SOURCE_SMART_SEARCH, title="Database schema", reference="db.md"),
+        ]
+        result = resolve_cross_source_conflicts(items)
+        assert result["metrics"]["conflictCount"] == 0
+
+    def test_blocking_conflict_both_verified(self):
+        items = [
+            _scored(
+                source=SOURCE_TASK_ARTIFACTS,
+                title="API endpoint design",
+                reference="api-design.md",
+                validation_state=VALIDATION_VERIFIED,
+            ),
+            _scored(
+                source=SOURCE_SMART_SEARCH,
+                title="API endpoint design",
+                reference="https://example.com/api",
+                validation_state=VALIDATION_VERIFIED,
+                source_authority=85,
+            ),
+        ]
+        result = resolve_cross_source_conflicts(items, conflict_threshold=0.3)
+        assert result["metrics"]["conflictCount"] >= 1
+        blocking = [c for c in result["conflicts"] if c["type"] == "blocking"]
+        assert len(blocking) >= 1
+
+    def test_downgrade_conflict_verified_vs_unverified(self):
+        items = [
+            _scored(
+                source=SOURCE_TASK_ARTIFACTS,
+                title="Config schema",
+                reference="config.md",
+                validation_state=VALIDATION_VERIFIED,
+            ),
+            _scored(
+                source=SOURCE_CODEBASE_EVIDENCE,
+                title="Config schema",
+                reference="src/config.ts",
+                validation_state=VALIDATION_CANDIDATE,
+                source_authority=60,
+            ),
+        ]
+        result = resolve_cross_source_conflicts(items, conflict_threshold=0.3)
+        downgraded = [
+            ae for ae in result["items"]
+            if "conflict_flagged" in ae.get("conflictFlags", [])
+        ]
+        assert len(downgraded) >= 1
+        # The candidate evidence should have lower effectiveAuthority than its base
+        candidate_item = next(
+            ae for ae in result["items"]
+            if ae["source"] == SOURCE_CODEBASE_EVIDENCE
+        )
+        assert candidate_item["effectiveAuthority"] < 60
+
+    def test_stale_session_memory_penalty(self):
+        items = [
+            _scored(
+                source=SOURCE_SESSION_MEMORY,
+                title="Old observation",
+                reference="memory/old.md",
+                freshness=20,
+                source_authority=55,
+                validation_state=VALIDATION_UNVERIFIED,
+            ),
+        ]
+        result = resolve_cross_source_conflicts(items)
+        mem_item = result["items"][0]
+        assert mem_item["effectiveAuthority"] < 55
+        assert "stale_warning" in mem_item["conflictFlags"]
+
+    def test_empty_items(self):
+        result = resolve_cross_source_conflicts([])
+        assert result["total"] == 0
+        assert result["metrics"]["conflictCount"] == 0
+
+    def test_intent_adjustment_exact(self):
+        items = [
+            _scored(
+                source=SOURCE_ARTIFACT_SEARCH,
+                title="Policy doc",
+                reference="policy.md",
+                source_authority=90,
+            ),
+            _scored(
+                source=SOURCE_CODEBASE_EVIDENCE,
+                title="Policy doc",
+                reference="src/policy.ts",
+                source_authority=60,
+            ),
+        ]
+        result = resolve_cross_source_conflicts(items, query_intent="exact")
+        artifact_item = next(
+            ae for ae in result["items"]
+            if ae["source"] == SOURCE_ARTIFACT_SEARCH
+        )
+        codebase_item = next(
+            ae for ae in result["items"]
+            if ae["source"] == SOURCE_CODEBASE_EVIDENCE
+        )
+        assert artifact_item["effectiveAuthority"] > 90  # boosted by +10
+        assert codebase_item["effectiveAuthority"] < 60  # penalized by -5
+
+
+# ---------------------------------------------------------------------------
+# 2. Integration: build_retrieval_pack no router envelope
+# ---------------------------------------------------------------------------
+
+class TestBuildRetrievalPackNoEnvelope:
+    def test_arbitration_works_without_router(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+        )
+        assert "arbitratedEvidence" in result
+        arb = cast(dict[str, Any], result["arbitratedEvidence"])
+        assert "items" in arb
+        assert "conflicts" in arb
+        assert "metrics" in arb
+        assert arb["metrics"]["totalItems"] >= 1
+
+    def test_no_intent_adjustment_without_router(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+        )
+        arb = cast(dict[str, Any], result["arbitratedEvidence"])
+        for item in arb["items"]:
+            # Without intent, effectiveAuthority == sourceAuthority
+            assert item["effectiveAuthority"] == item["sourceAuthority"]
+
+
+# ---------------------------------------------------------------------------
+# 3. Integration: router envelope with exact intent
+# ---------------------------------------------------------------------------
+
+class TestBuildRetrievalPackExactIntent:
+    def test_exact_intent_boosts_artifact_search(self):
+        router_envelope = {
+            "intents": ["exact"],
+            "steps": [],
+            "stopReasons": [],
+        }
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+            router_envelope=router_envelope,
+        )
+        arb = cast(dict[str, Any], result["arbitratedEvidence"])
+        artifact_items = [
+            ae for ae in arb["items"]
+            if ae["source"] == SOURCE_ARTIFACT_SEARCH
+        ]
+        assert len(artifact_items) >= 1
+        for item in artifact_items:
+            assert item["effectiveAuthority"] > item["sourceAuthority"]
+
+
+# ---------------------------------------------------------------------------
+# 4. Integration: conflicting sources → conflict entries
+# ---------------------------------------------------------------------------
+
+class TestBuildRetrievalPackConflicts:
+    def test_conflicting_sources_produce_conflict_entries(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[
+                {"path": "spec/api.md", "title": "API design endpoint", "score": 95},
+            ],
+            smart_search_manifests=[
+                _manifest(query="API design endpoint", status="ok"),
+            ],
+        )
+        arb = cast(dict[str, Any], result["arbitratedEvidence"])
+        # Even if no conflicts are detected due to title mismatch,
+        # the arbitrated evidence must still exist and be well-formed
+        assert "conflicts" in arb
+        assert isinstance(arb["conflicts"], list)
+        assert "metrics" in arb
+
+
+# ---------------------------------------------------------------------------
+# 5. Integration: backward compat → scoredEvidence unchanged
+# ---------------------------------------------------------------------------
+
+class TestBackwardCompat:
+    def test_scored_evidence_field_unchanged(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+            session_memory_results=[_session_result()],
+        )
+        scored = cast(dict[str, Any], result["scoredEvidence"])
+        # The scoredEvidence must have the original structure,
+        # not the arbitrated items with extra keys
+        assert "version" in scored
+        assert "total" in scored
+        assert "items" in scored
+        for item in scored["items"]:
+            # Original scored evidence items should NOT have arbitrated keys
+            assert "effectiveAuthority" not in item
+            assert "conflictFlags" not in item
+            assert "arbitrationReasons" not in item
+
+    def test_arbitrated_evidence_has_extended_keys(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+        )
+        arb = cast(dict[str, Any], result["arbitratedEvidence"])
+        for item in arb["items"]:
+            assert "effectiveAuthority" in item
+            assert "conflictFlags" in item
+            assert "arbitrationReasons" in item
+
+    def test_evidence_envelope_has_conflict_metrics(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result()],
+        )
+        envelope = cast(dict[str, Any], result["evidenceEnvelope"])
+        assert "conflictMetrics" in envelope
+        metrics = cast(dict[str, Any], envelope["conflictMetrics"])
+        assert "totalItems" in metrics
+        assert "conflictCount" in metrics
+
+    def test_context_pack_uses_arbitrated_ordering(self):
+        result = build_retrieval_pack(
+            artifact_search_results=[_artifact_result(path="a.md", score=90)],
+            session_memory_results=[_session_result(path="b.md", score=70)],
+        )
+        pack = cast(dict[str, Any], result["contextPack"])
+        # Context pack should be well-formed with selected items
+        assert "selected" in pack
+        assert "omitted" in pack
+        assert pack["summary"]["totalInput"] >= 2

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

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Dashboard Kernel-phase projection tests."""
+
+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.task_dashboard import project_kernel_surface, render_task_dashboard
+
+
+def _write_task(
+    tasks_dir: Path,
+    dir_name: str,
+    *,
+    status: str = "planning",
+    kernel_phase: str | None = None,
+    topology_kind: str | None = None,
+) -> 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": status,
+        "assignee": "dev",
+        "children": [],
+    }
+    if topology_kind is not None:
+        data["topology"] = {"kind": topology_kind}
+    (task_dir / "task.json").write_text(
+        json.dumps(data, ensure_ascii=False), encoding="utf-8"
+    )
+    if kernel_phase is not None:
+        kernel = {
+            "schemaVersion": 1,
+            "identity": {"taskId": dir_name},
+            "revision": 1,
+            "phase": kernel_phase,
+            "condition": "ready",
+            "outcome": None,
+            "audit": [],
+            "gates": {"schemaVersion": 1, "transitions": {}},
+            "projection": {"status": status, "record": data, "extras": {}},
+        }
+        (task_dir / "kernel.json").write_text(
+            json.dumps(kernel, ensure_ascii=False), encoding="utf-8"
+        )
+    return task_dir
+
+
+def _patch_dashboard(
+    monkeypatch: pytest.MonkeyPatch, repo_root: Path, tasks_dir: Path
+) -> None:
+    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}
+        )(),
+    )
+
+
+def test_kernel_define_fixture_uses_define_not_planning(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".pactile" / "tasks"
+    _write_task(
+        tasks_dir,
+        "08-31-define-fixture",
+        status="planning",
+        kernel_phase="define",
+    )
+    _patch_dashboard(monkeypatch, repo_root, tasks_dir)
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "Define:" in dashboard
+    assert "(Define)" in dashboard
+    assert "Planning:" not in dashboard
+    assert "(Planning)" not in dashboard
+    on_disk = json.loads(
+        (tasks_dir / "08-31-define-fixture" / "task.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    assert on_disk["status"] == "planning"
+
+
+def test_no_selected_task_does_not_name_micro_grill_as_mode(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".pactile" / "tasks"
+    tasks_dir.mkdir(parents=True)
+    _patch_dashboard(monkeypatch, repo_root, tasks_dir)
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "Selected task: none" in dashboard
+    assert "Micro-Grill" not in dashboard
+    assert "[Triage:]" not in dashboard
+    assert "Intake" in dashboard
+    assert "Open Proposal" in dashboard
+
+
+def test_legacy_planning_status_still_listed(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".pactile" / "tasks"
+    task_dir = _write_task(tasks_dir, "08-31-legacy-planning", status="planning")
+    _patch_dashboard(monkeypatch, repo_root, tasks_dir)
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "08-31-legacy-planning" in dashboard
+    assert "Define:" in dashboard
+    surface = project_kernel_surface(
+        task_dir,
+        json.loads((task_dir / "task.json").read_text(encoding="utf-8")),
+    )
+    assert surface["status"] == "planning"
+    assert surface["phase"] == "define"
+    assert surface["humanPhase"] == "Define"
+
+
+def test_integrate_heading_only_when_topology_needs_it(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".pactile" / "tasks"
+    _write_task(
+        tasks_dir,
+        "08-31-single-define",
+        status="planning",
+        kernel_phase="define",
+        topology_kind="single",
+    )
+    _patch_dashboard(monkeypatch, repo_root, tasks_dir)
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "Integrate:" not in dashboard
+    assert "Define:" in dashboard