devcouncil 0.2.0 → 0.2.2

package/src/devcouncil/app/errors.py

@@ -1,23 +0,0 @@
-class DevCouncilError(Exception):
-    """Base exception for all DevCouncil errors."""
-    pass
-
-class GatingError(DevCouncilError):
-    """Raised when a task or plan fails a mandatory gate."""
-    pass
-
-class ConfigurationError(DevCouncilError):
-    """Raised when the project configuration is invalid or missing."""
-    pass
-
-class OrchestrationError(DevCouncilError):
-    """Raised when the orchestrator encounters an unexpected state."""
-    pass
-
-class ExecutionError(DevCouncilError):
-    """Raised when an external or internal executor fails to run a task."""
-    pass
-
-class VerificationError(DevCouncilError):
-    """Raised when the verifier fails to run its checks properly."""
-    pass

package/src/devcouncil/app/events.py

@@ -1,44 +0,0 @@
-from typing import Any, Callable, Dict, List
-import inspect
-import logging
-
-logger = logging.getLogger(__name__)
-
-class EventBus:
-    """Simple asynchronous event bus for DevCouncil orchestration."""
-    def __init__(self):
-        self._listeners: Dict[str, List[Callable]] = {}
-
-    def subscribe(self, event_type: str, callback: Callable):
-        if event_type not in self._listeners:
-            self._listeners[event_type] = []
-        self._listeners[event_type].append(callback)
-
-    async def emit(self, event_type: str, payload: Any = None):
-        """Emit an event asynchronously to all registered listeners.
-        
-        Supports both sync and async callbacks.
-        """
-        logger.debug(f"Event emitted: {event_type}")
-        if event_type in self._listeners:
-            for callback in self._listeners[event_type]:
-                try:
-                    if inspect.iscoroutinefunction(callback):
-                        await callback(payload)
-                    else:
-                        callback(payload)
-                except Exception as e:
-                    logger.error(f"Error in event listener for {event_type}: {e}")
-
-# Global event bus instance
-bus = EventBus()
-
-# Standard Event Types
-class EventTypes:
-    PLANNING_STARTED = "planning_started"
-    PLANNING_COMPLETED = "planning_completed"
-    TASK_EXECUTING = "task_executing"
-    TASK_VERIFIED = "task_verified"
-    TASK_BLOCKED = "task_blocked"
-    GATE_FAILED = "gate_failed"
-    MODEL_CALLED = "model_called"

package/src/devcouncil/app/orchestrator.py

@@ -1,92 +0,0 @@
-import logging
-import json
-from pathlib import Path
-from typing import Optional, Any
-
-from devcouncil.app.state_machine import StateMachine, ProjectPhase
-from devcouncil.app.run_context import RunContext
-from devcouncil.app.events import bus, EventTypes
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import StateRepository
-from devcouncil.telemetry.traces import TraceLogger
-
-logger = logging.getLogger(__name__)
-
-class Orchestrator:
-    """Central orchestrator managing the workflow lifecycle and state transitions."""
-    def __init__(self, project_root: Path, persist_state: bool = True):
-        self.project_root = project_root
-        self.persist_state = persist_state
-        
-        db = get_db(self.project_root)
-        if db:
-            with db.get_session() as session:
-                repo = StateRepository(session)
-                state = repo.get_state()
-                if state:
-                    self.state_machine = StateMachine(ProjectPhase(state.current_phase))
-                    self.state_machine._history = [ProjectPhase(p) for p in json.loads(state.history_json)]
-                else:
-                    self.state_machine = StateMachine(ProjectPhase.NEW)
-        else:
-            self.state_machine = StateMachine(ProjectPhase.NEW)
-            
-        self.current_run: Optional[RunContext] = None
-
-    def reset_state_machine(self, initial: ProjectPhase = ProjectPhase.NEW):
-        """Start a new lifecycle sequence without depending on prior persisted phase."""
-        self.state_machine = StateMachine(initial)
-
-    async def start_run(self, run_id: str, goal: str) -> RunContext:
-        """Start a new orchestration run."""
-        self.current_run = RunContext(
-            run_id=run_id,
-            project_root=str(self.project_root),
-            goal=goal
-        )
-        self.current_run.initialize()
-        TraceLogger(self.project_root).log_event(
-            "planning_started",
-            {"goal": goal},
-            run_id=run_id,
-            summary=f"Planning started: {goal}",
-        )
-        
-        await bus.emit(EventTypes.PLANNING_STARTED, {"run_id": run_id, "goal": goal})
-        return self.current_run
-
-    async def transition_to(self, target_phase: ProjectPhase):
-        """Transition the project phase and emit events."""
-        old_phase = self.state_machine.phase
-        self.state_machine.transition(target_phase)
-        
-        db = get_db(self.project_root)
-        if db and self.persist_state:
-            with db.get_session() as session:
-                repo = StateRepository(session)
-                repo.save_state(
-                    self.state_machine.phase.value,
-                    [p.value for p in self.state_machine.history]
-                )
-                
-        logger.info(f"Transitioned from {old_phase.value} to {target_phase.value}")
-        TraceLogger(self.project_root).log_event(
-            "phase_transition",
-            {"from": old_phase.value, "to": target_phase.value},
-            run_id=self.current_run.run_id if self.current_run else None,
-            summary=f"{old_phase.value} -> {target_phase.value}",
-        )
-        
-        if target_phase == ProjectPhase.PLAN_APPROVED:
-            await bus.emit(EventTypes.PLANNING_COMPLETED, {"run_id": self.current_run.run_id if self.current_run else None})
-
-    def save_run_artifact(self, name: str, data: Any, is_json: bool = True):
-        """Save a local artifact specific to this run (in .devcouncil/runs/)."""
-        if not self.current_run:
-            logger.warning("Attempted to save artifact without an active run context.")
-            return
-            
-        if is_json:
-            self.current_run.save_json_artifact(name, data)
-        else:
-            self.current_run.save_artifact(name, data)

package/src/devcouncil/app/project_status.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from devcouncil.artifacts.graph import ArtifactGraph
-
-
-def compute_phase(graph: ArtifactGraph, persisted_phase: str | None = None) -> str:
-    """Compute the current project phase, honoring explicit persisted state first."""
-    if persisted_phase:
-        return persisted_phase
-
-    reqs = list(graph.requirements.values())
-    tasks = list(graph.tasks.values())
-    blocking_gaps = graph.blocking_gaps()
-    if not reqs and not tasks:
-        return "NEW"
-    if reqs and not tasks:
-        return "REQUIREMENTS_DRAFTED"
-    if blocking_gaps:
-        return "TASK_BLOCKED"
-    if tasks:
-        statuses = {task.status for task in tasks}
-        if "running" in statuses:
-            return "TASK_EXECUTING"
-        if "blocked" in statuses:
-            return "TASK_BLOCKED"
-        if all(status in {"verified", "done"} for status in statuses):
-            return "PROJECT_DONE"
-        return "PLAN_APPROVED"
-    return "NEW"

package/src/devcouncil/app/run_context.py

@@ -1,39 +0,0 @@
-from pathlib import Path
-from datetime import datetime, timezone
-from pydantic import BaseModel, Field
-from typing import Optional, List, Dict, Any
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-class RunContext(BaseModel):
-    """Context object encapsulating the current execution run."""
-    run_id: str
-    project_root: str
-    goal: Optional[str] = None
-    start_time: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    active_tasks: List[str] = Field(default_factory=list)
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    
-    @property
-    def run_dir(self) -> Path:
-        return Path(self.project_root) / ".devcouncil" / "runs" / self.run_id
-
-    def initialize(self):
-        """Create the necessary run directory and sub-folders."""
-        self.run_dir.mkdir(parents=True, exist_ok=True)
-        logger.info(f"Initialized run context at {self.run_dir}")
-
-    def save_artifact(self, filename: str, content: str):
-        """Save a text artifact associated with this run."""
-        path = self.run_dir / filename
-        path.write_text(content, encoding="utf-8")
-        logger.debug(f"Saved artifact to {path}")
-
-    def save_json_artifact(self, filename: str, data: Any):
-        """Save a JSON artifact associated with this run."""
-        path = self.run_dir / filename
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=2)
-        logger.debug(f"Saved JSON artifact to {path}")

package/src/devcouncil/app/state_machine.py

@@ -1,108 +0,0 @@
-"""Gating state machine for DevCouncil project lifecycle.
-
-States (from §12):
-  NEW -> REPO_MAPPED -> REQUIREMENTS_DRAFTED -> PLANS_GENERATED
-  -> CRITIQUES_GENERATED -> ARBITRATED -> AWAITING_USER_DECISIONS
-  -> PLAN_APPROVED -> TASK_READY -> TASK_EXECUTING -> TASK_VERIFYING
-  -> TASK_BLOCKED | TASK_VERIFIED -> PROJECT_DONE
-"""
-
-from __future__ import annotations
-
-from enum import Enum
-from typing import Dict, List, Set
-
-
-
-class ProjectPhase(str, Enum):
-    NEW = "NEW"
-    REPO_MAPPED = "REPO_MAPPED"
-    REQUIREMENTS_DRAFTED = "REQUIREMENTS_DRAFTED"
-    PLANS_GENERATED = "PLANS_GENERATED"
-    CRITIQUES_GENERATED = "CRITIQUES_GENERATED"
-    ARBITRATED = "ARBITRATED"
-    AWAITING_USER_DECISIONS = "AWAITING_USER_DECISIONS"
-    PLAN_APPROVED = "PLAN_APPROVED"
-    TASK_READY = "TASK_READY"
-    TASK_EXECUTING = "TASK_EXECUTING"
-    TASK_VERIFYING = "TASK_VERIFYING"
-    TASK_BLOCKED = "TASK_BLOCKED"
-    TASK_VERIFIED = "TASK_VERIFIED"
-    PROJECT_DONE = "PROJECT_DONE"
-
-
-# Valid transitions: from_phase -> set of valid next phases
-TRANSITIONS: Dict[ProjectPhase, Set[ProjectPhase]] = {
-    ProjectPhase.NEW: {ProjectPhase.REPO_MAPPED},
-    ProjectPhase.REPO_MAPPED: {ProjectPhase.REQUIREMENTS_DRAFTED},
-    ProjectPhase.REQUIREMENTS_DRAFTED: {ProjectPhase.PLANS_GENERATED},
-    ProjectPhase.PLANS_GENERATED: {ProjectPhase.CRITIQUES_GENERATED},
-    ProjectPhase.CRITIQUES_GENERATED: {ProjectPhase.ARBITRATED},
-    ProjectPhase.ARBITRATED: {
-        ProjectPhase.AWAITING_USER_DECISIONS,
-        ProjectPhase.PLAN_APPROVED,
-    },
-    ProjectPhase.AWAITING_USER_DECISIONS: {ProjectPhase.PLAN_APPROVED},
-    ProjectPhase.PLAN_APPROVED: {ProjectPhase.TASK_READY},
-    ProjectPhase.TASK_READY: {ProjectPhase.TASK_EXECUTING},
-    ProjectPhase.TASK_EXECUTING: {ProjectPhase.TASK_VERIFYING},
-    ProjectPhase.TASK_VERIFYING: {
-        ProjectPhase.TASK_VERIFIED,
-        ProjectPhase.TASK_BLOCKED,
-    },
-    ProjectPhase.TASK_BLOCKED: {
-        ProjectPhase.TASK_READY,  # after repair
-    },
-    ProjectPhase.TASK_VERIFIED: {
-        ProjectPhase.TASK_READY,  # next task
-        ProjectPhase.PROJECT_DONE,
-    },
-    ProjectPhase.PROJECT_DONE: set(),
-}
-
-
-class InvalidTransitionError(Exception):
-    """Raised when a state transition is not allowed."""
-
-    def __init__(self, current: ProjectPhase, target: ProjectPhase):
-        self.current = current
-        self.target = target
-        super().__init__(
-            f"Invalid transition: {current.value} -> {target.value}. "
-            f"Valid targets: {', '.join(t.value for t in TRANSITIONS.get(current, set()))}"
-        )
-
-
-class StateMachine:
-    """Manages project phase transitions with validation."""
-
-    def __init__(self, initial: ProjectPhase = ProjectPhase.NEW):
-        self._phase = initial
-        self._history: List[ProjectPhase] = [initial]
-
-    @property
-    def phase(self) -> ProjectPhase:
-        return self._phase
-
-    @property
-    def history(self) -> List[ProjectPhase]:
-        return list(self._history)
-
-    def can_transition(self, target: ProjectPhase) -> bool:
-        """Check if a transition to the target phase is valid."""
-        valid = TRANSITIONS.get(self._phase, set())
-        return target in valid
-
-    def transition(self, target: ProjectPhase) -> None:
-        """Transition to a new phase.
-        
-        Raises InvalidTransitionError if the transition is not allowed.
-        """
-        if not self.can_transition(target):
-            raise InvalidTransitionError(self._phase, target)
-        self._phase = target
-        self._history.append(target)
-
-    def valid_transitions(self) -> Set[ProjectPhase]:
-        """Return the set of valid next phases from the current state."""
-        return TRANSITIONS.get(self._phase, set())

package/src/devcouncil/artifacts/__init__.py

@@ -1 +0,0 @@
-"""Artifact package: graph, coverage, and validation for the persistent artifact DAG."""

package/src/devcouncil/artifacts/coverage.py

@@ -1,96 +0,0 @@
-"""Coverage analysis utilities for the artifact graph."""
-
-from __future__ import annotations
-
-from typing import Dict, List, Tuple
-
-from devcouncil.artifacts.graph import ArtifactGraph
-
-
-def requirement_task_matrix(graph: ArtifactGraph) -> List[Dict[str, str]]:
-    """Build a requirement → task → status coverage matrix for reporting.
-    
-    Returns a list of dicts suitable for rendering as a table:
-      [{"requirement": "REQ-001", "title": "...", "task": "TASK-001", "task_status": "verified"}, ...]
-    """
-    rows: List[Dict[str, str]] = []
-    for req in graph.requirements.values():
-        linked_tasks = [
-            t for t in graph.tasks.values() if req.id in t.requirement_ids
-        ]
-        if not linked_tasks:
-            rows.append({
-                "requirement": req.id,
-                "title": req.title,
-                "task": "(none)",
-                "task_status": "NOT PLANNED",
-            })
-        else:
-            for task in linked_tasks:
-                rows.append({
-                    "requirement": req.id,
-                    "title": req.title,
-                    "task": task.id,
-                    "task_status": task.status,
-                })
-    return rows
-
-
-def acceptance_criteria_evidence_matrix(
-    graph: ArtifactGraph,
-) -> List[Dict[str, str]]:
-    """Build an AC → evidence mapping for the final report.
-    
-    Returns rows with requirement_id, ac_id, ac_description, evidence_status.
-    """
-    evidenced: Dict[str, str] = {}
-    for ev in graph.test_evidence:
-        key = ev.acceptance_criterion_id
-        evidenced[key] = ev.status  # "passed", "failed", "not_run"
-
-    rows: List[Dict[str, str]] = []
-    for req in graph.requirements.values():
-        for ac in req.acceptance_criteria:
-            status = evidenced.get(ac.id, "no_evidence")
-            rows.append({
-                "requirement_id": req.id,
-                "ac_id": ac.id,
-                "description": ac.description,
-                "verification_method": ac.verification_method,
-                "status": status,
-            })
-    return rows
-
-
-def can_approve_plan(graph: ArtifactGraph) -> Tuple[bool, List[str]]:
-    """Check if the plan meets the PLAN_APPROVED gate criteria.
-    
-    Returns (passed, list_of_reasons_if_failed).
-    
-    Criteria (from §12):
-      - Every requirement has acceptance criteria.
-      - Every acceptance criterion has a verification method.
-      - Every requirement maps to at least one task.
-      - Every task maps to at least one requirement.
-      - Every high-impact assumption is confirmed or converted.
-      - No critical critique finding remains open.
-      - No blocking question remains unanswered.
-    """
-    reasons: List[str] = []
-
-    for req in graph.requirements_without_acceptance_criteria():
-        reasons.append(f"{req.id} has no acceptance criteria.")
-
-    for req in graph.requirements_without_tasks():
-        reasons.append(f"{req.id} is not mapped to any task.")
-
-    for task in graph.tasks_without_requirements():
-        reasons.append(f"{task.id} is not mapped to any requirement.")
-
-    for asm in graph.unconfirmed_high_impact_assumptions():
-        reasons.append(f"Assumption {asm.id} (high impact) is still open: {asm.statement}")
-
-    for finding in graph.open_findings("critical"):
-        reasons.append(f"Critical finding {finding.id} is still open: {finding.claim}")
-
-    return len(reasons) == 0, reasons

package/src/devcouncil/artifacts/graph.py

@@ -1,163 +0,0 @@
-"""Artifact graph: the persistent, directed graph that links requirements to evidence.
-
-This is DevCouncil's core data structure:
-  Requirement -> AcceptanceCriterion -> Task -> PlannedFile -> ChangedFile
-              -> CommandResult -> TestEvidence -> Gap
-
-The graph enables coverage queries like:
-  - Which requirements have no tasks?
-  - Which tasks produced no changed files?
-  - Which acceptance criteria have no evidence?
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Set, Tuple
-
-from devcouncil.domain.requirement import Requirement, AcceptanceCriterion
-from devcouncil.domain.task import Task
-from devcouncil.domain.assumption import Assumption
-from devcouncil.domain.evidence import CommandResult, DiffCoverageEvidence, DiffEvidence, TestEvidence
-from devcouncil.domain.gap import Gap
-from devcouncil.domain.critique import CritiqueFinding
-
-
-@dataclass
-class ArtifactGraph:
-    """Directed graph of all planning and execution artifacts."""
-
-    requirements: Dict[str, Requirement] = field(default_factory=dict)
-    tasks: Dict[str, Task] = field(default_factory=dict)
-    assumptions: Dict[str, Assumption] = field(default_factory=dict)
-    findings: Dict[str, CritiqueFinding] = field(default_factory=dict)
-    gaps: Dict[str, Gap] = field(default_factory=dict)
-    test_evidence: List[TestEvidence] = field(default_factory=list)
-    diff_evidence: List[DiffEvidence] = field(default_factory=list)
-    command_results: List[CommandResult] = field(default_factory=list)
-    diff_coverage_evidence: List[DiffCoverageEvidence] = field(default_factory=list)
-
-    # --- Mutation ---
-
-    def add_requirement(self, req: Requirement) -> None:
-        self.requirements[req.id] = req
-
-    def add_task(self, task: Task) -> None:
-        self.tasks[task.id] = task
-
-    def add_assumption(self, asm: Assumption) -> None:
-        self.assumptions[asm.id] = asm
-
-    def add_finding(self, finding: CritiqueFinding) -> None:
-        self.findings[finding.id] = finding
-
-    def add_gap(self, gap: Gap) -> None:
-        self.gaps[gap.id] = gap
-
-    def add_test_evidence(self, ev: TestEvidence) -> None:
-        self.test_evidence.append(ev)
-
-    def add_diff_evidence(self, ev: DiffEvidence) -> None:
-        self.diff_evidence.append(ev)
-
-    def add_command_result(self, cr: CommandResult) -> None:
-        self.command_results.append(cr)
-
-    def add_diff_coverage_evidence(self, ev: DiffCoverageEvidence) -> None:
-        self.diff_coverage_evidence.append(ev)
-
-    def diff_coverage_findings(self) -> List[DiffCoverageEvidence]:
-        """Measured diff-coverage runs where the changed lines were NOT fully exercised
-        — i.e. a green suite that did not actually run the new code."""
-        return [
-            ev for ev in self.diff_coverage_evidence
-            if ev.measured and ev.changed_lines and ev.covered_lines < ev.changed_lines
-        ]
-
-    # --- Coverage Queries ---
-
-    def requirements_without_tasks(self) -> List[Requirement]:
-        """Requirements that are not mapped to any task."""
-        task_req_ids: Set[str] = set()
-        for task in self.tasks.values():
-            task_req_ids.update(task.requirement_ids)
-        return [r for r in self.requirements.values() if r.id not in task_req_ids]
-
-    def tasks_without_requirements(self) -> List[Task]:
-        """Tasks that don't map back to any requirement."""
-        return [t for t in self.tasks.values() if not t.requirement_ids]
-
-    def requirements_without_acceptance_criteria(self) -> List[Requirement]:
-        """Requirements with no acceptance criteria defined."""
-        return [r for r in self.requirements.values() if not r.acceptance_criteria]
-
-    def acceptance_criteria_without_evidence(self) -> List[Tuple[str, AcceptanceCriterion]]:
-        """AC IDs that have no *passing* test evidence mapped to them.
-
-        Only ``passed`` evidence counts: a failed or not-run check is not proof, so
-        it must not remove a criterion from the unproven list (which would feed a
-        falsely-green coverage summary to ``dev status`` and the MCP surface).
-        """
-        evidenced_ac_ids: Set[str] = set()
-        for ev in self.test_evidence:
-            if getattr(ev, "status", "passed") == "passed":
-                evidenced_ac_ids.add(ev.acceptance_criterion_id)
-
-        results: List[Tuple[str, AcceptanceCriterion]] = []
-        for req in self.requirements.values():
-            for ac in req.acceptance_criteria:
-                if ac.id not in evidenced_ac_ids:
-                    results.append((req.id, ac))
-        return results
-
-    def tasks_without_changed_files(self) -> List[Task]:
-        """Tasks that have not produced any diff evidence."""
-        tasks_with_diffs: Set[str] = set()
-        for de in self.diff_evidence:
-            tasks_with_diffs.add(de.task_id)
-        return [
-            t for t in self.tasks.values()
-            if t.id not in tasks_with_diffs and t.status not in ("planned", "ready")
-        ]
-
-    def open_findings(self, min_severity: str = "low") -> List[CritiqueFinding]:
-        """Critique findings that are still open."""
-        severity_order = {"low": 0, "medium": 1, "high": 2, "critical": 3}
-        min_rank = severity_order.get(min_severity, 0)
-        return [
-            f for f in self.findings.values()
-            if f.status == "open" and severity_order.get(f.severity, 0) >= min_rank
-        ]
-
-    def blocking_gaps(self) -> List[Gap]:
-        """Gaps that are blocking progress."""
-        return [g for g in self.gaps.values() if g.blocking]
-
-    def unconfirmed_high_impact_assumptions(self) -> List[Assumption]:
-        """Assumptions with high impact that are still open."""
-        return [
-            a for a in self.assumptions.values()
-            if a.status == "open" and a.impact == "high"
-        ]
-
-    # --- Aggregate ---
-
-    def coverage_summary(self) -> Dict[str, Any]:
-        """Produce a coverage summary for reporting."""
-        return {
-            "total_requirements": len(self.requirements),
-            "requirements_without_tasks": len(self.requirements_without_tasks()),
-            "requirements_without_ac": len(self.requirements_without_acceptance_criteria()),
-            "total_tasks": len(self.tasks),
-            "tasks_without_requirements": len(self.tasks_without_requirements()),
-            "tasks_without_diffs": len(self.tasks_without_changed_files()),
-            "total_ac": sum(len(r.acceptance_criteria) for r in self.requirements.values()),
-            "ac_without_evidence": len(self.acceptance_criteria_without_evidence()),
-            "total_gaps": len(self.gaps),
-            "blocking_gaps": len(self.blocking_gaps()),
-            "diff_coverage_runs": len(self.diff_coverage_evidence),
-            "unexercised_diff_findings": len(self.diff_coverage_findings()),
-            "open_findings": len(self.open_findings()),
-            "high_critical_open_findings": len(self.open_findings("high")),
-            "unconfirmed_high_assumptions": len(self.unconfirmed_high_impact_assumptions()),
-        }

package/src/devcouncil/artifacts/migrations.py

@@ -1,20 +0,0 @@
-from typing import Any, Dict
-
-class ArtifactMigrator:
-    """Migrates artifact schemas across DevCouncil versions."""
-    
-    @staticmethod
-    def migrate_requirement(data: Dict[str, Any]) -> Dict[str, Any]:
-        """Upgrade requirement payload to current schema."""
-        if "priority" not in data:
-            data["priority"] = "medium"
-        return data
-
-    @staticmethod
-    def migrate_task(data: Dict[str, Any]) -> Dict[str, Any]:
-        """Upgrade task payload to current schema."""
-        if "forbidden_changes" not in data:
-            data["forbidden_changes"] = []
-        if "expected_tests" not in data:
-            data["expected_tests"] = []
-        return data

package/src/devcouncil/artifacts/schemas.py

@@ -1,23 +0,0 @@
-from typing import List
-from pydantic import BaseModel, Field
-
-# Common schemas that might be shared across artifacts
-class FileModification(BaseModel):
-    path: str
-    diff: str
-
-class CoverageMatrix(BaseModel):
-    """Represents a requirement to task/test mapping coverage."""
-    requirement_id: str
-    task_ids: List[str] = Field(default_factory=list)
-    test_evidence_ids: List[str] = Field(default_factory=list)
-    is_covered: bool = False
-    missing_tasks: bool = False
-    missing_tests: bool = False
-
-class ReportSchema(BaseModel):
-    project_id: str
-    tasks_completed: int
-    tasks_blocked: int
-    open_gaps: int
-    coverage_matrix: List[CoverageMatrix]

package/src/devcouncil/artifacts/serializer.py

@@ -1,21 +0,0 @@
-import json
-from typing import Any, Dict, TypeVar, Type
-from pydantic import BaseModel
-
-T = TypeVar("T", bound=BaseModel)
-
-class ArtifactSerializer:
-    """Handles serialization and deserialization of DevCouncil artifacts."""
-    
-    @staticmethod
-    def to_json(artifact: BaseModel) -> str:
-        return artifact.model_dump_json(indent=2)
-
-    @staticmethod
-    def from_json(json_str: str, model_class: Type[T]) -> T:
-        data = json.loads(json_str)
-        return model_class.model_validate(data)
-
-    @staticmethod
-    def to_dict(artifact: BaseModel) -> Dict[str, Any]:
-        return artifact.model_dump()