@blxzer/pactile 0.5.0 → 0.6.0-beta.4

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

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

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