specsmith 0.17.1.dev667__tar.gz → 0.17.1.dev669__tar.gz

{specsmith-0.17.1.dev667/src/specsmith.egg-info → specsmith-0.17.1.dev669}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.17.1.dev667
+Version: 0.17.1.dev669
 Summary: AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider.
 Author: Layer1Labs Silicon, Inc.
 License-Expression: MIT

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev669}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.17.1.dev667"
+version = "0.17.1.dev669"
 description = "AEE governance toolkit for AI-assisted development — session preflight gates, multi-agent dispatch, requirements↔test traceability, ESDB persistence, MCP server, and skills for Warp, Cursor, Claude Code, Copilot, Windsurf, and Aider."
 readme = "README.md"
 license = "MIT"

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev669}/src/specsmith/agent/context_seed.py

@@ -27,7 +27,9 @@ left off (extended to cover full epistemic continuity).
 from __future__ import annotations
 
 import json
+import uuid
 from collections.abc import Sequence
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -62,6 +64,10 @@ def build_context_seed(
     records (failed approaches, stale decisions, low-confidence hypotheses) are
     excluded from the context window.
 
+    REQ-407: ESDB-first ledger snippet (falls back to LEDGER.md).
+    REQ-415: auto-tune seed parameters from EFF-CURRENT.
+    REQ-416: write context_usage record per build_context_seed() call.
+
     Args:
         project_dir: Project root containing ``.specsmith/``.
         char_budget: Maximum total characters across all seed turns.
@@ -75,9 +81,21 @@ def build_context_seed(
         Empty list if no prior context is available.
     """
     root = Path(project_dir).resolve()
+    session_id = uuid.uuid4().hex[:16].upper()
     turns: list[dict[str, Any]] = []
     used = 0
 
+    # Auto-tune parameters from EFF-CURRENT (REQ-415)
+    eff = _load_efficiency_params(root)
+    if eff.get("degraded"):
+        # Reduce budget when context is degraded to force tighter seeds
+        char_budget = int(char_budget * 0.75)
+    if eff.get("context_char_efficiency") is not None:
+        # Scale max_ledger based on fill efficiency: high fill → fewer ledger lines
+        fill_eff = float(eff["context_char_efficiency"])
+        if fill_eff > 0.9:
+            max_ledger = max(10, max_ledger // 2)
+
     # ── 1. Session state snapshot ─────────────────────────────────────
     session_summary = _load_session_summary(root)
     if session_summary:
@@ -95,7 +113,7 @@ def build_context_seed(
         turns.append(t)
         used += len(c)
 
-    # ── 3. Recent LEDGER entries ─────────────────────────────────
+    # ── 3. Recent LEDGER entries — ESDB-first (REQ-407) ─────────────────
     ledger_block = _load_ledger_snippet(root, max_lines=max_ledger)
     if ledger_block and used + len(ledger_block) <= char_budget:
         turns.append(
@@ -106,7 +124,22 @@ def build_context_seed(
         )
         used += len(ledger_block)
 
-    # ── 4. ESDB records — relevance-based by kind (REQ-399) ──────────────
+    # ── 4. Efficiency degradation warning ────────────────────────────────
+    if eff.get("degraded"):
+        eq_score = eff.get("epistemic_quality_score", 0.0)
+        tpc = eff.get("tokens_per_correct_answer")
+        baseline = eff.get("baseline_tokens_per_pass")
+        warn_parts = ["[EFFICIENCY WARNING: context degraded"]
+        if tpc is not None and baseline is not None:
+            warn_parts.append(f"tokens/pass={tpc:.0f} vs baseline={baseline:.0f}")
+        if eq_score:
+            warn_parts.append(f"epistemic_quality={eq_score:.2f}")
+        warn_parts.append("— consider specsmith esdb sweep]")
+        warn_content = " ".join(warn_parts)
+        turns.append({"role": "system", "content": warn_content})
+        used += len(warn_content)
+
+    # ── 5. ESDB records — relevance-based by kind (REQ-399) ──────────────
     esdb_block = _load_esdb_by_kind(
         root,
         max_preflight=max_preflight,
@@ -123,6 +156,17 @@ def build_context_seed(
                 ),
             }
         )
+        used += len(esdb_block)
+
+    # ── 6. Write context_usage record (REQ-416) ──────────────────────────
+    _write_context_usage(
+        root,
+        session_id=session_id,
+        seed_chars=used,
+        seed_fill_pct=round(used / max(1, char_budget) * 100.0, 1),
+        turns_count=len(turns),
+        degraded=bool(eff.get("degraded")),
+    )
 
     return turns
 
@@ -192,7 +236,34 @@ def _load_conversation_history(
 
 
 def _load_ledger_snippet(root: Path, *, max_lines: int) -> str:
-    """Return the last ``max_lines`` of LEDGER.md, newest-first."""
+    """Return the last ``max_lines`` of ledger entries — ESDB-first (REQ-407).
+
+    Query order:
+      1. ESDB ``ledger_event`` records (sorted by timestamp desc).
+      2. Fall back to LEDGER.md file if ESDB has no ledger_event records.
+    """
+    # 1. Try ESDB first
+    try:
+        from specsmith.esdb import SqliteStore
+
+        sqlite_path = root / ".specsmith" / "esdb.sqlite3"
+        if sqlite_path.exists():
+            with SqliteStore(root) as store:
+                records = store.query(kind="ledger_event", status="active")
+            if records:
+                # Sort newest first by timestamp in data, then take last max_lines
+                def _ts(r: Any) -> str:
+                    return str(r.data.get("timestamp") or "")
+
+                sorted_recs = sorted(records, key=_ts, reverse=True)[:max_lines]
+                lines_out = [
+                    f"{r.data.get('timestamp', '')[:16]} — {r.label[:120]}" for r in sorted_recs
+                ]
+                return "\n".join(lines_out)
+    except Exception:  # noqa: BLE001
+        pass
+
+    # 2. Fall back to LEDGER.md file
     try:
         candidates = [root / "LEDGER.md", root / "docs" / "LEDGER.md"]
         for path in candidates:
@@ -310,4 +381,64 @@ def _load_esdb_by_kind(
     return "\n".join(lines)
 
 
+def _load_efficiency_params(root: Path) -> dict[str, Any]:
+    """Load EFF-CURRENT from ESDB and return its data dict (REQ-415).
+
+    Returns an empty dict on any error (best-effort).
+    """
+    try:
+        from specsmith.esdb import SqliteStore
+
+        sqlite_path = root / ".specsmith" / "esdb.sqlite3"
+        if not sqlite_path.exists():
+            return {}
+        with SqliteStore(root) as store:
+            rec = store.get("EFF-CURRENT")
+        if rec is None:
+            return {}
+        data = dict(rec.data)
+        # Flatten epistemic_quality score for convenience
+        eq = data.get("epistemic_quality")
+        if isinstance(eq, dict):
+            data["epistemic_quality_score"] = eq.get("score", 0.0)
+        return data
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+def _write_context_usage(
+    root: Path,
+    *,
+    session_id: str,
+    seed_chars: int,
+    seed_fill_pct: float,
+    turns_count: int,
+    degraded: bool,
+) -> None:
+    """Write a context_usage record to ESDB (REQ-416, best-effort)."""
+    try:
+        from specsmith.esdb import SqliteRecord, open_default_store
+
+        rec_id = f"CTX-{session_id}"
+        record = SqliteRecord(
+            id=rec_id,
+            kind="context_usage",
+            status="active",
+            label=f"seed session={session_id} fill={seed_fill_pct:.1f}%",
+            confidence=1.0,
+            data={
+                "session_id": session_id,
+                "seed_chars": seed_chars,
+                "seed_fill_pct": seed_fill_pct,
+                "turns_count": turns_count,
+                "degraded_at_seed": degraded,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            },
+        )
+        with open_default_store(root, warn=False) as store:
+            store.upsert(record)
+    except Exception:  # noqa: BLE001
+        pass
+
+
 __all__ = ["build_context_seed"]

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev669}/src/specsmith/agent/runner.py

@@ -604,6 +604,23 @@ class AgentRunner:
         )
         self._state.elapsed_minutes = round((time.time() - self._started_at) / 60.0, 2)
 
+        # Write token_metric to ESDB (REQ-410) — best-effort, never blocks.
+        if tokens_in or tokens_out:
+            try:
+                from specsmith.esdb_writer import write_token_metric
+
+                write_token_metric(
+                    self.project_dir,
+                    input_tokens=tokens_in,
+                    output_tokens=tokens_out,
+                    cost_usd=cost_usd,
+                    model=str(getattr(result, "provider", "") if result else ""),
+                    command_source=activity or "chat",
+                    work_item_id=str(getattr(self._state, "active_work_item_id", "") or ""),
+                )
+            except Exception:  # noqa: BLE001
+                pass
+
         if result is not None:
             self._history.append({"role": "user", "text": utterance})
             self._history.append({"role": "agent", "text": result.summary})

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev669}/src/specsmith/cli.py

@@ -2698,6 +2698,105 @@ def ledger_stats(project_dir: str) -> None:
             console.print(f"  {name}: {count} entries")
 
 
+@ledger.command(name="export")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option(
+    "--since",
+    default="",
+    help="Filter to entries since date prefix, e.g. '2026-06-01'.",
+)
+@click.option(
+    "--format",
+    "fmt",
+    default="text",
+    type=click.Choice(["text", "json"]),
+    help="Output format (default: text).",
+)
+@click.option("--json", "as_json", is_flag=True, default=False, help="Shorthand for --format json.")
+@click.option(
+    "--source",
+    default="esdb",
+    type=click.Choice(["esdb", "file", "both"]),
+    help="Read from ESDB ledger_event records, LEDGER.md file, or both (default: esdb).",
+)
+def ledger_export(
+    project_dir: str,
+    since: str,
+    fmt: str,
+    as_json: bool,
+    source: str,
+) -> None:
+    """Export ledger entries from ESDB or LEDGER.md.
+
+    ESDB source (default) queries ledger_event records inserted by recent
+    specsmith add-entry calls, which is faster than parsing LEDGER.md.
+
+    REQ-409: specsmith ledger export command.
+    """
+    import json as _json
+
+    if as_json:
+        fmt = "json"
+
+    root = Path(project_dir).resolve()
+    entries: list[dict[str, Any]] = []
+
+    if source in ("esdb", "both"):
+        try:
+            from specsmith.esdb import SqliteStore
+
+            sqlite_path = root / ".specsmith" / "esdb.sqlite3"
+            if sqlite_path.exists():
+                with SqliteStore(root) as store:
+                    records = store.query(kind="ledger_event", status="active")
+                for r in records:
+                    ts = str(r.data.get("timestamp") or "")
+                    if since and ts[: len(since)] < since:
+                        continue
+                    entries.append(
+                        {
+                            "id": r.id,
+                            "timestamp": ts,
+                            "description": str(r.data.get("description") or r.label),
+                            "entry_type": str(r.data.get("entry_type") or ""),
+                            "author": str(r.data.get("author") or ""),
+                            "reqs": str(r.data.get("reqs") or ""),
+                            "status": str(r.data.get("status") or ""),
+                            "source": "esdb",
+                        }
+                    )
+        except Exception as exc:  # noqa: BLE001
+            console.print(f"[yellow]ESDB read failed: {exc}[/yellow]")
+
+    if source in ("file", "both"):
+        try:
+            from specsmith.ledger import list_entries
+
+            file_entries = list_entries(root, since=since)
+            for e in file_entries:
+                entries.append({**e, "source": "LEDGER.md"})
+        except Exception as exc:  # noqa: BLE001
+            console.print(f"[yellow]LEDGER.md read failed: {exc}[/yellow]")
+
+    if not entries:
+        console.print("[yellow]No ledger entries found.[/yellow]")
+        return
+
+    # Sort by timestamp
+    entries.sort(key=lambda e: str(e.get("timestamp") or ""))
+
+    if fmt == "json":
+        click.echo(_json.dumps(entries, indent=2, ensure_ascii=False))
+    else:
+        for e in entries:
+            ts = str(e.get("timestamp") or "")[:16]
+            desc = str(e.get("description") or e.get("heading") or "")
+            author = str(e.get("author") or "")
+            suffix = f"  [dim]({author})[/dim]" if author else ""
+            console.print(f"  [dim]{ts}[/dim]  {desc}{suffix}")
+        console.print(f"\n  [bold]{len(entries)} entry(ies)[/bold]")
+
+
 main.add_command(ledger)
 
 
@@ -3348,6 +3447,120 @@ def save_cmd(project_dir: str, message: str, no_push: bool, force: bool, as_json
         raise SystemExit(1)
 
 
+@main.command(name="inspect")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option("--json", "as_json", is_flag=True, default=False)
+def inspect_cmd(project_dir: str, as_json: bool) -> None:
+    """Inspect project state: governance anchor, active WIs, efficiency, and context quality.
+
+    Designed to be called at the start of every session after checkpoint.
+    Outputs a bordered block with project state suitable for agent context injection.
+
+    REQ-409: specsmith inspect command.
+    """
+    import json as _json
+    from datetime import datetime, timezone
+
+    root = Path(project_dir).resolve()
+    lines: list[str] = []
+    data: dict[str, Any] = {}
+
+    # Governance anchor
+    try:
+        from specsmith.auditor import run_audit
+
+        audit_report = run_audit(root)
+        data["audit_healthy"] = audit_report.healthy
+        data["audit_failed"] = audit_report.failed
+        gov_status = "healthy" if audit_report.healthy else f"ISSUES ({audit_report.failed})"
+        lines.append(f"  Governance : {gov_status} ")
+    except Exception:  # noqa: BLE001
+        data["audit_healthy"] = None
+        lines.append("  Governance : unknown (audit failed)")
+
+    # Active work items
+    try:
+        from specsmith.wi_store import WorkItemStore
+
+        wi_store = WorkItemStore(root)
+        active_wis = [wi for wi in wi_store.list_all() if wi.status in ("open", "implemented")]
+        data["active_work_items"] = [w.id for w in active_wis]
+        if active_wis:
+            for wi in active_wis[:5]:
+                lines.append(f"  WI         : [{wi.id}] {str(wi.intent or '')[:60]} ({wi.status})")
+        else:
+            lines.append("  WI         : no active work items")
+    except Exception:  # noqa: BLE001
+        data["active_work_items"] = []
+        lines.append("  WI         : (unavailable)")
+
+    # EFF-CURRENT
+    try:
+        from specsmith.esdb import SqliteStore
+
+        sqlite_path = root / ".specsmith" / "esdb.sqlite3"
+        eff_data: dict[str, Any] = {}
+        if sqlite_path.exists():
+            with SqliteStore(root) as store:
+                eff_rec = store.get("EFF-CURRENT")
+            if eff_rec:
+                eff_data = dict(eff_rec.data)
+
+        if eff_data:
+            tpc = eff_data.get("tokens_per_correct_answer")
+            degraded = eff_data.get("degraded", False)
+            ctx_eff = eff_data.get("context_char_efficiency")
+            eq = eff_data.get("epistemic_quality") or {}
+            eq_score = float(eq.get("score", 0.0)) if isinstance(eq, dict) else 0.0
+            data["efficiency"] = eff_data
+            tok_str = f"{tpc:.0f}" if tpc else "n/a"
+            deg_str = "  ⚠ DEGRADED" if degraded else ""
+            lines.append(
+                f"  Efficiency : tokens/pass={tok_str}  ctx_fill={ctx_eff or 'n/a'}{deg_str}"
+            )
+            lines.append(f"  Epistemic  : score={eq_score:.2f} ({_band(eq_score)})")
+            # 5-dim breakdown
+            for dim, key in [
+                ("confidence", "confidence_density"),
+                ("recency", "recency_score"),
+                ("coherence", "coherence_score"),
+                ("closure", "closure_score"),
+                ("non-contr", "non_contradiction_score"),
+            ]:
+                val = eq.get(key, 0.0) if isinstance(eq, dict) else 0.0
+                lines.append(f"    {dim:12s}: {val:.3f}")
+        else:
+            lines.append("  Efficiency : EFF-CURRENT not yet computed (run specsmith save)")
+    except Exception:  # noqa: BLE001
+        lines.append("  Efficiency : (unavailable)")
+
+    data["timestamp"] = datetime.now(timezone.utc).isoformat()
+
+    if as_json:
+        click.echo(_json.dumps(data, indent=2, ensure_ascii=False))
+        return
+
+    width = 60
+    border = "═" * width
+    console.print(f"[bold]╬ {border}[/bold]")
+    console.print(f"  specsmith inspect \u2014 {root}")
+    console.print(f"  {datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%MZ')}")
+    console.print(f"[bold]╪ {border}[/bold]")
+    for line in lines:
+        console.print(line)
+    console.print(f"[bold]╩ {border}[/bold]")
+
+
+def _band(score: float) -> str:
+    if score >= 0.85:
+        return "excellent"
+    if score >= 0.70:
+        return "good"
+    if score >= 0.50:
+        return "fair"
+    return "poor"
+
+
 @main.command(name="load")
 @click.option("--project-dir", type=click.Path(exists=True), default=".")
 @click.option(
@@ -12145,6 +12358,85 @@ def esdb_switch_backend_cmd(project_dir: str, target_backend: str, confirm_data_
     )
 
 
+@esdb_group.command(name="sweep")
+@click.option("--project-dir", type=click.Path(exists=True), default=".")
+@click.option(
+    "--orphans-only",
+    is_flag=True,
+    default=False,
+    help="Only remove orphaned work_item / preflight_decision records (skip retention sweep).",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Show what would be swept without writing.",
+)
+@click.option("--json", "as_json", is_flag=True, default=False)
+def esdb_sweep_cmd(
+    project_dir: str,
+    orphans_only: bool,
+    dry_run: bool,
+    as_json: bool,
+) -> None:
+    """Sweep expired and orphaned ESDB records (REQ-412).
+
+    Tombstones records whose retention period has expired and removes
+    orphaned work_item / preflight_decision records.  Refreshes EFF-CURRENT
+    after a full sweep.
+
+    \b
+    Retention periods:
+      session_metric   60 days
+      context_usage    30 days
+      ledger_event     90 days
+      seal_record      forever
+      token_metric     forever
+      efficiency_metric forever
+    """
+    import json as _json
+
+    from specsmith.esdb_sweep import run_sweep
+
+    root = Path(project_dir).resolve()
+    result = run_sweep(root, orphans_only=orphans_only, dry_run=dry_run)
+
+    if as_json:
+        click.echo(
+            _json.dumps(
+                {
+                    "tombstoned": result.tombstoned,
+                    "orphans_flagged": result.orphans_flagged,
+                    "efficiency_refreshed": result.efficiency_refreshed,
+                    "kinds_swept": result.kinds_swept,
+                    "errors": result.errors,
+                    "dry_run": dry_run,
+                },
+                indent=2,
+            )
+        )
+    else:
+        mode = "[dim](dry-run)[/dim]" if dry_run else ""
+        console.print(f"[bold]specsmith esdb sweep[/bold] {mode} \u2014 {root}\n")
+        if result.tombstoned:
+            console.print(
+                f"  [green]\u2713[/green] Tombstoned {result.tombstoned} expired record(s):"
+            )
+            for kind, n in result.kinds_swept.items():
+                console.print(f"    {kind}: {n}")
+        else:
+            console.print("  [dim]No expired records to sweep.[/dim]")
+        if result.orphans_flagged:
+            console.print(
+                f"  [green]\u2713[/green] Flagged {result.orphans_flagged} orphan record(s)."
+            )
+        if result.efficiency_refreshed:
+            console.print("  [green]\u2713[/green] EFF-CURRENT refreshed.")
+        if result.errors:
+            for err in result.errors:
+                console.print(f"  [yellow]\u26a0[/yellow] {err}")
+
+
 main.add_command(esdb_group)
 
 

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev669}/src/specsmith/context_orchestrator.py

@@ -74,6 +74,8 @@ class ContextOrchestrator:
     ) -> OptimizeResultEx:
         """Run the appropriate optimization tier for the current fill percentage.
 
+        Uses dynamic thresholds from EFF-CURRENT when available (REQ-415).
+
         Args:
             fill_pct: Current context fill as a percentage (0–100).
             history: Current conversation history (list of {role, content}).
@@ -83,13 +85,18 @@ class ContextOrchestrator:
         """
         result = OptimizeResultEx(history=list(history or []))
 
-        if fill_pct >= TIER3_PCT:
+        t1, t2, t3 = self._load_dynamic_thresholds()
+
+        if fill_pct >= t3:
             self._run_tier3(result)
-        elif fill_pct >= TIER2_PCT:
+        elif fill_pct >= t2:
             self._run_tier2(result)
-        elif fill_pct >= TIER1_PCT:
+        elif fill_pct >= t1:
             self._run_tier1(result)
 
+        # Update context_usage with peak fill (REQ-416)
+        self._update_context_usage_peak(fill_pct)
+
         return result
 
     def optimize_all(self, *, dry_run: bool = False) -> OptimizeResultEx:
@@ -215,6 +222,67 @@ class ContextOrchestrator:
     # ESDB helpers
     # ------------------------------------------------------------------
 
+    def _load_dynamic_thresholds(self) -> tuple[float, float, float]:
+        """Return (t1, t2, t3) tier thresholds, adjusted by EFF-CURRENT (REQ-415).
+
+        When the context is degraded, lower thresholds so compression triggers
+        earlier.  Falls back to module-level constants on any error.
+        """
+        try:
+            from specsmith.esdb import SqliteStore
+
+            sqlite_path = self.root / ".specsmith" / "esdb.sqlite3"
+            if not sqlite_path.exists():
+                return TIER1_PCT, TIER2_PCT, TIER3_PCT
+            with SqliteStore(self.root) as store:
+                rec = store.get("EFF-CURRENT")
+            if rec is None or not rec.data.get("degraded"):
+                return TIER1_PCT, TIER2_PCT, TIER3_PCT
+            # Degraded: trigger compression 5% earlier
+            return TIER1_PCT - 5.0, TIER2_PCT - 5.0, TIER3_PCT - 5.0
+        except Exception:  # noqa: BLE001
+            return TIER1_PCT, TIER2_PCT, TIER3_PCT
+
+    def _update_context_usage_peak(self, fill_pct: float) -> None:
+        """Upsert/update the peak fill percentage in the latest context_usage record (REQ-416)."""
+        try:
+            from specsmith.esdb import SqliteRecord, SqliteStore, open_default_store
+
+            sqlite_path = self.root / ".specsmith" / "esdb.sqlite3"
+            if not sqlite_path.exists():
+                return
+
+            # Find the most recent context_usage record and update its peak_fill_pct
+            with SqliteStore(self.root) as store:
+                records = store.query(kind="context_usage", status="active")
+
+            if not records:
+                return
+
+            # Sort by timestamp desc
+            latest = max(
+                records,
+                key=lambda r: str(r.data.get("timestamp") or ""),
+            )
+            data = dict(latest.data)
+            existing_peak = float(data.get("peak_fill_pct") or 0.0)
+            if fill_pct <= existing_peak:
+                return  # No update needed
+            data["peak_fill_pct"] = fill_pct
+            updated = SqliteRecord(
+                id=latest.id,
+                kind=latest.kind,
+                status=latest.status,
+                label=latest.label,
+                confidence=latest.confidence,
+                data=data,
+                source_ids=latest.source_ids,
+            )
+            with open_default_store(self.root, warn=False) as store:
+                store.upsert(updated)
+        except Exception:  # noqa: BLE001
+            pass
+
     def _evict_low_confidence_records(
         self,
         min_confidence: float = 0.5,
@@ -225,7 +293,8 @@ class ContextOrchestrator:
         Writes back to the store (tombstone via store.delete()) so the eviction
         persists across sessions.  Data is never physically removed — tombstone
         only.  Infrastructure records (edge, rollback_event, token_metric,
-        skill_run) and governance records (requirement, testcase) are exempt.
+        skill_run, efficiency_metric, context_usage) and governance records
+        (requirement, testcase) are exempt.
 
         Returns the count of records actually tombstoned.
         """
@@ -237,6 +306,8 @@ class ContextOrchestrator:
                 "rollback_event",
                 "token_metric",
                 "skill_run",
+                "efficiency_metric",
+                "context_usage",
             }
         )