gdmcode 0.1.0__py3-none-any.whl

src/cost_tracker.py

@@ -0,0 +1,348 @@
+"""Cost tracker — per-turn token and USD cost accounting.
+
+Supports all three providers (Grok / Gemini / Codex) and all model tiers.
+Persists a running session total. Cheap to call — no I/O on hot path.
+
+Usage::
+
+    tracker = CostTracker(session_id="abc", provider="grok")
+    tracker.record(tier="coder", input_tokens=1200, output_tokens=450)
+    tracker.record_tool_call("web_search")
+    print(tracker.session_total_usd)  # → 0.00063
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Literal
+
+__all__ = ["CostTracker", "TurnCost", "ModelTier", "ProviderName"]
+
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Type aliases
+# ---------------------------------------------------------------------------
+
+ModelTier = Literal["scout", "coder", "thinker", "reasoner", "debate", "standard", "heavy"]
+ProviderName = Literal["grok", "gemini", "codex"]
+
+# ---------------------------------------------------------------------------
+# Price tables  (USD per 1 million tokens)
+# Updated: 2026-04 — update when providers change pricing
+# ---------------------------------------------------------------------------
+
+# fmt: off
+_GROK_PRICES: dict[str, tuple[float, float, float]] = {
+    # tier: (input, output, cached_input)
+    "scout":    (0.20,  0.50,  0.05),
+    "coder":    (0.20,  0.50,  0.05),
+    "thinker":  (2.00,  6.00,  0.20),
+    "reasoner": (2.00,  6.00,  0.20),
+    "debate":   (2.00,  6.00,  0.20),
+    "standard": (3.00, 15.00,  0.20),
+    "heavy":    (6.00, 30.00,  0.40),
+}
+
+_GEMINI_PRICES: dict[str, tuple[float, float, float]] = {
+    "scout":    (0.15,  0.60,  0.04),   # gemini-2.5-flash (free tier: 1K/day)
+    "coder":    (0.075, 0.30,  0.02),   # gemini-2.5-flash-8b
+    "thinker":  (1.25, 10.00,  0.31),   # gemini-2.5-pro ≤200K
+    "reasoner": (2.50, 10.00,  0.63),   # gemini-2.5-pro >200K
+    "debate":   (2.50, 10.00,  0.63),   # falls back to Reasoner
+    "standard": (1.25, 10.00,  0.31),
+    "heavy":    (2.50, 10.00,  0.63),
+}
+
+_CODEX_PRICES: dict[str, tuple[float, float, float]] = {
+    "scout":    (0.40,  1.60,  0.10),   # gpt-4.1-mini
+    "coder":    (2.00,  8.00,  0.50),   # gpt-4.1
+    "thinker":  (1.10,  4.40,  0.28),   # o4-mini
+    "reasoner": (2.00,  8.00,  0.50),   # o3
+    "debate":   (2.00,  8.00,  0.50),   # o3 ×4 parallel
+    "standard": (2.00,  8.00,  0.50),
+    "heavy":    (10.00, 40.00, 2.50),   # o3-pro
+}
+
+# Tool call costs (per 1,000 calls)
+_TOOL_CALL_COSTS_PER_K: dict[str, float] = {
+    "web_search":              5.00,
+    "x_search":                5.00,
+    "document_query":          2.50,
+    "file_attachment_search": 10.00,
+}
+# fmt: on
+
+_PROVIDER_PRICES: dict[str, dict[str, tuple[float, float, float]]] = {
+    "grok":   _GROK_PRICES,
+    "gemini": _GEMINI_PRICES,
+    "codex":  _CODEX_PRICES,
+}
+
+
+# ---------------------------------------------------------------------------
+# Data classes
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TurnCost:
+    """Cost breakdown for one agent turn."""
+
+    provider: ProviderName
+    tier: ModelTier
+    input_tokens: int
+    output_tokens: int
+    cached_tokens: int = 0
+    tool_calls: dict[str, int] = field(default_factory=dict)  # name → count
+    usd: float = 0.0
+
+    def __post_init__(self) -> None:
+        if self.usd == 0.0:
+            self.usd = _compute_usd(
+                provider=self.provider,
+                tier=self.tier,
+                input_tokens=self.input_tokens,
+                output_tokens=self.output_tokens,
+                cached_tokens=self.cached_tokens,
+                tool_calls=self.tool_calls,
+            )
+
+
+# ---------------------------------------------------------------------------
+# Core class
+# ---------------------------------------------------------------------------
+
+class CostTracker:
+    """Tracks token usage and USD cost across an agent session.
+
+    Lightweight — no I/O on the hot path. Call ``flush_to_db()`` at
+    session end to persist the total.
+    """
+
+    def __init__(self, session_id: str, provider: ProviderName) -> None:
+        self._session_id = session_id
+        self._provider = provider
+        self._turns: list[TurnCost] = []
+        self._session_total_usd: float = 0.0
+        self._total_input: int = 0
+        self._total_output: int = 0
+        self._total_cached: int = 0
+        self._pending_tool_calls: dict[str, int] = {}
+        self._alerted_50: bool = False
+        self._alerted_80: bool = False
+
+    # ------------------------------------------------------------------
+    # Recording
+    # ------------------------------------------------------------------
+
+    def record(
+        self,
+        tier: ModelTier,
+        input_tokens: int,
+        output_tokens: int,
+        cached_tokens: int = 0,
+        tool_calls: dict[str, int] | None = None,
+    ) -> TurnCost:
+        """Record one turn's token usage and return its TurnCost."""
+        turn = TurnCost(
+            provider=self._provider,
+            tier=tier,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cached_tokens=cached_tokens,
+            tool_calls=tool_calls or {},
+        )
+        self._turns.append(turn)
+        self._session_total_usd += turn.usd
+        self._total_input += input_tokens
+        self._total_output += output_tokens
+        self._total_cached += cached_tokens
+        log.debug(
+            "turn cost: provider=%s tier=%s in=%d out=%d cached=%d → $%.5f",
+            self._provider, tier, input_tokens, output_tokens, cached_tokens, turn.usd,
+        )
+        return turn
+
+    # ------------------------------------------------------------------
+    # Queries
+    # ------------------------------------------------------------------
+
+    @property
+    def session_total_usd(self) -> float:
+        """Running session cost in USD."""
+        return self._session_total_usd
+
+    @property
+    def turn_count(self) -> int:
+        return len(self._turns)
+
+    def summary(self) -> dict[str, object]:
+        """Return a summary dict suitable for display."""
+        return {
+            "session_id": self._session_id,
+            "provider": self._provider,
+            "turns": self.turn_count,
+            "input_tokens": self._total_input,
+            "output_tokens": self._total_output,
+            "cached_tokens": self._total_cached,
+            "total_usd": round(self._session_total_usd, 6),
+        }
+
+    def exceeds(self, limit_usd: float) -> bool:
+        """True if session cost has exceeded *limit_usd*."""
+        return self._session_total_usd >= limit_usd
+
+    # ------------------------------------------------------------------
+    # Tool call tracking
+    # ------------------------------------------------------------------
+
+    def record_tool_call(self, tool_name: str, count: int = 1) -> None:
+        """Accumulate a tool call for inclusion in the next flush_event_to_db call."""
+        self._pending_tool_calls[tool_name] = (
+            self._pending_tool_calls.get(tool_name, 0) + count
+        )
+
+    # ------------------------------------------------------------------
+    # Budget enforcement
+    # ------------------------------------------------------------------
+
+    def check_budget(self, db: object) -> None:  # type: ignore[type-arg]
+        """Raise BudgetExceededError if any hard-stop budget limit is breached.
+
+        Emits WARNING logs at 50 % and 80 % thresholds before raising.
+        No-ops if db has no applicable budget_limits rows.
+        """
+        from src.exceptions import BudgetExceededError
+        limit = self._effective_limit(db)
+        if limit is None:
+            return
+        pct = self._session_total_usd / limit if limit > 0 else 0.0
+        if pct >= 0.80 and not self._alerted_80:
+            self._alerted_80 = True
+            log.warning(
+                "⚠ Budget 80%% alert: spent $%.4f of $%.2f limit",
+                self._session_total_usd, limit,
+            )
+        elif pct >= 0.50 and not self._alerted_50:
+            self._alerted_50 = True
+            log.warning(
+                "⚠ Budget 50%% alert: spent $%.4f of $%.2f limit",
+                self._session_total_usd, limit,
+            )
+        if self._session_total_usd >= limit:
+            raise BudgetExceededError(
+                f"Budget limit ${limit:.2f} exceeded (spent ${self._session_total_usd:.2f})"
+            )
+
+    def _effective_limit(self, db: object) -> float | None:  # type: ignore[type-arg]
+        """Return the most restrictive session-scoped hard-stop limit, or None."""
+        try:
+            row = db.execute_one(  # type: ignore[union-attr]
+                """
+                SELECT limit_usd FROM budget_limits
+                WHERE scope_type = 'session' AND scope_id = ?
+                  AND period = 'session' AND hard_stop = 1
+                ORDER BY limit_usd ASC LIMIT 1
+                """,
+                (self._session_id,),
+            )
+            return float(row["limit_usd"]) if row is not None else None
+        except Exception as exc:  # noqa: BLE001
+            log.debug("_effective_limit query failed: %s", exc)
+            return None
+
+    # ------------------------------------------------------------------
+    # Persistence
+    # ------------------------------------------------------------------
+
+    def flush_event_to_db(
+        self,
+        db: object,  # type: ignore[type-arg]
+        tier: str,
+        input_tokens: int,
+        output_tokens: int,
+        cached_tokens: int,
+        cost_usd: float,
+        event_id: str | None = None,
+    ) -> None:
+        """Persist one turn's cost to the cost_events append-only ledger.
+
+        Clears ``_pending_tool_calls`` after writing. Also updates the running
+        session total on the sessions table.
+        """
+        import json
+        try:
+            db.cost_event_insert(  # type: ignore[union-attr]
+                session_id=self._session_id,
+                provider=self._provider,
+                tier=tier,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                cached_tokens=cached_tokens,
+                cost_usd=cost_usd,
+                tool_calls_json=json.dumps(self._pending_tool_calls),
+                event_id=event_id,
+            )
+            self._pending_tool_calls.clear()
+            self.flush_to_db(db)
+        except Exception as exc:  # noqa: BLE001
+            log.warning("flush_event_to_db failed: %s", exc)
+
+    @staticmethod
+    def monthly_spend(db: object, project_id: str | None = None) -> float:  # type: ignore[type-arg]
+        """Return the rolling 30-day total spend from the cost_events ledger."""
+        try:
+            return db.cost_monthly_spend(project_id)  # type: ignore[union-attr]
+        except Exception as exc:  # noqa: BLE001
+            log.warning("monthly_spend failed: %s", exc)
+            return 0.0
+
+    def flush_to_db(self, db: object) -> None:  # type: ignore[type-arg]
+        """Persist session cost total to the database (idempotent SET, not increment).
+
+        Safe to call multiple times — always writes the current absolute total.
+
+        Args:
+            db: GdmDatabase instance (imported lazily to avoid circular dep).
+        """
+        try:
+            db.execute(  # type: ignore[union-attr]
+                "UPDATE sessions SET cost_usd = ? WHERE session_id = ?",
+                (self._session_total_usd, self._session_id),
+            )
+        except Exception as exc:  # noqa: BLE001
+            log.warning("flush_to_db failed: %s", exc)
+
+
+# ---------------------------------------------------------------------------
+# Private helpers
+# ---------------------------------------------------------------------------
+
+def _compute_usd(
+    provider: str,
+    tier: str,
+    input_tokens: int,
+    output_tokens: int,
+    cached_tokens: int,
+    tool_calls: dict[str, int],
+) -> float:
+    """Compute USD cost for one turn."""
+    prices = _PROVIDER_PRICES.get(provider, _GROK_PRICES)
+    tier_prices = prices.get(tier, prices.get("coder", (2.00, 6.00, 0.20)))
+    in_price, out_price, cached_price = tier_prices
+
+    # Non-cached input tokens = total input − cached
+    real_input = max(0, input_tokens - cached_tokens)
+
+    usd = (
+        real_input * in_price / 1_000_000
+        + cached_tokens * cached_price / 1_000_000
+        + output_tokens * out_price / 1_000_000
+    )
+
+    # Add tool call costs
+    for tool_name, count in tool_calls.items():
+        cost_per_k = _TOOL_CALL_COSTS_PER_K.get(tool_name, 0.0)
+        usd += cost_per_k * count / 1_000
+
+    return usd

src/db/__init__.py

@@ -0,0 +1,4 @@
+"""Database package — migration registry and connection helpers."""
+from src.db.migrations import MigrationRegistry, Migration, registry
+
+__all__ = ["MigrationRegistry", "Migration", "registry"]

src/db/migrations.py

@@ -0,0 +1,337 @@
+"""Central migration registry for GdmDatabase schema changes.
+
+All schema migrations must register here. No module may hardcode an
+absolute schema version number outside this file.
+
+Usage::
+
+    from src.db.migrations import registry, Migration
+
+    registry.register(Migration(
+        version=7,
+        description="Add my_table",
+        upgrade=lambda conn: conn.execute("ALTER TABLE ..."),
+    ))
+
+The GdmDatabase calls registry.apply_pending(conn) on every open.
+"""
+from __future__ import annotations
+
+import logging
+import sqlite3
+from dataclasses import dataclass, field
+from typing import Callable
+
+__all__ = ["Migration", "MigrationRegistry", "registry"]
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Migration:
+    """A single schema migration step."""
+
+    version: int
+    description: str
+    upgrade: Callable[[sqlite3.Connection], None]
+    downgrade: Callable[[sqlite3.Connection], None] | None = None
+
+
+class MigrationRegistry:
+    """Central registry for ordered, idempotent schema migrations.
+
+    Migrations are applied in ascending version order. Each migration is
+    applied exactly once and tracked in the schema_version table.
+    """
+
+    def __init__(self) -> None:
+        self._migrations: dict[int, Migration] = {}
+
+    def register(self, migration: Migration) -> None:
+        """Register a migration. Raises ValueError on duplicate version."""
+        if migration.version in self._migrations:
+            raise ValueError(
+                f"Duplicate migration version {migration.version}: "
+                f"'{self._migrations[migration.version].description}' "
+                f"vs '{migration.description}'"
+            )
+        self._migrations[migration.version] = migration
+
+    def current_version(self, conn: sqlite3.Connection) -> int:
+        """Return the highest applied migration version, or 0 if none."""
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)"
+        )
+        row = conn.execute("SELECT MAX(version) FROM schema_version").fetchone()
+        return int(row[0]) if row and row[0] is not None else 0
+
+    def apply_pending(self, conn: sqlite3.Connection) -> None:
+        """Apply all registered migrations not yet applied. Idempotent."""
+        current = self.current_version(conn)
+        pending = sorted(v for v in self._migrations if v > current)
+        for version in pending:
+            migration = self._migrations[version]
+            log.info("Applying migration v%d: %s", version, migration.description)
+            try:
+                migration.upgrade(conn)
+                conn.execute(
+                    "INSERT OR IGNORE INTO schema_version (version) VALUES (?)",
+                    (version,),
+                )
+                conn.commit()
+                log.info("Migration v%d applied successfully", version)
+            except Exception as exc:
+                log.error("Migration v%d failed: %s", version, exc)
+                try:
+                    conn.execute("ROLLBACK")
+                except Exception:
+                    pass
+                raise
+
+    def versions(self) -> list[int]:
+        """Return sorted list of all registered migration versions."""
+        return sorted(self._migrations)
+
+    def latest_version(self) -> int:
+        """Return the highest registered migration version, or 0 if empty."""
+        return max(self._migrations, default=0)
+
+
+# ---------------------------------------------------------------------------
+# Module-level singleton registry
+# All modules register their migrations here at import time.
+# ---------------------------------------------------------------------------
+registry = MigrationRegistry()
+
+# ---------------------------------------------------------------------------
+# Baseline migrations (extracted from the existing GdmDatabase ad-hoc system)
+# These represent the schema as it exists at v6.
+# ---------------------------------------------------------------------------
+
+
+def _noop(conn: sqlite3.Connection) -> None:
+    """No-op upgrade for baseline migrations where DDL is handled by CREATE IF NOT EXISTS."""
+    pass
+
+
+# v1: Initial schema (handled by DDL in GdmDatabase)
+registry.register(Migration(version=1, description="Initial schema (projects, sessions, memory, file_cache, conventions, code_index, errors, permissions, checkpoints, tasks, audit_log, btw_queue, spinner_state)", upgrade=_noop))
+
+# v2: Add memory.tool_calls_json
+def _upgrade_v2(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("ALTER TABLE memory ADD COLUMN tool_calls_json TEXT")
+    except Exception:
+        pass  # Already exists on fresh DBs
+
+registry.register(Migration(version=2, description="Add memory.tool_calls_json", upgrade=_upgrade_v2))
+
+# v3: Add session_events, tool_call_log, patch_log tables (DDL handles this)
+registry.register(Migration(version=3, description="Add session_events, tool_call_log, patch_log tables", upgrade=_noop))
+
+# v4: Add cost_events, budget_limits, budget_usage tables (DDL handles this)
+registry.register(Migration(version=4, description="Add cost_events, budget_limits, budget_usage, daemon_jobs tables", upgrade=_noop))
+
+# v5: Add session_events.annotation column
+def _upgrade_v5(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("ALTER TABLE session_events ADD COLUMN annotation TEXT")
+    except Exception:
+        pass
+
+registry.register(Migration(version=5, description="Add session_events.annotation column", upgrade=_upgrade_v5))
+
+# v6: Add memory.turn_index (with backfill), unique index, sessions.status column
+def _upgrade_v6(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("ALTER TABLE memory ADD COLUMN turn_index INTEGER NOT NULL DEFAULT 0")
+    except Exception:
+        pass
+    try:
+        conn.execute(
+            "UPDATE memory SET turn_index = ("
+            "  SELECT COUNT(*) FROM memory m2"
+            "  WHERE m2.session_id = memory.session_id AND m2.id < memory.id"
+            ")"
+        )
+    except Exception:
+        pass
+    try:
+        conn.execute(
+            "CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_session_turn "
+            "ON memory(session_id, turn_index)"
+        )
+    except Exception:
+        pass
+    try:
+        conn.execute(
+            "ALTER TABLE sessions ADD COLUMN status TEXT NOT NULL DEFAULT 'active'"
+        )
+    except Exception:
+        pass
+
+registry.register(Migration(version=6, description="Add memory.turn_index, UNIQUE index, sessions.status", upgrade=_upgrade_v6))
+
+
+# v7: Add artifacts, artifact_versions, artifact_links, artifact_fts tables
+def _upgrade_v7(conn: sqlite3.Connection) -> None:
+    conn.executescript("""
+    CREATE TABLE IF NOT EXISTS artifacts (
+        artifact_id  TEXT PRIMARY KEY,
+        name         TEXT NOT NULL,
+        type         TEXT NOT NULL CHECK(type IN (
+                         'diagram','report','plan','coverage','diff','custom'
+                     )),
+        description  TEXT,
+        session_id   TEXT REFERENCES sessions(session_id),
+        created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        visibility   TEXT NOT NULL DEFAULT 'private'
+                     CHECK(visibility IN ('private','project','public')),
+        UNIQUE(name)
+    );
+    CREATE INDEX IF NOT EXISTS idx_artifacts_session ON artifacts(session_id);
+    CREATE INDEX IF NOT EXISTS idx_artifacts_type    ON artifacts(type);
+
+    CREATE TABLE IF NOT EXISTS artifact_versions (
+        version_id   TEXT PRIMARY KEY,
+        artifact_id  TEXT NOT NULL REFERENCES artifacts(artifact_id) ON DELETE CASCADE,
+        version_num  INTEGER NOT NULL,
+        content      TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        byte_size    INTEGER NOT NULL DEFAULT 0,
+        event_id     TEXT REFERENCES session_events(event_id),
+        created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(artifact_id, version_num)
+    );
+    CREATE INDEX IF NOT EXISTS idx_av_artifact ON artifact_versions(artifact_id, version_num DESC);
+
+    CREATE TABLE IF NOT EXISTS artifact_links (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        artifact_id  TEXT NOT NULL REFERENCES artifacts(artifact_id) ON DELETE CASCADE,
+        link_type    TEXT NOT NULL CHECK(link_type IN (
+                         'session','turn','file','commit','pr','evidence_node'
+                     )),
+        ref_value    TEXT NOT NULL,
+        created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_artifact_links ON artifact_links(artifact_id, link_type);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS artifact_fts USING fts5(
+        name, description, content
+    );
+
+    CREATE TRIGGER IF NOT EXISTS artifact_fts_insert
+        AFTER INSERT ON artifact_versions BEGIN
+        INSERT INTO artifact_fts(rowid, name, description, content)
+        SELECT new.rowid,
+               (SELECT name        FROM artifacts WHERE artifact_id = new.artifact_id),
+               (SELECT description FROM artifacts WHERE artifact_id = new.artifact_id),
+               new.content;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS artifact_fts_delete
+        AFTER DELETE ON artifact_versions BEGIN
+        DELETE FROM artifact_fts WHERE rowid = old.rowid;
+    END;
+    """)
+
+
+registry.register(Migration(version=7, description="Add artifact tables (artifacts, artifact_versions, artifact_links, artifact_fts)", upgrade=_upgrade_v7))
+
+
+# v8: Add checkpoints.turn_id column for per-turn rollback journal
+def _upgrade_v8(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("ALTER TABLE checkpoints ADD COLUMN turn_id TEXT")
+    except Exception:
+        pass  # Already exists on fresh DBs
+
+
+registry.register(Migration(version=8, description="Add checkpoints.turn_id for per-turn rollback journal", upgrade=_upgrade_v8))
+
+
+
+# v9: Add edit_nodes, evidence_nodes, graph_edges for VerificationGraph
+def _upgrade_v9(conn):
+    conn.executescript("""
+    CREATE TABLE IF NOT EXISTS edit_nodes (
+        node_id     TEXT PRIMARY KEY,
+        session_id  TEXT NOT NULL,
+        turn_index  INTEGER NOT NULL,
+        file_path   TEXT NOT NULL,
+        patch_ref   TEXT,
+        created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(session_id, turn_index, file_path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_edit_nodes_session ON edit_nodes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_edit_nodes_file    ON edit_nodes(file_path);
+    CREATE TABLE IF NOT EXISTS evidence_nodes (
+        evidence_id TEXT PRIMARY KEY,
+        node_id     TEXT NOT NULL REFERENCES edit_nodes(node_id) ON DELETE CASCADE,
+        kind        TEXT NOT NULL CHECK(kind IN (
+                        'TEST','LINT','TYPE_CHECK','REVIEW','RUN','SECURITY','PERF','COVERAGE'
+                    )),
+        verdict     TEXT NOT NULL CHECK(verdict IN (
+                        'PASS','FAIL','WARNING','PENDING','SKIPPED'
+                    )),
+        detail_json TEXT NOT NULL DEFAULT '{}',
+        tool        TEXT,
+        duration_ms INTEGER,
+        created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_evidence_node ON evidence_nodes(node_id, kind);
+    CREATE TABLE IF NOT EXISTS graph_edges (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        from_node_id TEXT NOT NULL REFERENCES edit_nodes(node_id) ON DELETE CASCADE,
+        to_node_id   TEXT NOT NULL REFERENCES edit_nodes(node_id) ON DELETE CASCADE,
+        UNIQUE(from_node_id, to_node_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_from ON graph_edges(from_node_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_to   ON graph_edges(to_node_id);
+    """)
+
+registry.register(Migration(
+    version=9,
+    description="Add edit_nodes, evidence_nodes, graph_edges for VerificationGraph",
+    upgrade=_upgrade_v9,
+))
+
+
+# v10: Add mtime column to code_index for incremental re-indexing
+def _upgrade_v10(conn: sqlite3.Connection) -> None:
+    try:
+        conn.execute("ALTER TABLE code_index ADD COLUMN mtime REAL DEFAULT 0")
+    except Exception:
+        pass  # Already exists on fresh DBs
+
+
+registry.register(Migration(
+    version=10,
+    description="Add code_index.mtime for incremental re-indexing",
+    upgrade=_upgrade_v10,
+))
+
+
+# v11: Add confidence_outcomes table for ide-003 calibration persistence
+def _upgrade_v11(conn: sqlite3.Connection) -> None:
+    conn.executescript("""
+    CREATE TABLE IF NOT EXISTS confidence_outcomes (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id   TEXT NOT NULL,
+        hunk_hash    TEXT NOT NULL,
+        score        INTEGER NOT NULL,
+        reasons_json TEXT NOT NULL DEFAULT '[]',
+        verified     INTEGER NOT NULL DEFAULT 0,
+        created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_co_session  ON confidence_outcomes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_co_hunk     ON confidence_outcomes(hunk_hash);
+    """)
+
+
+registry.register(Migration(
+    version=11,
+    description="Add confidence_outcomes table for calibration persistence",
+    upgrade=_upgrade_v11,
+))

src/enterprise/__init__.py

@@ -0,0 +1,3 @@
+from src.enterprise.usage_analytics import UsageAnalytics, UsageEvent, SessionSummary, TeamRollup
+
+__all__ = ["UsageAnalytics", "UsageEvent", "SessionSummary", "TeamRollup"]