continuum-toolkit 1.0.0__py3-none-any.whl

handoff/models.py

@@ -0,0 +1,88 @@
+"""
+Project Continuum - Handoff Models
+==================================
+Milestone 6 - Phase 14: Universal Handoff Package Generation.
+Encapsulates standard vendor-neutral handoff packages and disk persistence.
+"""
+
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class HandoffPackage:
+    """
+    Standard vendor-neutral Continuum Handoff Package.
+    Contains:
+    - project_state_json: machine-readable canonical state JSON string
+    - project_context_md: high-level verified architectural context Markdown
+    - handoff_md: focused continuation document for the next AI agent
+    - evidence_files: map of relative filenames to content strings in evidence/
+    """
+    project_id: str
+    package_timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    project_state_json: str = ""
+    project_context_md: str = ""
+    handoff_md: str = ""
+    evidence_files: Dict[str, str] = field(default_factory=dict)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "project_id": self.project_id,
+            "package_timestamp": self.package_timestamp,
+            "project_state_json": self.project_state_json,
+            "project_context_md": self.project_context_md,
+            "handoff_md": self.handoff_md,
+            "evidence_files": self.evidence_files,
+            "metadata": self.metadata
+        }
+
+    def save_to_directory(self, output_dir: str) -> Dict[str, str]:
+        """
+        Atomically saves the handoff package to output_dir with the standard structure:
+        - <output_dir>/project-state.json
+        - <output_dir>/project-context.md
+        - <output_dir>/handoff.md
+        - <output_dir>/evidence/<evidence_files>
+
+        Returns a dictionary mapping logical keys to their written filepaths.
+        """
+        base_path = Path(output_dir)
+        base_path.mkdir(parents=True, exist_ok=True)
+        evidence_dir = base_path / "evidence"
+        evidence_dir.mkdir(parents=True, exist_ok=True)
+
+        written_paths: Dict[str, str] = {}
+
+        # 1. project-state.json
+        state_file = base_path / "project-state.json"
+        with open(state_file, "w", encoding="utf-8") as f:
+            f.write(self.project_state_json)
+        written_paths["project-state.json"] = str(state_file.resolve())
+
+        # 2. project-context.md
+        context_file = base_path / "project-context.md"
+        with open(context_file, "w", encoding="utf-8") as f:
+            f.write(self.project_context_md)
+        written_paths["project-context.md"] = str(context_file.resolve())
+
+        # 3. handoff.md
+        handoff_file = base_path / "handoff.md"
+        with open(handoff_file, "w", encoding="utf-8") as f:
+            f.write(self.handoff_md)
+        written_paths["handoff.md"] = str(handoff_file.resolve())
+
+        # 4. evidence files
+        for rel_filename, content in self.evidence_files.items():
+            ev_file = evidence_dir / rel_filename
+            ev_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(ev_file, "w", encoding="utf-8") as f:
+                f.write(content)
+            written_paths[f"evidence/{rel_filename}"] = str(ev_file.resolve())
+
+        return written_paths

handoff/packager.py

@@ -0,0 +1,288 @@
+"""
+Project Continuum - Universal Handoff Package Generator
+========================================================
+Milestone 6 - Phase 14: Universal Handoff Package Generation.
+Generates standard vendor-neutral Continuum Handoff Packages that strictly
+distinguish verified ground truth from conversational claims, report discrepancies,
+blockers, confidence, and actionable next steps.
+"""
+
+from datetime import datetime, timezone
+import json
+from typing import Any, Dict, List, Optional
+
+from core.enums import NodeType, Status
+from core.serializer import CanonicalStateSerializer
+from core.state_models import (
+    CanonicalProjectState,
+    ContradictionRecord,
+    GraphNode,
+    ProjectState,
+    ConversationalState,
+    AgentExecutionState,
+)
+from context.models import TaskContext
+from handoff.models import HandoffPackage
+
+
+class UniversalHandoffPackager:
+    """
+    Constructs vendor-neutral Continuum handoff packages containing:
+    - project-state.json
+    - project-context.md
+    - handoff.md
+    - evidence/ directory artifacts
+    """
+
+    def __init__(self):
+        pass
+
+    def generate_package(
+        self,
+        canonical_state: CanonicalProjectState,
+        task_context: Optional[TaskContext] = None
+    ) -> HandoffPackage:
+        """
+        Synthesizes the complete handoff package from a CanonicalProjectState and
+        optional focused TaskContext.
+        """
+        # 1. Generate project-state.json (strict canonical schema)
+        project_state_json = CanonicalStateSerializer.to_json(canonical_state, indent=2)
+
+        # 2. Generate project-context.md (high-level verified architectural narrative)
+        project_context_md = self._generate_project_context_md(canonical_state)
+
+        # 3. Generate handoff.md (focused continuation briefing for the next agent)
+        handoff_md = self._generate_handoff_md(canonical_state, task_context)
+
+        # 4. Generate evidence/ directory artifacts
+        evidence_files = self._generate_evidence_artifacts(canonical_state)
+
+        metadata = {
+            "schema_version": canonical_state.schema_version,
+            "total_nodes": len(canonical_state.graph_nodes),
+            "total_edges": len(canonical_state.graph_edges),
+            "total_evidence": len(canonical_state.evidence_pool),
+            "contradiction_count": len(canonical_state.contradictions),
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+        return HandoffPackage(
+            project_id=canonical_state.project_id,
+            package_timestamp=datetime.now(timezone.utc).isoformat(),
+            project_state_json=project_state_json,
+            project_context_md=project_context_md,
+            handoff_md=handoff_md,
+            evidence_files=evidence_files,
+            metadata=metadata
+        )
+
+    def _generate_project_context_md(self, state: CanonicalProjectState) -> str:
+        """
+        Generates project-context.md: High-level architectural briefing of verified reality.
+        """
+        p_state = state.project_state
+        c_state = state.conversational_state
+
+        lines = [
+            f"# Project Continuum — Verified Project Context",
+            f"**Project ID:** `{state.project_id}` | **Schema:** `{state.schema_version}`",
+            f"**Last Scanned:** `{p_state.last_scanned_at}`",
+            "",
+            "## 1. Physical Workspace Reality",
+            f"- **Root Path:** `{p_state.root_path}`",
+            f"- **Detected Languages:** {', '.join(p_state.detected_languages) if p_state.detected_languages else 'None detected'}",
+            f"- **Source Files Tracked:** {len(p_state.files)} file(s)",
+            f"- **AST Symbols Extracted:** {len(p_state.symbols)} symbol(s)",
+            f"- **Build Status:** `[{p_state.build_status.value}]`",
+            "",
+            "### Git State",
+            f"- **Repository:** {'Yes' if p_state.git_state.is_repo else 'No'}",
+            f"- **Active Branch:** `{p_state.git_state.branch or 'N/A'}`",
+            f"- **Head Commit:** `{p_state.git_state.head_commit or 'N/A'}`",
+            f"- **Working Tree Dirty:** {'Yes (Uncommitted Changes)' if p_state.git_state.is_dirty else 'Clean'}",
+            f"- **Staged Files:** {len(p_state.git_state.staged_files)}",
+            f"- **Unstaged Files:** {len(p_state.git_state.unstaged_files)}",
+            f"- **Untracked Files:** {len(p_state.git_state.untracked_files)}",
+            "",
+            "## 2. Canonical Architecture & Component Inventory",
+        ]
+
+        if state.graph_nodes:
+            # Group by NodeType
+            nodes_by_type: Dict[str, List[GraphNode]] = {}
+            for n in state.graph_nodes.values():
+                t = n.node_type.value
+                nodes_by_type.setdefault(t, []).append(n)
+
+            for n_type, n_list in sorted(nodes_by_type.items()):
+                lines.append(f"### {n_type.capitalize()}s ({len(n_list)})")
+                for n in sorted(n_list, key=lambda x: x.name):
+                    conf_str = f" | Confidence: {n.confidence_score:.0f}%" if n.confidence_score > 0 else ""
+                    lines.append(f"- **{n.name}** (`{n.id}`): Status `[{n.status.value}]`{conf_str}")
+                lines.append("")
+        else:
+            lines.append("- *No graph components registered.*")
+            lines.append("")
+
+        lines.extend([
+            "## 3. Verified Test & Verification Baseline",
+            f"- **Recorded Test Executions:** {len(p_state.test_results)}",
+        ])
+
+        if p_state.test_results:
+            passed = [t for t in p_state.test_results if t.status.value == "VERIFIED"]
+            failed = [t for t in p_state.test_results if t.status.value != "VERIFIED"]
+            lines.append(f"- **Passing Tests:** {len(passed)}")
+            lines.append(f"- **Failing Tests:** {len(failed)}")
+            if failed:
+                lines.append("\n#### ❌ Failing Tests Detail:")
+                for ft in failed:
+                    lines.append(f"- **{ft.name}** (`{ft.suite}`): exit code {ft.exit_code}")
+                    if ft.error_message:
+                        lines.append(f"  - Error: `{ft.error_message}`")
+        lines.append("")
+
+        lines.extend([
+            "## 4. Architectural Decisions & Requirements",
+            f"- **User Requirements:** {len(c_state.user_requirements)}",
+            f"- **Recorded Decisions:** {len(c_state.architectural_decisions)}",
+        ])
+
+        if c_state.architectural_decisions:
+            for d in c_state.architectural_decisions:
+                lines.append(f"- **{d.title}**: {d.rationale}")
+                if d.constraints:
+                    for c in d.constraints:
+                        lines.append(f"  - *Constraint*: {c}")
+
+        lines.append("\n---")
+        lines.append("*Generated automatically by Project Continuum Universal Handoff Engine.*")
+        return "\n".join(lines)
+
+    def _generate_handoff_md(
+        self,
+        state: CanonicalProjectState,
+        task_context: Optional[TaskContext] = None
+    ) -> str:
+        """
+        Generates handoff.md: Tactical continuation document explaining exactly
+        what the next agent needs to do, distinguishing verified vs unverified claims.
+        """
+        exec_state = state.agent_execution_state
+        c_state = state.conversational_state
+        p_state = state.project_state
+
+        lines = [
+            "# Project Continuum — Agent Handoff Briefing",
+            f"**Session / Project ID:** `{state.project_id}`",
+            f"**Previous Agent Model:** `{exec_state.model_name}` (ID: `{exec_state.agent_id}`)",
+            f"**Handoff Generated At:** `{datetime.now(timezone.utc).isoformat()}`",
+            "",
+            "> ⚠️ **MANDATORY DIRECTIVE FOR RESUMING AGENT:**",
+            "> Maintain strict separation between verified physical evidence and conversational claims.",
+            "> Never accept unverified agent claims as completed tasks without physical verification.",
+            "",
+            "## 🎯 1. Tactical In-Flight & Active Tasks",
+        ]
+
+        if exec_state.active_tasks:
+            for t in exec_state.active_tasks:
+                lines.append(f"- **{t.title}** (`{t.id}`): Status `[{t.status.value}]`")
+                if t.target_files:
+                    lines.append(f"  - Target Files: {', '.join(f'`{f}`' for f in t.target_files)}")
+                if t.target_symbols:
+                    lines.append(f"  - Target Symbols: {', '.join(f'`{s}`' for s in t.target_symbols)}")
+                if t.notes:
+                    lines.append(f"  - Notes: {t.notes}")
+        else:
+            lines.append("- *No in-flight tasks recorded.*")
+
+        lines.extend([
+            "",
+            "## 🚀 2. Recommended Next Action",
+        ])
+
+        if exec_state.next_action:
+            na = exec_state.next_action
+            lines.append(f"- **Action Type:** `{na.action_type}`")
+            lines.append(f"- **Target URI:** `{na.target_uri}`")
+            lines.append(f"- **Description:** {na.description}")
+            if na.prerequisites:
+                lines.append(f"- **Prerequisites:** {', '.join(f'`{p}`' for p in na.prerequisites)}")
+        elif exec_state.last_error_encountered:
+            lines.append(f"- **Action Required:** Fix last encountered error: `{exec_state.last_error_encountered}`")
+        else:
+            lines.append("- *Inspect known blockers and continue highest priority in-progress component.*")
+
+        lines.extend([
+            "",
+            "## ⚠️ 3. Known Blockers & Contradiction Ledger",
+        ])
+
+        if state.contradictions:
+            lines.append(f"**Total Contradictions Detected:** {len(state.contradictions)}")
+            for c in state.contradictions:
+                res_tag = " [RESOLVED]" if c.resolved else " [ACTIVE BLOCKER]"
+                lines.append(f"- 🔴 **[{c.severity}]{res_tag}**: {c.explanation}")
+                if c.claim_text:
+                    lines.append(f"  - *Conflicting Claim*: \"{c.claim_text}\"")
+        else:
+            lines.append("- ✅ *Zero unresolved contradictions detected between claims and physical state.*")
+
+        lines.extend([
+            "",
+            "## 💬 4. Unverified Conversational Claims & Unresolved Questions",
+        ])
+
+        if c_state.agent_claims:
+            lines.append("### Unverified Agent Claims (Level 5 Evidence):")
+            for cl in c_state.agent_claims:
+                lines.append(f"- \"{cl.claim_text}\" (Claimed Status: `[{cl.claimed_status.value}]` by `{cl.source_agent}`)")
+        else:
+            lines.append("- *No unverified agent claims recorded.*")
+
+        if c_state.unresolved_questions:
+            lines.append("\n### Unresolved Questions:")
+            for uq in c_state.unresolved_questions:
+                block_tag = " **[BLOCKING]**" if uq.blocking else ""
+                lines.append(f"- ❓{block_tag} {uq.question} (Context: {uq.context or 'N/A'})")
+
+        if task_context:
+            lines.extend([
+                "",
+                "## 🔍 5. Focused Task Context",
+                task_context.to_markdown()
+            ])
+
+        lines.append("\n---")
+        lines.append("*Project Continuum AI Work Continuity Package.*")
+        return "\n".join(lines)
+
+    def _generate_evidence_artifacts(self, state: CanonicalProjectState) -> Dict[str, str]:
+        """
+        Generates artifacts for the evidence/ directory:
+        - evidence/test_results.json
+        - evidence/contradictions.json
+        - evidence/symbols_manifest.json
+        - evidence/evidence_manifest.json
+        """
+        artifacts: Dict[str, str] = {}
+
+        # 1. Test Results
+        test_data = [t.to_dict() for t in state.project_state.test_results]
+        artifacts["test_results.json"] = json.dumps(test_data, indent=2)
+
+        # 2. Contradictions
+        contra_data = [c.to_dict() for c in state.contradictions]
+        artifacts["contradictions.json"] = json.dumps(contra_data, indent=2)
+
+        # 3. Symbols
+        sym_data = [s.to_dict() for s in state.project_state.symbols]
+        artifacts["symbols_manifest.json"] = json.dumps(sym_data, indent=2)
+
+        # 4. Evidence Pool Manifest
+        ev_data = {k: v.to_dict() for k, v in state.evidence_pool.items()}
+        artifacts["evidence_manifest.json"] = json.dumps(ev_data, indent=2)
+
+        return artifacts

pipeline/__init__.py

@@ -0,0 +1,9 @@
+"""
+Project Continuum - End-to-End Pipeline Package
+===============================================
+Exposes the ContinuumPipeline and PipelineExecutionSummary.
+"""
+
+from pipeline.orchestrator import ContinuumPipeline, PipelineExecutionSummary
+
+__all__ = ["ContinuumPipeline", "PipelineExecutionSummary"]

pipeline/orchestrator.py

@@ -0,0 +1,260 @@
+"""
+Project Continuum - End-to-End Orchestrator Pipeline
+=====================================================
+Milestone 8 - Phase 19: End-to-End Integration & Polyglot Validation.
+Connects the complete Continuum pipeline:
+1. Multi-source evidence harvesting (Workspace, Config, Git, Verification, Conversation).
+2. Evidence Resolution Engine (arbitration by hierarchy level 1-5).
+3. Contradiction Detection Engine (detecting mismatches between claims and reality).
+4. Confidence Calculation Engine (explainable scoring grounded in proof).
+5. Canonical State Graph / DAG (node/edge modeling, cycle prevention, dependency propagation).
+6. Task-driven Context Selection & Budget Pruning (minimum sufficient high-signal context).
+7. Model-Specific Handoff Adapters (Claude, Codex/GPT, Gemini, Local LLM, Universal).
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from core.enums import EvidenceLevel, EvidenceType, NodeType, RelationType, Status, TargetModel
+from core.evidence import Evidence
+from core.state_models import (
+    AgentClaim,
+    AgentExecutionState,
+    CanonicalProjectState,
+    ContradictionRecord,
+    ConversationalState,
+    GraphEdge,
+    GraphNode,
+    ProjectState,
+    Requirement,
+    TestResult,
+)
+from core.serializer import CanonicalStateSerializer
+from extractors.workspace_extractor import WorkspaceEvidenceExtractor
+from extractors.config_extractor import ConfigEvidenceExtractor
+from extractors.git_extractor import GitEvidenceExtractor
+from extractors.verification_extractor import VerificationEvidenceExtractor
+from extractors.conversation_extractor import ConversationEvidenceExtractor
+from resolution.resolver import EvidenceResolver, ResolutionResult
+from contradictions.detector import ContradictionDetector
+from confidence.calculator import ConfidenceCalculator
+from graph.manager import StateGraphManager
+from context.selector import TaskContextSelector
+from context.pruner import ContextPruner
+from context.models import TaskContext
+from handoff.packager import UniversalHandoffPackager
+from handoff.adapters import get_adapter_for_model
+from handoff.models import HandoffPackage
+
+
+@dataclass
+class PipelineExecutionSummary:
+    """Summary metrics of an end-to-end pipeline execution."""
+    project_id: str
+    workspace_path: str
+    languages_detected: List[str]
+    total_files_scanned: int
+    total_symbols_extracted: int
+    total_evidence_collected: int
+    contradictions_detected: int
+    project_confidence: float
+    graph_nodes_count: int
+    graph_edges_count: int
+    context_tokens_generated: Optional[int] = None
+    handoff_formats_generated: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "project_id": self.project_id,
+            "workspace_path": self.workspace_path,
+            "languages_detected": self.languages_detected,
+            "total_files_scanned": self.total_files_scanned,
+            "total_symbols_extracted": self.total_symbols_extracted,
+            "total_evidence_collected": self.total_evidence_collected,
+            "contradictions_detected": self.contradictions_detected,
+            "project_confidence": self.project_confidence,
+            "graph_nodes_count": self.graph_nodes_count,
+            "graph_edges_count": self.graph_edges_count,
+            "context_tokens_generated": self.context_tokens_generated,
+            "handoff_formats_generated": self.handoff_formats_generated,
+        }
+
+
+class ContinuumPipeline:
+    """
+    High-level orchestrator for Project Continuum.
+    Executes the complete end-to-end pipeline from physical workspace scanning
+    to model-optimized handoff generation.
+    """
+
+    def __init__(
+        self,
+        workspace_path: Union[str, Path],
+        project_id: Optional[str] = None,
+        custom_parsers: Optional[List[Any]] = None
+    ):
+        self.workspace_path = Path(workspace_path).resolve()
+        self.project_id = project_id or f"proj_{self.workspace_path.name}"
+
+        # Initialize subsystem engines
+        self.ws_extractor = WorkspaceEvidenceExtractor(custom_parsers=custom_parsers)
+        self.config_extractor = ConfigEvidenceExtractor()
+        self.git_extractor = GitEvidenceExtractor()
+        self.verification_extractor = VerificationEvidenceExtractor()
+        self.conversation_extractor = ConversationEvidenceExtractor()
+
+        self.resolver = EvidenceResolver()
+        self.contradiction_detector = ContradictionDetector()
+        self.confidence_calculator = ConfidenceCalculator()
+        self.context_selector = TaskContextSelector()
+        self.context_pruner = ContextPruner()
+        self.universal_packager = UniversalHandoffPackager()
+
+    def run_full_analysis(
+        self,
+        conversation_input: Optional[Union[str, Path, Dict[str, Any]]] = None,
+        explicit_verification_results: Optional[List[TestResult]] = None,
+        task_description: Optional[str] = None,
+        token_budget: Optional[int] = None,
+        target_models: Optional[List[TargetModel]] = None
+    ) -> Tuple[CanonicalProjectState, PipelineExecutionSummary, Dict[str, Any]]:
+        """
+        Executes the complete end-to-end pipeline:
+        1. Workspace scanning & symbol parsing.
+        2. Manifest & config discovery.
+        3. Git tree inspection.
+        4. Test verification & results recording.
+        5. Conversation ingestion (preserving strict 3-state separation).
+        6. Truth resolution across evidence hierarchy.
+        7. Contradiction detection.
+        8. Grounded confidence computation.
+        9. DAG construction & dependency propagation.
+        10. Task-driven context selection & budget pruning.
+        11. Universal & model-specific handoff generation.
+        """
+        # Initialize Canonical State container
+        canonical_state = CanonicalProjectState(
+            schema_version="1.0.0",
+            project_id=self.project_id,
+            project_state=ProjectState(root_path=str(self.workspace_path))
+        )
+
+        # ----------------------------------------------------------------------
+        # Step 1: Physical Workspace & Source Code Evidence Extraction
+        # ----------------------------------------------------------------------
+        self.ws_extractor.populate_project_state(str(self.workspace_path), canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 2: Configuration, Environment & Manifest Extraction
+        # ----------------------------------------------------------------------
+        self.config_extractor.populate_project_state(str(self.workspace_path), canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 3: Git History & Delta Analysis
+        # ----------------------------------------------------------------------
+        self.git_extractor.populate_project_state(str(self.workspace_path), canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 4: Verification & Test Execution Recording
+        # ----------------------------------------------------------------------
+        if explicit_verification_results:
+            for tr in explicit_verification_results:
+                canonical_state.project_state.test_results.append(tr)
+                test_ev = self.verification_extractor.create_evidence(
+                    evidence_type=EvidenceType.TEST_RUN,
+                    summary=f"Test Suite: {tr.suite} (Test: {tr.name}, Status: {tr.status.value})",
+                    raw_payload=tr.to_dict(),
+                    source_uri=tr.suite,
+                    locator=f"test:{tr.suite}:{tr.name}"
+                )
+                canonical_state.add_evidence(test_ev)
+
+        # ----------------------------------------------------------------------
+        # Step 5: Conversation & Agent State Ingestion (Strict 3-State Separation)
+        # ----------------------------------------------------------------------
+        if conversation_input:
+            self.conversation_extractor.ingest_transcript(conversation_input, canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 6 & 7: Contradiction Detection & Discrepancy Resolution
+        # ----------------------------------------------------------------------
+        contradictions = self.contradiction_detector.detect_contradictions(
+            project_state=canonical_state.project_state,
+            conversational_state=canonical_state.conversational_state,
+            evidence_pool=canonical_state.evidence_pool
+        )
+        canonical_state.contradictions = contradictions
+
+        # ----------------------------------------------------------------------
+        # Step 8 & 9: Canonical State Graph (DAG) Construction
+        # ----------------------------------------------------------------------
+        graph_manager = StateGraphManager(canonical_state)
+        graph_manager.build_from_canonical_state(canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 10: Grounded Confidence Calculation
+        # ----------------------------------------------------------------------
+        proj_confidence, conf_explanation = self.confidence_calculator.calculate_project_confidence(canonical_state)
+
+        # ----------------------------------------------------------------------
+        # Step 11: Task Context Selection & Budget Pruning (Optional)
+        # ----------------------------------------------------------------------
+        task_ctx: Optional[TaskContext] = None
+        pruned_tokens = None
+        if task_description:
+            task_ctx = self.context_selector.extract_task_context(
+                task_description=task_description,
+                canonical_state=canonical_state,
+                token_budget=token_budget
+            )
+            if token_budget:
+                prune_res = self.context_pruner.prune_to_budget(task_ctx, token_budget)
+                pruned_tokens = prune_res.estimated_tokens_after
+
+        # ----------------------------------------------------------------------
+        # Step 12: Model Handoff Generation (Universal & Model-Specific)
+        # ----------------------------------------------------------------------
+        handoff_results: Dict[str, Any] = {}
+        generated_formats: List[str] = []
+
+        # Universal Handoff Package
+        universal_pkg = self.universal_packager.generate_package(canonical_state, task_ctx)
+        handoff_results["universal"] = universal_pkg
+        generated_formats.append("universal")
+
+        # Model-Specific Adapters
+        models_to_generate = target_models or [
+            TargetModel.CLAUDE,
+            TargetModel.CODEX_GPT,
+            TargetModel.GEMINI,
+            TargetModel.LOCAL_LLM
+        ]
+
+        for model in models_to_generate:
+            adapter = get_adapter_for_model(model)
+            model_handoff = adapter.generate_handoff(canonical_state)
+            handoff_results[model.value] = model_handoff
+            handoff_results[model.value.lower()] = model_handoff
+            if model == TargetModel.CODEX_GPT:
+                handoff_results["codex"] = model_handoff
+            generated_formats.append(model.value)
+
+        p_state = canonical_state.project_state
+        # Build execution summary
+        summary = PipelineExecutionSummary(
+            project_id=self.project_id,
+            workspace_path=str(self.workspace_path),
+            languages_detected=list(set(p_state.detected_languages)),
+            total_files_scanned=len(p_state.files),
+            total_symbols_extracted=len(p_state.symbols),
+            total_evidence_collected=len(canonical_state.evidence_pool),
+            contradictions_detected=len(contradictions),
+            project_confidence=proj_confidence,
+            graph_nodes_count=len(canonical_state.graph_nodes),
+            graph_edges_count=len(canonical_state.graph_edges),
+            context_tokens_generated=pruned_tokens,
+            handoff_formats_generated=generated_formats
+        )
+
+        return canonical_state, summary, handoff_results

resolution/__init__.py

@@ -0,0 +1,15 @@
+"""
+Project Continuum - Evidence Resolution Subsystem Package Initialization
+"""
+
+from resolution.resolver import (
+    EvidenceResolver,
+    EvidenceCandidate,
+    ResolutionResult,
+)
+
+__all__ = [
+    "EvidenceResolver",
+    "EvidenceCandidate",
+    "ResolutionResult",
+]