specsmith 0.17.1.dev667__tar.gz → 0.17.1.dev684__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.17.1.dev667
+Version: 0.17.1.dev684
 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.dev684}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.17.1.dev667"
+version = "0.17.1.dev684"
 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.dev684}/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.dev684}/src/specsmith/agent/runner.py

@@ -394,7 +394,9 @@ class AgentRunner:
                     lines.append(f"    {s.icon} {s.name:<10} \u2717 {s.note}")
             lines.append("")
             if active_count == 0:
-                lines.append("  \u26a0  No provider available — commands will return no response.")
+                lines.append(
+                    "  \u26a0  No provider available \u2014 commands will return no response."
+                )
             else:
                 # Show multi-model routing if the router is configured (REQ-389).
                 if self._model_router is not None:
@@ -585,6 +587,28 @@ class AgentRunner:
             self._emit_event(type="system", message=hint)
             return None
 
+        if result is None:
+            # All providers failed — give the user an actionable explanation
+            # rather than silent emptiness.
+            import os as _os
+
+            host = _os.environ.get("OLLAMA_HOST", DEFAULT_OLLAMA_HOST).rstrip("/")
+            if _ollama_alive(host):
+                model = _pick_ollama_model(host)
+                hint = (
+                    f"Ollama is running but returned no response "
+                    f"(model: {model}). "
+                    "Try: ollama run " + model
+                )
+            else:
+                hint = (
+                    "No LLM provider available. Options:\n"
+                    "  • Start Ollama: ollama serve\n"
+                    "  • Set ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY"
+                )
+            self._emit_event(type="system", message=hint)
+            return None
+
         # Aggregate metrics into the session state (C1).
         # ``run_chat`` now reports tokens_in / tokens_out / cost_usd off the
         # provider response (Ollama prompt_eval_count + eval_count, OpenAI
@@ -604,6 +628,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.dev684/src/specsmith/agent/token_pricing.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 Layer1Labs Silicon, Inc. All rights reserved.
+"""specsmith.agent.token_pricing — static per-token cost lookup.
+
+Provides a single function :func:`cost_for_tokens` that returns the estimated
+USD cost for a given (provider, model, input_tokens, output_tokens) tuple.
+
+Design contract
+---------------
+- ``ollama`` provider (and its aliases ``llamacpp``, ``vllm``, ``lmstudio``)
+  always returns **0.0** — local inference is free; this is intentional and
+  correct, not a bug or missing data.
+- Known cloud models (OpenAI, Anthropic, Google) use a static pricing table
+  updated to Q2 2026 list prices.
+- Unknown providers/models fall back to a conservative default rate so
+  ``cost_of_pass`` analysis degrades gracefully rather than crashing.
+
+Pricing source
+--------------
+Q2 2026 provider pricing pages.  All figures are in USD per 1 M tokens.
+Update this table when provider pricing changes (bump the table version comment).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Pricing table — (input_usd_per_1M, output_usd_per_1M)
+# Table version: 2026-Q2
+# ---------------------------------------------------------------------------
+
+#: Providers that are always zero-cost (local inference).
+_FREE_PROVIDERS: frozenset[str] = frozenset({"ollama", "llamacpp", "vllm", "lmstudio", "local"})
+
+#: Static pricing table.  Keys are normalised model name substrings matched
+#: from longest to shortest so that more-specific keys win over generic ones.
+_PRICING_PER_1M: dict[str, tuple[float, float]] = {
+    # ── OpenAI GPT-4 family ────────────────────────────────────────────────
+    "gpt-4o-mini": (0.15, 0.60),
+    "gpt-4o": (2.50, 10.00),
+    "gpt-4.1-nano": (0.10, 0.40),
+    "gpt-4.1-mini": (0.40, 1.60),
+    "gpt-4.1": (2.00, 8.00),
+    "gpt-4-turbo": (10.00, 30.00),
+    # ── OpenAI GPT-5 family ────────────────────────────────────────────────
+    "gpt-5-nano": (0.50, 2.00),
+    "gpt-5-mini": (2.00, 8.00),
+    "gpt-5-pro": (50.00, 200.00),
+    "gpt-5.4-nano": (0.30, 1.20),
+    "gpt-5.4-mini": (1.00, 4.00),
+    "gpt-5.4-pro": (20.00, 80.00),
+    "gpt-5.4": (5.00, 20.00),
+    "gpt-5.5-pro": (15.00, 60.00),
+    "gpt-5.5": (3.00, 12.00),
+    "gpt-5.2-codex": (10.00, 40.00),
+    "gpt-5.2-pro": (40.00, 160.00),
+    "gpt-5.2": (10.00, 40.00),
+    "gpt-5.3-codex": (8.00, 32.00),
+    "gpt-5.1": (12.00, 48.00),
+    "gpt-5-codex": (15.00, 60.00),
+    "gpt-5": (15.00, 60.00),
+    # ── OpenAI reasoning ──────────────────────────────────────────────────
+    "o4-mini": (1.10, 4.40),
+    "o3-mini": (1.10, 4.40),
+    "o3": (10.00, 40.00),
+    "o1": (15.00, 60.00),
+    # ── Anthropic ─────────────────────────────────────────────────────────
+    "claude-haiku-4-5": (0.25, 1.25),
+    "claude-haiku": (0.25, 1.25),
+    "claude-sonnet-4-5": (3.00, 15.00),
+    "claude-sonnet-4-6": (3.00, 15.00),
+    "claude-sonnet": (3.00, 15.00),
+    "claude-opus-4-5": (15.00, 75.00),
+    "claude-opus-4-6": (15.00, 75.00),
+    "claude-opus": (15.00, 75.00),
+    # ── Google ────────────────────────────────────────────────────────────
+    "gemini-3.5-flash": (0.15, 0.60),
+    "gemini-3-flash": (0.35, 1.05),
+    "gemini-flash": (0.075, 0.30),
+    "gemini-3.1-pro": (1.25, 5.00),
+    "gemini-pro": (1.25, 5.00),
+    # ── Conservative fallback ─────────────────────────────────────────────
+    "unknown": (3.00, 15.00),
+}
+
+
+def _lookup_rates(model: str) -> tuple[float, float]:
+    """Return (input_usd_per_1M, output_usd_per_1M) for *model*.
+
+    Tries an exact key match first, then a longest-substring match, and
+    finally falls back to the ``"unknown"`` conservative default.
+    """
+    key = model.strip().lower()
+    if key in _PRICING_PER_1M:
+        return _PRICING_PER_1M[key]
+    # Longest-prefix / substring match so that "gpt-4o-mini-2026-04-09"
+    # still resolves to "gpt-4o-mini".
+    best_match = ""
+    for table_key in _PRICING_PER_1M:
+        if table_key in key and len(table_key) > len(best_match):
+            best_match = table_key
+    if best_match:
+        return _PRICING_PER_1M[best_match]
+    return _PRICING_PER_1M["unknown"]
+
+
+def cost_for_tokens(
+    provider: str,
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+) -> float:
+    """Return estimated USD cost for a single LLM call.
+
+    Args:
+        provider: Provider name (e.g. ``"ollama"``, ``"openai"``, ``"anthropic"``).
+        model: Model name or slug (e.g. ``"gpt-4o"``, ``"qwen2.5-coder:14b"``).
+        input_tokens: Number of prompt/context tokens consumed.
+        output_tokens: Number of generated/completion tokens.
+
+    Returns:
+        Estimated cost in USD.  Always ``0.0`` for local/free providers
+        (Ollama, llamacpp, vllm, lmstudio, local).  Returns ``0.0`` when
+        both token counts are zero regardless of provider.
+
+    Examples::
+
+        >>> cost_for_tokens("ollama", "qwen2.5-coder:14b", 1000, 500)
+        0.0
+        >>> cost_for_tokens("openai", "gpt-4o-mini", 1_000_000, 0)
+        0.15
+        >>> cost_for_tokens("anthropic", "claude-haiku-4-5", 0, 1_000_000)
+        1.25
+    """
+    if not provider and not model:
+        return 0.0
+    if (provider or "").strip().lower() in _FREE_PROVIDERS:
+        return 0.0
+    if input_tokens == 0 and output_tokens == 0:
+        return 0.0
+    inp_per_m, out_per_m = _lookup_rates(model)
+    return (input_tokens * inp_per_m + output_tokens * out_per_m) / 1_000_000
+
+
+def cost_for_tokens_breakdown(
+    provider: str,
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+) -> tuple[float, float, float]:
+    """Return ``(input_cost_usd, output_cost_usd, total_cost_usd)``."""
+    if (provider or "").strip().lower() in _FREE_PROVIDERS:
+        return 0.0, 0.0, 0.0
+    inp_per_m, out_per_m = _lookup_rates(model)
+    inp_cost = input_tokens * inp_per_m / 1_000_000
+    out_cost = output_tokens * out_per_m / 1_000_000
+    return inp_cost, out_cost, inp_cost + out_cost
+
+
+def tokens_per_correct_answer(
+    records: list[Any],
+    *,
+    token_attr: str = "tokens_total",
+    passed_attr: str = "passed",
+) -> float | None:
+    """Compute mean tokens consumed per correct (passing) answer.
+
+    Args:
+        records: Sequence of record objects (e.g. :class:`MetricsRecord` or
+            :class:`RunResult`) with numeric ``token_attr`` and bool
+            ``passed_attr`` attributes.
+        token_attr: Attribute name for total token count.
+        passed_attr: Attribute name for pass/fail boolean.
+
+    Returns:
+        Mean total tokens among passing records, or ``None`` if no passing
+        records exist.
+    """
+    passing = [r for r in records if getattr(r, passed_attr, False)]
+    if not passing:
+        return None
+    totals = [getattr(r, token_attr, 0) for r in passing]
+    return sum(totals) / len(totals)
+
+
+__all__ = [
+    "cost_for_tokens",
+    "cost_for_tokens_breakdown",
+    "tokens_per_correct_answer",
+]

{specsmith-0.17.1.dev667 → specsmith-0.17.1.dev684}/src/specsmith/auditor.py

@@ -554,8 +554,9 @@ def check_ledger_health(root: Path) -> list[AuditResult]:
 
 
 # Default thresholds (used when no project type is detected)
+# AGENTS.md: raised to 250 (template now generates ~202 lines with Parallel Agents section)
 _DEFAULT_THRESHOLDS: dict[str, int] = {
-    "AGENTS.md": 200,
+    "AGENTS.md": 250,
     "docs/governance/RULES.md": 800,
     "docs/governance/SESSION-PROTOCOL.md": 400,
     "docs/governance/LIFECYCLE.md": 200,