blitz-cli 0.15.0__tar.gz → 0.16.1__tar.gz

{blitz_cli-0.15.0 → blitz_cli-0.16.1}/.gitignore

@@ -21,3 +21,10 @@ dist/
 # the blitz.toml, which is not always the repo root. The `*` covers the SQLite
 # -wal/-shm sidecars.
 **/.blitz/traces.db*
+
+# Regenerable `blitz init` output: scripts/ and templates/ are refreshed from the
+# package on --force, so a clone reproduces them exactly by running init.
+# memory/playbook.md is deliberately NOT here: it is seeded once and never
+# overwritten, so it stays tracked.
+/.blitz/scripts/
+/.blitz/templates/

{blitz_cli-0.15.0 → blitz_cli-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blitz-cli
-Version: 0.15.0
+Version: 0.16.1
 Summary: Developer CLI for Blitz locker-room: spec-driven playbooks, a codebase/huddle ontology graph with an MCP tool, and the composable watcher/trainer/graph containers.
 License: MIT
 License-File: LICENSE

{blitz_cli-0.15.0 → blitz_cli-0.16.1}/blitz_cli/__init__.py

@@ -30,4 +30,4 @@ Commands:
 
 __all__ = ["__version__"]
 
-__version__ = "0.15.0"
+__version__ = "0.16.0"

{blitz_cli-0.15.0 → blitz_cli-0.16.1}/blitz_cli/_activity.py

@@ -21,6 +21,9 @@ from pathlib import Path
 from typing import Optional
 
 _SYSTEM_REMINDER_RE = re.compile(r"<system-reminder>.*?</system-reminder>\s*", re.DOTALL)
+# Slash-command invocations recorded inside the raw user prompt, e.g.
+# <command-name>/huddle</command-name>. Matched BEFORE _clean_prompt() runs.
+_COMMAND_NAME_RE = re.compile(r"<command-name>\s*(/?[\w:-]+)\s*</command-name>")
 # Compact, single-line caps for the terminal's quick-glance labels.
 _MAX_SUMMARY_LEN = 80
 _MAX_SNIPPET_LEN = 200
@@ -57,6 +60,9 @@ class Turn:
     cache_creation_tokens: int = 0
     models: list = field(default_factory=list)
     turn_uuid: Optional[str] = None
+    commands: list = field(default_factory=list)
+    did_git_push: bool = False
+    did_create_pr: bool = False
 
 
 @dataclass
@@ -198,6 +204,18 @@ def _prompt_text(content) -> Optional[str]:
     return None
 
 
+def _raw_prompt_text(content) -> str:
+    """The user record's prompt text with nothing stripped, for extraction
+    of markers (like <command-name> blocks) that _clean_prompt may remove."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(
+            b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text"
+        )
+    return ""
+
+
 def _truncate(text: str, limit: int) -> str:
     """Collapse whitespace to one line and cap length — for compact labels."""
     text = " ".join(text.split())
@@ -520,6 +538,12 @@ def parse_session(path: Path, file_history_dir: Optional[Path] = None) -> Sessio
             if prompt is not None:
                 _finalize()
                 current = Turn(timestamp=rec.get("timestamp"), prompt=prompt, turn_uuid=rec.get("uuid"))
+                # Slash commands are extracted from the RAW prompt text,
+                # before _clean_prompt strips anything (research R1).
+                current.commands = [
+                    name if name.startswith("/") else f"/{name}"
+                    for name in _COMMAND_NAME_RE.findall(_raw_prompt_text(content))
+                ]
                 continue
             # tool-result line: match each block back to its tool_use action
             if isinstance(content, list):
@@ -574,6 +598,12 @@ def parse_session(path: Path, file_history_dir: Optional[Path] = None) -> Sessio
                                 file_history_dir, session_id, tool_name, tool_input or {},
                                 file_path, backup_info["backupFileName"],
                             )
+                    if tool_name == "Bash":
+                        command = (tool_input or {}).get("command") or ""
+                        if "git push" in command:
+                            current.did_git_push = True
+                        if "gh pr create" in command:
+                            current.did_create_pr = True
                     current.actions.append(action)
                     if block.get("id"):
                         pending_tool_uses[block["id"]] = action

blitz_cli-0.16.1/blitz_cli/_corpus.py

@@ -0,0 +1,542 @@
+"""Convert Claude Code activity (parsed by `_activity.py`) into a fine-tuning
+corpus stored in SQLite, for the `blitz locker-room watch`
+container.
+
+This is a wholly separate store from `_local.py`'s `spans` table —
+`_dataset.py:span_to_example()` explicitly rejects any tool-call-shaped span
+and only extracts plain-string message content, so it's the wrong shape for
+agentic Claude Code trajectories. `turns` here holds one row per Turn (an
+OpenAI/Qwen-chat-style `{"messages": [...]}` example using Claude Code's own
+native tool names), and `raw_sessions` holds a redacted archival copy of each
+session's full transcript — kept independent of Claude Code's own
+`cleanupPeriodDays` auto-deletion (default 30 days), and independent of our
+own lossy `turns` conversion, so a better conversion can be re-derived later
+without needing the original (possibly already-deleted) source transcript.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from blitz_cli import _activity, _redact
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS turns (
+    turn_id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    project_path TEXT,
+    turn_uuid TEXT,
+    turn_ordinal INTEGER,
+    started_at TEXT,
+    duration_ms INTEGER,
+    models TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    cache_read_tokens INTEGER,
+    cache_creation_tokens INTEGER,
+    action_count INTEGER,
+    had_error INTEGER,
+    messages_json TEXT NOT NULL,
+    ingested_at TEXT NOT NULL,
+    source_mtime REAL NOT NULL,
+    commands_json TEXT,
+    did_git_push INTEGER,
+    did_create_pr INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_turns_session_id ON turns(session_id);
+CREATE INDEX IF NOT EXISTS idx_turns_started_at ON turns(started_at);
+CREATE INDEX IF NOT EXISTS idx_turns_project_path ON turns(project_path);
+
+CREATE TABLE IF NOT EXISTS ingest_state (
+    session_path TEXT PRIMARY KEY,
+    last_mtime REAL NOT NULL,
+    last_ingested_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS raw_sessions (
+    session_id TEXT PRIMARY KEY,
+    project_path TEXT,
+    raw_content TEXT NOT NULL,
+    source_mtime REAL NOT NULL,
+    ingested_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_raw_sessions_project_path ON raw_sessions(project_path);
+
+CREATE TABLE IF NOT EXISTS local_usage (
+    run_id TEXT PRIMARY KEY,
+    repo_path TEXT,
+    spec TEXT,
+    model TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    started_at TEXT,
+    source_path TEXT,
+    ingested_at TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_local_usage_started_at ON local_usage(started_at);
+"""
+
+# Additive v2 columns on `turns`, applied by ALTER TABLE when opening a db
+# created before they existed (CREATE TABLE IF NOT EXISTS never adds columns).
+_TURNS_V2_COLUMNS = (
+    ("commands_json", "TEXT"),
+    ("did_git_push", "INTEGER"),
+    ("did_create_pr", "INTEGER"),
+)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def turn_to_messages(turn) -> Optional[dict]:
+    """Turn -> {"messages": [...]} training example: a user message
+    (turn.prompt), one assistant message carrying every action's tool_calls
+    (native Claude Code tool names — Read/Edit/Write/Bash/... — not remapped),
+    one tool-role message per result, then a final assistant text message.
+    All text is redacted. Returns None if the turn has no usable content at
+    all (empty prompt, no actions, no response — a dangling trailing turn)."""
+    if not turn.prompt and not turn.response and not turn.actions:
+        return None
+
+    messages = [{"role": "user", "content": _redact.redact(turn.prompt or "")}]
+
+    if turn.actions:
+        tool_calls = []
+        for i, action in enumerate(turn.actions):
+            arguments = json.dumps(
+                _redact.redact_json_strings(action.tool_input or {}), ensure_ascii=False
+            )
+            tool_calls.append({
+                "id": f"call_{i}",
+                "type": "function",
+                "function": {"name": action.tool, "arguments": arguments},
+            })
+        messages.append({"role": "assistant", "content": None, "tool_calls": tool_calls})
+        for i, action in enumerate(turn.actions):
+            messages.append({
+                "role": "tool",
+                "tool_call_id": f"call_{i}",
+                "content": _redact.redact(action.result_full or ""),
+            })
+
+    if turn.response:
+        messages.append({"role": "assistant", "content": _redact.redact(turn.response)})
+
+    return {"messages": messages}
+
+
+def turn_to_row(
+    session_id: str, project_path: str, ordinal: int, turn, source_mtime: float
+) -> Optional[dict]:
+    """Build the full `turns` table row for one Turn, or None if it has no
+    usable content (see turn_to_messages)."""
+    example = turn_to_messages(turn)
+    if example is None:
+        return None
+    turn_key = turn.turn_uuid or f"ordinal-{ordinal}"
+    return {
+        "turn_id": f"{session_id}:{turn_key}",
+        "session_id": session_id,
+        "project_path": project_path,
+        "turn_uuid": turn.turn_uuid,
+        "turn_ordinal": ordinal,
+        "started_at": turn.timestamp,
+        "duration_ms": turn.duration_ms,
+        "models": json.dumps(turn.models),
+        "input_tokens": turn.input_tokens,
+        "output_tokens": turn.output_tokens,
+        "cache_read_tokens": turn.cache_read_tokens,
+        "cache_creation_tokens": turn.cache_creation_tokens,
+        "action_count": len(turn.actions),
+        "had_error": 1 if any(a.ok is False for a in turn.actions) else 0,
+        "messages_json": json.dumps(example, ensure_ascii=False),
+        "ingested_at": _now_iso(),
+        "source_mtime": source_mtime,
+        "commands_json": json.dumps(turn.commands),
+        "did_git_push": 1 if turn.did_git_push else 0,
+        "did_create_pr": 1 if turn.did_create_pr else 0,
+    }
+
+
+class TurnStore:
+    """Writer for the locker-room activity fine-tuning corpus. Unlike _local.py's
+    read-only LocalStore (which assumes an externally-stubbed db and returns
+    None if missing), this store owns its schema and creates it on first
+    connect — it's the one and only writer, structurally closer to
+    serve.py.tmpl's _init_db() than to a CLI-side read path."""
+
+    def __init__(self, db_path: Path):
+        self._db_path = Path(db_path)
+        self._schema_ready = False
+
+    def _connect(self) -> sqlite3.Connection:
+        db = str(self._db_path)
+        is_uri = db.startswith("file:")
+        if not is_uri:
+            self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = sqlite3.connect(db, uri=is_uri)
+        conn.row_factory = sqlite3.Row
+        if not self._schema_ready:
+            try:
+                conn.execute("PRAGMA journal_mode=WAL")
+                conn.executescript(_SCHEMA)
+                existing = {
+                    row[1] for row in conn.execute("PRAGMA table_info(turns)")
+                }
+                for name, col_type in _TURNS_V2_COLUMNS:
+                    if name not in existing:
+                        conn.execute(f"ALTER TABLE turns ADD COLUMN {name} {col_type}")
+                conn.commit()
+            except sqlite3.OperationalError:
+                # Read-only database: readers need no DDL; proceed without it.
+                pass
+            self._schema_ready = True
+        return conn
+
+    def get_last_mtime(self, session_path: str) -> Optional[float]:
+        conn = self._connect()
+        try:
+            row = conn.execute(
+                "SELECT last_mtime FROM ingest_state WHERE session_path = ?", (session_path,)
+            ).fetchone()
+            return row["last_mtime"] if row else None
+        finally:
+            conn.close()
+
+    def set_last_mtime(self, session_path: str, mtime: float) -> None:
+        conn = self._connect()
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO ingest_state (session_path, last_mtime, last_ingested_at) "
+                "VALUES (?, ?, ?)",
+                (session_path, mtime, _now_iso()),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def upsert_turns(self, rows: list) -> int:
+        if not rows:
+            return 0
+        # NULL in the v2 columns means "not derived" (contract C1); callers
+        # predating v2 may omit the keys entirely.
+        rows = [
+            {"commands_json": None, "did_git_push": None, "did_create_pr": None, **row}
+            for row in rows
+        ]
+        conn = self._connect()
+        try:
+            conn.executemany(
+                "INSERT OR REPLACE INTO turns ("
+                "turn_id, session_id, project_path, turn_uuid, turn_ordinal, started_at, "
+                "duration_ms, models, input_tokens, output_tokens, cache_read_tokens, "
+                "cache_creation_tokens, action_count, had_error, messages_json, ingested_at, "
+                "source_mtime, commands_json, did_git_push, did_create_pr"
+                ") VALUES ("
+                ":turn_id, :session_id, :project_path, :turn_uuid, :turn_ordinal, :started_at, "
+                ":duration_ms, :models, :input_tokens, :output_tokens, :cache_read_tokens, "
+                ":cache_creation_tokens, :action_count, :had_error, :messages_json, :ingested_at, "
+                ":source_mtime, :commands_json, :did_git_push, :did_create_pr"
+                ")",
+                rows,
+            )
+            conn.commit()
+            return len(rows)
+        finally:
+            conn.close()
+
+    def upsert_local_usage(self, rows: list) -> int:
+        if not rows:
+            return 0
+        conn = self._connect()
+        try:
+            conn.executemany(
+                "INSERT OR REPLACE INTO local_usage ("
+                "run_id, repo_path, spec, model, input_tokens, output_tokens, "
+                "started_at, source_path, ingested_at"
+                ") VALUES ("
+                ":run_id, :repo_path, :spec, :model, :input_tokens, :output_tokens, "
+                ":started_at, :source_path, :ingested_at"
+                ")",
+                rows,
+            )
+            conn.commit()
+            return len(rows)
+        finally:
+            conn.close()
+
+    def usage_summary(self, from_ts: str, to_ts: str, bucket: str = "hour") -> dict:
+        """Token usage over time by (bucket, source, model). Window:
+        from_ts <= started_at < to_ts (ISO-8601 UTC strings). Frontier rows
+        come from `turns` (tokens attributed to the turn's first model),
+        local rows from `local_usage`. Returns {"series": [...]} ordered by
+        bucket. Safe on a read-only database (SELECT only)."""
+        formats = {"hour": "%Y-%m-%dT%H:00:00Z", "day": "%Y-%m-%dT00:00:00Z"}
+        if bucket not in formats:
+            raise ValueError(f"bucket must be 'hour' or 'day', got {bucket!r}")
+        fmt = formats[bucket]
+        conn = self._connect()
+        try:
+            series = []
+            frontier = conn.execute(
+                "SELECT strftime(?, started_at) AS bucket, "
+                "COALESCE(json_extract(models, '$[0]'), '') AS model, "
+                "SUM(COALESCE(input_tokens, 0)) AS input_tokens, "
+                "SUM(COALESCE(output_tokens, 0)) AS output_tokens "
+                "FROM turns WHERE started_at >= ? AND started_at < ? "
+                "GROUP BY bucket, model",
+                (fmt, from_ts, to_ts),
+            ).fetchall()
+            for row in frontier:
+                series.append({
+                    "bucket": row["bucket"], "source": "frontier", "model": row["model"],
+                    "input_tokens": row["input_tokens"], "output_tokens": row["output_tokens"],
+                })
+            try:
+                local = conn.execute(
+                    "SELECT strftime(?, started_at) AS bucket, "
+                    "COALESCE(model, '') AS model, "
+                    "SUM(COALESCE(input_tokens, 0)) AS input_tokens, "
+                    "SUM(COALESCE(output_tokens, 0)) AS output_tokens "
+                    "FROM local_usage WHERE started_at >= ? AND started_at < ? "
+                    "GROUP BY bucket, model",
+                    (fmt, from_ts, to_ts),
+                ).fetchall()
+            except sqlite3.OperationalError:
+                # Read-only pre-v2 db without local_usage: no local rows.
+                local = []
+            for row in local:
+                series.append({
+                    "bucket": row["bucket"], "source": "local", "model": row["model"],
+                    "input_tokens": row["input_tokens"], "output_tokens": row["output_tokens"],
+                })
+            series.sort(key=lambda s: (s["bucket"], s["source"], s["model"]))
+            return {"series": series}
+        finally:
+            conn.close()
+
+    def usage_sessions(self, from_ts: str, to_ts: str) -> dict:
+        """Per-session aggregates over turns in the window. `models` and
+        `commands` are merged across turns, deduped in first-seen order;
+        flags are true when any turn set them; NULL commands_json/flags are
+        treated as empty/false. Returns {"sessions": [...]} ordered by
+        first_ts. Safe on a read-only database (SELECT only)."""
+        conn = self._connect()
+        try:
+            rows = conn.execute(
+                "SELECT * FROM turns WHERE started_at >= ? AND started_at < ? "
+                "ORDER BY started_at",
+                (from_ts, to_ts),
+            ).fetchall()
+        finally:
+            conn.close()
+
+        sessions: dict = {}
+        order = []
+        for row in rows:
+            keys = row.keys()
+            sid = row["session_id"]
+            agg = sessions.get(sid)
+            if agg is None:
+                agg = {
+                    "session_id": sid,
+                    "project_path": row["project_path"],
+                    "first_ts": row["started_at"],
+                    "last_ts": row["started_at"],
+                    "input_tokens": 0, "output_tokens": 0,
+                    "cache_read_tokens": 0, "cache_creation_tokens": 0,
+                    "models": [], "commands": [],
+                    "did_git_push": False, "did_create_pr": False,
+                    "turn_count": 0, "error_count": 0,
+                }
+                sessions[sid] = agg
+                order.append(sid)
+            ts = row["started_at"]
+            if ts is not None:
+                if agg["first_ts"] is None or ts < agg["first_ts"]:
+                    agg["first_ts"] = ts
+                if agg["last_ts"] is None or ts > agg["last_ts"]:
+                    agg["last_ts"] = ts
+            for col in ("input_tokens", "output_tokens", "cache_read_tokens", "cache_creation_tokens"):
+                agg[col] += row[col] or 0
+            agg["turn_count"] += 1
+            agg["error_count"] += 1 if row["had_error"] else 0
+            try:
+                models = json.loads(row["models"]) if row["models"] else []
+            except ValueError:
+                models = []
+            for m in models:
+                if m not in agg["models"]:
+                    agg["models"].append(m)
+            commands_json = row["commands_json"] if "commands_json" in keys else None
+            try:
+                commands = json.loads(commands_json) if commands_json else []
+            except ValueError:
+                commands = []
+            for c in commands:
+                if c not in agg["commands"]:
+                    agg["commands"].append(c)
+            if "did_git_push" in keys and row["did_git_push"]:
+                agg["did_git_push"] = True
+            if "did_create_pr" in keys and row["did_create_pr"]:
+                agg["did_create_pr"] = True
+
+        result = sorted(
+            (sessions[sid] for sid in order),
+            key=lambda s: s["first_ts"] or "",
+        )
+        return {"sessions": result}
+
+    def upsert_raw_session(
+        self, session_id: str, project_path: str, raw_content: str, source_mtime: float
+    ) -> None:
+        conn = self._connect()
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO raw_sessions "
+                "(session_id, project_path, raw_content, source_mtime, ingested_at) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (session_id, project_path, raw_content, source_mtime, _now_iso()),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+
+def ingest_once(projects_dir: Path, store: TurnStore, print_fn=print) -> int:
+    """Walk every project dir under projects_dir, re-ingest any session whose
+    mtime has advanced since the last recorded ingest, and return the number
+    of turn rows upserted this pass. A session file's raw (redacted) content
+    is archived to `raw_sessions` on the same pass. Never raises on a single
+    bad file — logs and continues, since a transcript can be mid-write."""
+    total = 0
+    if not projects_dir.is_dir():
+        return total
+    for project_dir in sorted(projects_dir.iterdir()):
+        if not project_dir.is_dir():
+            continue
+        for session_path in sorted(project_dir.glob("*.jsonl")):
+            try:
+                mtime = session_path.stat().st_mtime
+            except OSError:
+                continue
+            last = store.get_last_mtime(str(session_path))
+            if last is not None and mtime <= last:
+                continue
+            try:
+                raw_text = session_path.read_text(encoding="utf-8", errors="replace")
+                session = _activity.parse_session(session_path)
+            except Exception as exc:  # a malformed/mid-write file must never kill the watcher
+                print_fn(f"[watch] skip {session_path}: {exc}")
+                continue
+
+            store.upsert_raw_session(
+                session.id, project_dir.name, _redact.redact_jsonl_text(raw_text), mtime
+            )
+            rows = []
+            for i, turn in enumerate(session.turns):
+                row = turn_to_row(session.id, project_dir.name, i, turn, mtime)
+                if row is not None:
+                    rows.append(row)
+            total += store.upsert_turns(rows)
+            store.set_last_mtime(str(session_path), mtime)
+    return total
+
+
+def backfill_turn_usage(store: TurnStore, print_fn=print) -> int:
+    """Re-derive commands_json/did_git_push/did_create_pr for existing turns
+    rows by re-parsing raw_sessions.raw_content with the same parser ingest
+    uses. Idempotent (parsing is deterministic). Unmatched turn ids skip
+    silently; malformed raw content logs via print_fn and continues. Returns
+    the number of rows updated."""
+    conn = store._connect()
+    try:
+        raw_rows = conn.execute("SELECT session_id, raw_content FROM raw_sessions").fetchall()
+        updated = 0
+        for raw in raw_rows:
+            session_id = raw["session_id"]
+            try:
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    session_path = Path(tmp_dir) / f"{session_id}.jsonl"
+                    session_path.write_text(raw["raw_content"], encoding="utf-8")
+                    session = _activity.parse_session(session_path)
+            except Exception as exc:  # malformed archives must not kill the backfill
+                print_fn(f"[backfill] skip {session_id}: {exc}")
+                continue
+            for i, turn in enumerate(session.turns):
+                turn_key = turn.turn_uuid or f"ordinal-{i}"
+                cursor = conn.execute(
+                    "UPDATE turns SET commands_json = ?, did_git_push = ?, did_create_pr = ? "
+                    "WHERE turn_id = ?",
+                    (
+                        json.dumps(turn.commands),
+                        1 if turn.did_git_push else 0,
+                        1 if turn.did_create_pr else 0,
+                        f"{session_id}:{turn_key}",
+                    ),
+                )
+                updated += cursor.rowcount
+        conn.commit()
+        return updated
+    finally:
+        conn.close()
+
+
+def ingest_local_usage(workspace_root: Path, store: TurnStore, print_fn=print) -> int:
+    """Scan the workspace's repos (up to three directory levels deep, matching
+    huddle discovery) for .blitz/execute/runs/*/usage.json and upsert one
+    local_usage row per run, keyed on "<repo>:<run-dir>" so the pass is
+    idempotent. Missing root or malformed records never raise. Returns the
+    number of rows upserted."""
+    workspace_root = Path(workspace_root)
+    if not workspace_root.is_dir():
+        return 0
+    usage_paths = sorted(
+        p
+        for depth in ("*", "*/*", "*/*/*")
+        for p in workspace_root.glob(f"{depth}/.blitz/execute/runs/*/usage.json")
+    )
+    rows = []
+    for usage_path in usage_paths:
+        try:
+            record = json.loads(usage_path.read_text())
+        except (OSError, ValueError) as exc:
+            print_fn(f"[local-usage] skip {usage_path}: {exc}")
+            continue
+        spec = record.get("spec")
+        total = record.get("total")
+        if not spec or not isinstance(spec, str) or not isinstance(total, dict):
+            continue
+        run_dir = usage_path.parent
+        repo_dir = usage_path.parents[4]  # <repo>/.blitz/execute/runs/<run>/usage.json
+        try:
+            started_local = datetime.strptime(run_dir.name, "%Y%m%d-%H%M%S").astimezone()
+            started_utc = started_local.astimezone(timezone.utc)
+        except ValueError:
+            try:
+                mtime = usage_path.stat().st_mtime
+            except OSError:
+                continue
+            started_utc = datetime.fromtimestamp(mtime, timezone.utc)
+        # "Z" suffix matches the timestamp format Claude Code transcripts use,
+        # so lexicographic window comparisons stay chronological across sources.
+        started_at = started_utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+        repo_rel = repo_dir.relative_to(workspace_root).as_posix()
+        rows.append({
+            "run_id": f"{repo_rel}:{run_dir.name}",
+            "repo_path": repo_rel,
+            "spec": spec,
+            "model": record.get("model"),
+            "input_tokens": total.get("input", 0),
+            "output_tokens": total.get("output", 0),
+            "started_at": started_at,
+            "source_path": str(usage_path),
+            "ingested_at": _now_iso(),
+        })
+    return store.upsert_local_usage(rows)

{blitz_cli-0.15.0 → blitz_cli-0.16.1}/blitz_cli/_gitignore.py

@@ -1,10 +1,13 @@
 """Reconcile an install target's .gitignore with the playbook working area rules.
 
-The .blitz/ directory splits into content that must stay trackable (memory/,
-scripts/, templates/) and per-run state that must not be committed (execute/,
-feature.json, and the blitz-sdk trace store). This module ensures the rules for
-the state half are present in the target's root .gitignore, append-only, and
-never touches a rule the user wrote.
+The .blitz/ directory splits into what a clone can reproduce and what it cannot.
+Regenerable output (scripts/, templates/) and per-run state (execute/,
+feature.json, and the blitz-sdk trace store) are ignored. Seeded-once content
+(memory/, which holds the repo's playbook) stays trackable, because
+install_scaffold() never overwrites it and so nothing can reconstruct it.
+
+This module ensures the ignored half's rules are present in the target's root
+.gitignore, append-only, and never touches a rule the user wrote.
 """
 
 from __future__ import annotations
@@ -14,7 +17,7 @@ from pathlib import Path
 
 from blitz_cli._git import _git
 
-COMMENT = "# Blitz playbook working area: per-run state, not content."
+COMMENT = "# Blitz working area: regenerable output and per-run state."
 
 RULES: tuple[str, ...] = (
     "/.blitz/execute/",
@@ -24,6 +27,16 @@ RULES: tuple[str, ...] = (
     # which is not always the repo root. An anchored rule would silently miss
     # it. The trailing * covers the SQLite -wal and -shm sidecars.
     "**/.blitz/traces.db*",
+    # Regenerable output: install_scaffold() refreshes both from the package
+    # under --force, and nothing detects on either, so a clone reproduces them
+    # exactly by running init. The test is regenerable AND not an input to the
+    # thing that regenerates it. memory/ fails the first half: it is seeded
+    # once and never overwritten, so nothing can reconstruct it. A rendered
+    # agent command directory fails the second: it is what AGENTS[...] detects
+    # on, so ignoring it means init finds no agent and installs nothing.
+    # Neither belongs here. See specs/006-init-ignore-generated/spec.md.
+    "/.blitz/scripts/",
+    "/.blitz/templates/",
 )