theslopmachine 1.0.13 → 1.0.22

package/assets/skills/deep-retrospective/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: deep-retrospective
+description: Deep retrospective analysis for slopmachine workflow runs. Triggered exclusively by "deep-retrospective <path>". Extracts raw session data then performs multi-phase analysis comparing actual workflow traces against expected behavior.
+---
+
+# Deep Retrospective
+
+Two-phase skill for analyzing completed slopmachine workflow runs.
+
+## Phase 1: Extraction
+
+When the user triggers `deep-retrospective <path>`, first run the extraction script:
+
+```
+python3 ~/.agents/skills/deep-retrospective/run.py <path>
+```
+
+This writes raw data to `retrospectives/<project>_<timestamp>/extraction/`. Proceed to Phase 2 immediately — no pause, no user confirmation.
+
+## Phase 2: Deep Analysis
+
+Load `~/.agents/skills/deep-retrospective/workflow-reference.md` before starting. This defines expected behavior for every phase, developer lane rules, and known anti-patterns.
+
+**Output directory:** `retrospectives/<project>_<timestamp>/analysis/`
+
+**Critical rule:** The analysis must be exhaustive. Read every text response from every session. Do not skim. Quote specific excerpts from developer, evaluator, and owner traces as evidence for every finding. The per-phase files especially must be deeply detailed — think of them as investigation reports where each session interaction is evidence.
+
+### Step 1: Build the Phase Timeline
+
+Read `extraction/sessions.json`, `extraction/beads.json`, and `extraction/ai-metadata.json`. Build a timeline with per-phase: start/end times, duration, bead IDs, active session IDs, total tokens consumed. Write to `analysis/phase-timeline.md`.
+
+### Step 2: Read Every Session Trace — Do Not Skim
+
+**This is the most important step.** Open every file in `extraction/sessions/`. For each session, read ALL text_parts. Do not stop at the first 10-15 entries. Read everything. Take notes.
+
+For each session, record:
+- Session ID, type, part count, token totals
+- Every text response with timestamp (quote the full text, not truncated snippets)
+- Every tool call name and count
+- Every task launch (subagent spawn) with description and prompt excerpt
+
+### Step 3: Map Sessions to Phases
+
+Using the bead timestamps and session time_created/time_updated fields from `extraction/sessions.json`, assign each session to the phase(s) it was active during. The owner session spans all phases — split its text responses by phase. Developer sessions for specific phases (design, primary dev, bugfix, coverage) are assigned to their respective phases.
+
+### Step 4: Per-Phase Deep Analysis — The Core Deliverable
+
+For each phase (1 through 8 as available), produce `analysis/phases/phase-<N>-<name>.md`. Each file must be thorough — these are the primary analysis artifacts.
+
+**Every phase file must include these sections, with no section skipped:**
+
+#### 4a. Session Inventory
+List every session active during this phase with: ID, slug, title, type, part count, input tokens, output tokens, time created, time updated.
+
+#### 4b. Owner Actions — Step by Step
+Reconstruct what the owner did from the owner session's text_parts for this phase. Read every owner text response and list each action chronologically. For each action, include:
+- Timestamp
+- What the owner did (launched subagent, sent prompt, reviewed output, recorded bead)
+- The exact text the owner wrote or the prompt that was sent
+- Which subagent session was launched (if any), with session ID
+
+#### 4c. Developer/Worker Interactions — Complete Trace
+Read ALL text responses from every developer/general/evaluator session active during this phase. Present them chronologically. For each interaction:
+- Timestamp
+- What was said (quote the actual text — do not summarize or paraphrase)
+- What actions the developer took (tool calls, file edits)
+- What was produced (test counts, files created, outcomes)
+
+For the primary developer session spanning multiple phases (design into development): split the responses by module/topic. For Phase 3 specifically, group by module (scaffold, auth, courses, resources, announcements, search, stores, admin).
+
+For the bugfix developer: present each fix round as a subsection with the issues in that round, the fixes applied, and the test impact.
+
+#### 4d. Bead Commentary
+Every bead comment for this phase — quoted in full (not truncated). Include the bead ID, timestamp, author, and full text of the comment.
+
+#### 4e. Rule Compliance — Expected vs Actual
+Using `workflow-reference.md` as the standard, create a table comparing each relevant rule against what actually happened:
+
+| Rule from workflow-reference | Expected | Actual | Verdict | Evidence |
+|---|---|---|---|---|
+| [specific rule] | [what should happen] | [what happened based on traces] | PASS/FAIL/MISSED/UNCLEAR | [session ID + excerpt] |
+
+#### 4f. Interactions Between Sessions
+Trace the flow of work between sessions in this phase:
+- Owner → developer: what was the prompt? Was it natural language? Did it expose workflow mechanics?
+- Developer → owner: what was the response? Did the developer report completion? How?
+- Owner → evaluator: what prompt was sent? Was it verbatim?
+- Evaluator → owner: what verdict? What issues were found?
+- Owner → bugfix developer: how were issues communicated?
+
+Quote the actual messages exchanged. Do not summarize.
+
+#### 4g. What Worked Well / What Went Wrong
+Specific findings with exact evidence:
+- What patterns were correct (e.g. "natural language prompting maintained throughout — see excerpt X")
+- What patterns were incorrect (e.g. "permissive assertion at timestamp X — see excerpt Y")
+- Every deviation from the workflow-reference must be listed with the rule it violates
+
+#### 4h. What Should Have Been Caught
+Issues that originated in this phase but only surfaced later. For each:
+- What the issue was
+- Which later phase discovered it (with bead comment citation)
+- Why it was missed in this phase
+- What specific check would have caught it
+
+### Step 5: Cross-Phase Root Cause Chain
+
+Write to `analysis/root-cause-chain.md`. Build the end-to-end trace:
+```
+P1-P2: [what was accepted without proper verification]
+   → Specific gap: [exact plan/design deficiency]
+   ↓
+P3: [specific development failures with excerpts]
+   → Module by module: [what went wrong in each]
+   ↓
+P4: [what verification missed]
+   → [specific evaluator pass deficiency]
+   ↓
+P5: [what evaluation found but couldn't prevent]
+   → [coverage chase details]
+   ↓
+P6-P7: [what was caught at the last moment]
+   → [exact bugs discovered, when, how]
+```
+
+Then for every late finding: a table with finding, phase surfaced, phase that should have caught it, why it was missed, specific workflow fix.
+
+Also identify the **single highest-leverage fix** — the one change that would have prevented the most downstream churn.
+
+### Step 6: Developer Pattern Analysis
+
+Write to `analysis/dev-patterns.md`. Read ALL developer text responses across all developer sessions. For each anti-pattern from workflow-reference.md, count occurrences and quote the exact excerpts. Include:
+- Pattern name
+- Count
+- Every instance with session ID, timestamp, full text excerpt
+- Which rule from workflow-reference.md or developer.md is violated
+
+### Step 7: Evaluator Session Analysis
+
+Write to `analysis/evaluator-sessions.md`. For every evaluator session (all sessions with type "evaluator"):
+
+- Session ID, parts, tokens
+- What prompt was sent (was it the full evaluation prompt? regeneration prompt? follow-up?)
+- What verdict was returned (Fail, Partial Pass, Pass)
+- What issues were found (quote the key findings)
+- Whether the evaluator had file-write capability
+- Whether this was part of a regeneration cycle or coverage chase
+
+Group evaluator sessions by purpose: internal evaluator (Phase 4), audit cycle 1, audit cycle 2, coverage/README audit, coverage chase sessions.
+
+### Step 8: Owner Decision Quality
+
+Write to `analysis/owner-decisions.md`. Rate every significant owner decision with:
+- What was decided (specific action or inaction)
+- Quality rating (GOOD / WEAK / POOR)
+- What resulted from this decision
+- Evidence: session ID, timestamp, exact excerpt
+
+Cover at minimum: design/plan acceptance, module completion acceptance, evaluator pass count, browser verification approach, coverage scoring response, package validation, prompt paste discipline, session lifecycle management.
+
+### Step 9: Playbook Cross-Reference
+
+Write to `analysis/playbook-matches.md`. For all 10 playbook lessons, assess applicability with specific evidence from this run's traces.
+
+### Step 10: Scoring
+
+Write to `analysis/scoring.md`. Score each dimension (1-10) with narrative evidence explaining the score — not just numbers.
+
+### Step 11: Improvements
+
+Write to `analysis/improvements.md`. Immediate and medium-term tiers. Each improvement must reference specific evidence from the analysis.
+
+### Step 12: Complete Summary
+
+Write `analysis/deep-retrospective.md` — the complete analysis combining all of the above into one document. This is the master report.
+
+After writing all files, count the total lines across all markdown files. If the total is less than 2000 lines for a project with 30+ sessions, you have not been thorough enough. Go back and add more detail.
+
+Present the user with: grade, key findings, top 3 improvements, and total analysis size.

package/assets/skills/deep-retrospective/run.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+"""Extract all raw data from a slopmachine project for deep retrospective analysis.
+
+Usage: python3 run.py <project_path>
+
+Extracts: OpenCode sessions + parts, beads history, .ai metadata, task docs,
+audit reports, token counts, and conversation traces. Writes everything to
+retrospectives/<project>_<timestamp>/extraction/ — no analysis performed.
+"""
+
+import json
+import os
+import sqlite3
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone
+
+
+def ts_to_iso(ts_ms):
+    return datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc).isoformat()
+
+
+# ─── Database extraction ───────────────────────────────────────────
+
+def extract_sessions(db_path, project_path):
+    """Extract all sessions matching project_path from opencode.db."""
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+
+    rows = conn.execute("""
+        SELECT id, slug, title, directory, time_created, time_updated,
+               agent, model, parent_id
+        FROM session
+        WHERE directory = ? OR directory LIKE ?
+        ORDER BY time_created
+    """, (project_path, project_path + "/%")).fetchall()
+    sessions = [dict(r) for r in rows]
+
+    if not sessions:
+        rows = conn.execute("""
+            SELECT id, slug, title, directory, time_created, time_updated,
+                   agent, model, parent_id
+            FROM session
+            WHERE directory LIKE ?
+            ORDER BY time_created
+        """, (f"%{os.path.basename(project_path)}%",)).fetchall()
+        sessions = [dict(r) for r in rows]
+
+    # Find main owner session (SlopMachine agent with most parts)
+    owner_id = None
+    slop = [s for s in sessions if s.get("agent") == "SlopMachine"]
+    if slop:
+        parts_by_id = {}
+        for s in slop:
+            parts_by_id[s["id"]] = conn.execute(
+                "SELECT COUNT(*) FROM part WHERE session_id = ?", (s["id"],)
+            ).fetchone()[0]
+        owner_id = max(slop, key=lambda s: parts_by_id.get(s["id"], 0))["id"]
+
+    # Get child sessions (subagents)
+    if owner_id:
+        child_rows = conn.execute("""
+            SELECT id, slug, title, directory, time_created, time_updated,
+                   agent, model, parent_id
+            FROM session WHERE parent_id = ? ORDER BY time_created
+        """, (owner_id,)).fetchall()
+        sessions.extend(dict(r) for r in child_rows)
+
+    # Deduplicate
+    seen = set()
+    unique = []
+    for s in sessions:
+        if s["id"] not in seen:
+            seen.add(s["id"])
+            unique.append(s)
+    sessions = unique
+
+    # Add part counts and token totals
+    for s in sessions:
+        s["part_count"] = conn.execute(
+            "SELECT COUNT(*) FROM part WHERE session_id = ?", (s["id"],)
+        ).fetchone()[0]
+        row = conn.execute("""
+            SELECT SUM(json_extract(m.data, '$.tokens.input')),
+                   SUM(json_extract(m.data, '$.tokens.output'))
+            FROM message m WHERE m.session_id = ?
+        """, (s["id"],)).fetchone()
+        s["total_input_tokens"] = int(row[0] or 0)
+        s["total_output_tokens"] = int(row[1] or 0)
+        s["total_tokens"] = s["total_input_tokens"] + s["total_output_tokens"]
+
+    conn.close()
+    return sessions, owner_id
+
+
+def extract_parts(db_path, session_id):
+    """Extract all parts from a session."""
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    rows = conn.execute("""
+        SELECT id, time_created, data FROM part
+        WHERE session_id = ? ORDER BY id
+    """, (session_id,)).fetchall()
+    parts = []
+    for r in rows:
+        try:
+            d = json.loads(r["data"])
+            d["_time"] = r["time_created"]
+            d["_id"] = r["id"]
+            parts.append(d)
+        except json.JSONDecodeError:
+            pass
+    conn.close()
+    return parts
+
+
+def classify_parts(parts):
+    """Classify session parts into structured categories."""
+    result = {
+        "text_parts": [],
+        "task_launches": [],
+        "tool_calls": defaultdict(int),
+        "type_counts": defaultdict(int),
+    }
+    for p in parts:
+        ptype = p.get("type", "unknown")
+        result["type_counts"][ptype] += 1
+        if ptype == "text":
+            txt = p.get("text", "")
+            if txt.strip():
+                result["text_parts"].append({
+                    "time": ts_to_iso(p["_time"]),
+                    "text": txt,
+                })
+        elif ptype == "tool":
+            tn = p.get("tool", "?")
+            result["tool_calls"][tn] += 1
+            if tn == "task":
+                state = p.get("state", {})
+                inp = state.get("input", {})
+                outp = state.get("output", "")[:500] if state.get("output") else ""
+                result["task_launches"].append({
+                    "time": ts_to_iso(p["_time"]),
+                    "subagent_type": inp.get("subagent_type", "?"),
+                    "description": inp.get("description", "")[:300],
+                    "prompt": inp.get("prompt", "")[:1000],
+                    "result": outp,
+                })
+        elif ptype == "step-start":
+            result["type_counts"]["step_start"] = result["type_counts"].get("step_start", 0) + 1
+        elif ptype == "step-finish":
+            result["type_counts"]["step_finish"] = result["type_counts"].get("step_finish", 0) + 1
+            try:
+                snap = p.get("snapshot", "")
+                if snap:
+                    result.setdefault("snapshots", []).append(snap)
+            except Exception:
+                pass
+    return result
+
+
+def classify_session(title, agent):
+    """Classify session by type."""
+    tl = (title or "").lower()
+    ag = (agent or "").lower()
+    if ag == "slopmachine":
+        return "owner"
+    if "evaluator" in tl:
+        return "evaluator"
+    if any(kw in tl for kw in ["bugfix", "coverage reconciliation", "scaffold",
+                                "developer", "prompt orientation", "create product design"]):
+        return "developer"
+    if any(kw in tl for kw in ["clarif", "faithful", "design", "plan"]):
+        return "general_subagent"
+    if any(kw in tl for kw in ["audit", "strict audit", "strict coverage",
+                                "coverage audit", "coverage readme", "internal evaluator"]):
+        return "evaluator"
+    return "other"
+
+
+# ─── File readers ───────────────────────────────────────────────────
+
+def read_beads(project_root):
+    """Read beads history from issues.jsonl."""
+    for base in [project_root, os.path.dirname(project_root)]:
+        issues_path = os.path.join(base, ".beads", "issues.jsonl")
+        if os.path.isfile(issues_path):
+            with open(issues_path) as f:
+                return [json.loads(line) for line in f if line.strip()]
+    return []
+
+
+def read_ai_metadata(project_root):
+    """Read .ai metadata, plan, requirements, etc."""
+    for base in [project_root, os.path.dirname(project_root)]:
+        ai_dir = os.path.join(base, ".ai")
+        if os.path.isdir(ai_dir):
+            result = {}
+            meta_path = os.path.join(ai_dir, "metadata.json")
+            if os.path.isfile(meta_path):
+                with open(meta_path) as f:
+                    result["metadata"] = json.load(f)
+            for fname in sorted(os.listdir(ai_dir)):
+                fpath = os.path.join(ai_dir, fname)
+                if fname.endswith(".md") and os.path.isfile(fpath):
+                    with open(fpath) as f:
+                        result[fname] = f.read()
+            # Also read archive
+            archive_dir = os.path.join(ai_dir, "archive")
+            if os.path.isdir(archive_dir):
+                for fname in sorted(os.listdir(archive_dir)):
+                    fpath = os.path.join(archive_dir, fname)
+                    if fname.endswith(".md") and os.path.isfile(fpath):
+                        with open(fpath) as f:
+                            result[f"archive/{fname}"] = f.read()
+            return result
+    return {}
+
+
+def read_task_docs(task_dir):
+    """Read task-level docs and metadata."""
+    result = {}
+    for sub in ["docs", ""]:
+        d = os.path.join(task_dir, sub) if sub else task_dir
+        if not os.path.isdir(d):
+            continue
+        for fname in os.listdir(d):
+            if fname.endswith(".md"):
+                with open(os.path.join(d, fname)) as f:
+                    result[f"{sub}/{fname}" if sub else fname] = f.read()
+    meta = os.path.join(task_dir, "metadata.json")
+    if os.path.isfile(meta):
+        with open(meta) as f:
+            result["metadata.json"] = json.load(f)
+    return result
+
+
+def read_audit_reports(task_dir):
+    """Read .tmp audit reports."""
+    result = {}
+    tmp = os.path.join(task_dir, ".tmp")
+    if os.path.isdir(tmp):
+        for fname in sorted(os.listdir(tmp)):
+            if fname.endswith(".md"):
+                with open(os.path.join(tmp, fname)) as f:
+                    result[fname] = f.read()
+    return result
+
+
+# ─── Main ───────────────────────────────────────────────────────────
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 run.py <project_path>")
+        sys.exit(1)
+
+    project_path = os.path.abspath(sys.argv[1])
+    project_name = os.path.basename(os.path.dirname(project_path)) or os.path.basename(project_path)
+
+    db_path = os.path.expanduser("~/.local/share/opencode/opencode.db")
+    if not os.path.isfile(db_path):
+        print("ERROR: OpenCode database not found")
+        sys.exit(1)
+
+    print(f"Extracting: {project_path}")
+
+    # 1. Sessions
+    sessions, owner_id = extract_sessions(db_path, project_path)
+    print(f"  Sessions: {len(sessions)} (owner: {owner_id})")
+
+    # 2. Read artifacts
+    beads = read_beads(project_path)
+    ai_data = read_ai_metadata(project_path)
+    task_dir = project_path if os.path.isdir(os.path.join(project_path, "docs")) \
+               else os.path.join(project_path, "task")
+    task_docs = read_task_docs(task_dir)
+    audit_reports = read_audit_reports(task_dir)
+    print(f"  Beads: {len(beads)}, Audit reports: {len(audit_reports)}")
+
+    # 3. Output directory
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    sm_root = os.path.dirname(os.path.dirname(os.path.dirname(script_dir)))
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe = project_name.replace("/", "_").replace(" ", "_")
+    out_dir = os.path.join(sm_root, "retrospectives", f"{safe}_{ts}", "extraction")
+    os.makedirs(out_dir, exist_ok=True)
+
+    # 4. Write session list
+    session_list = []
+    for s in sessions:
+        session_list.append({
+            "id": s["id"], "slug": s["slug"], "title": s["title"],
+            "agent": s["agent"], "parent_id": s["parent_id"],
+            "time_created": ts_to_iso(s["time_created"]),
+            "time_updated": ts_to_iso(s["time_updated"]),
+            "part_count": s["part_count"],
+            "total_input_tokens": s["total_input_tokens"],
+            "total_output_tokens": s["total_output_tokens"],
+            "total_tokens": s["total_tokens"],
+            "session_type": classify_session(s["title"], s["agent"]),
+        })
+    with open(os.path.join(out_dir, "sessions.json"), "w") as f:
+        json.dump(session_list, f, indent=2, default=str)
+    print(f"  sessions.json ({len(session_list)} sessions)")
+
+    # 5. Write parts for each significant session
+    parts_dir = os.path.join(out_dir, "sessions")
+    os.makedirs(parts_dir, exist_ok=True)
+    for s in sessions:
+        stype = classify_session(s["title"], s["agent"])
+        if stype == "other":
+            continue
+        if s.get("part_count", 0) == 0:
+            continue
+        parts = extract_parts(db_path, s["id"])
+        classified = classify_parts(parts)
+        label = f"{stype}-{s['slug']}-{s['id'][:20]}"
+        safe_label = label.replace("/", "_").replace(" ", "_").replace(":", "_")
+        data = {
+            "session_id": s["id"],
+            "session_type": stype,
+            "title": s["title"],
+            "part_count": s["part_count"],
+            "total_input_tokens": s["total_input_tokens"],
+            "total_output_tokens": s["total_output_tokens"],
+            "type_counts": dict(classified["type_counts"]),
+            "tool_calls": dict(classified["tool_calls"]),
+            "text_count": len(classified["text_parts"]),
+            "text_parts": classified["text_parts"],
+            "task_launch_count": len(classified["task_launches"]),
+            "task_launches": classified["task_launches"],
+        }
+        with open(os.path.join(parts_dir, f"{safe_label}.json"), "w") as f:
+            json.dump(data, f, indent=2, default=str)
+
+    print(f"  sessions/ ({len(os.listdir(parts_dir))} session extracts)")
+
+    # 6. Write beads
+    with open(os.path.join(out_dir, "beads.json"), "w") as f:
+        json.dump(beads, f, indent=2, default=str)
+
+    # 7. Write AI metadata (truncate large content for inspectability)
+    ai_write = {}
+    for k, v in ai_data.items():
+        if isinstance(v, str) and len(v) > 50000:
+            ai_write[k] = v[:50000] + f"\n\n[... truncated, full {len(v)} chars]"
+        else:
+            ai_write[k] = v
+    with open(os.path.join(out_dir, "ai-metadata.json"), "w") as f:
+        json.dump(ai_write, f, indent=2, default=str)
+
+    # 8. Write task docs (truncated)
+    with open(os.path.join(out_dir, "task-docs.json"), "w") as f:
+        json.dump(task_docs, f, indent=2, default=str)
+
+    # 9. Write audit reports
+    with open(os.path.join(out_dir, "audit-reports.json"), "w") as f:
+        json.dump(audit_reports, f, indent=2, default=str)
+
+    # 10. Phase-session mapping
+    beads_map = {b["id"]: b for b in beads}
+    meta = ai_data.get("metadata", {}) if isinstance(ai_data, dict) else {}
+    phase_map = {}
+    for phase_key, bead_refs in (meta.get("beads", {}) or {}).items():
+        bead_ids = []
+        for ref in bead_refs.split(","):
+            bid = ref.strip().split(" ")[0]
+            if bid in beads_map:
+                bead_ids.append(bid)
+        if not bead_ids:
+            continue
+        pbeads = [beads_map[bid] for bid in bead_ids]
+        # Use earliest comment time as start, earliest close time as end
+        comment_times = []
+        close_times = []
+        for b in pbeads:
+            for c in b.get("comments", []):
+                ct = c.get("created_at", "")
+                if ct:
+                    comment_times.append(ct)
+            ct = b.get("closed_at") or b.get("updated_at") or ""
+            if ct:
+                close_times.append(ct)
+        phase_start = min(comment_times)[:19] if comment_times else ""
+        phase_end = min(close_times)[:19] if close_times else ""
+        phase_map[phase_key] = {
+            "start": phase_start, "end": phase_end,
+            "bead_ids": bead_ids,
+        }
+
+    phase_sessions = []
+    for s in session_list:
+        stype = s.get("session_type", "other")
+        if stype == "other":
+            continue
+        sc = s.get("time_created", "")[:19]
+        su = s.get("time_updated", "")[:19]
+        assigned = []
+        for pk, pd in phase_map.items():
+            ps = pd.get("start", "")[:19]
+            pe = pd.get("end", "")[:19]
+            if ps and pe and sc and su:
+                if sc <= pe and su >= ps:
+                    assigned.append(pk)
+        if assigned:
+            phase_sessions.append({
+                "session_id": s["id"],
+                "session_type": stype,
+                "title": s["title"],
+                "time_created": sc,
+                "time_updated": su,
+                "phases": assigned,
+            })
+
+    with open(os.path.join(out_dir, "phase-session-map.json"), "w") as f:
+        json.dump({"phases": {k: {"start": v["start"], "end": v["end"], "bead_ids": v["bead_ids"]}
+                              for k, v in phase_map.items()},
+                   "session_assignments": phase_sessions}, f, indent=2, default=str)
+    print(f"  phase-session-map.json ({len(phase_map)} phases, {len(phase_sessions)} sessions assigned)")
+
+    # 12. Write summary
+    summary = {
+        "project_path": project_path,
+        "extracted_at": datetime.now(timezone.utc).isoformat(),
+        "session_count": len(sessions),
+        "bead_count": len(beads),
+        "audit_report_count": len(audit_reports),
+        "owner_session_id": owner_id,
+        "session_types": {
+            "owner": len([s for s in session_list if s["session_type"] == "owner"]),
+            "developer": len([s for s in session_list if s["session_type"] == "developer"]),
+            "evaluator": len([s for s in session_list if s["session_type"] == "evaluator"]),
+        },
+        "total_tokens": sum(s.get("total_tokens", 0) for s in sessions),
+    }
+    with open(os.path.join(out_dir, "extraction-summary.json"), "w") as f:
+        json.dump(summary, f, indent=2, default=str)
+
+    print(f"\nExtraction complete: {out_dir}/")
+    print(f"  Summary: {summary['session_count']} sessions, {summary['bead_count']} beads, "
+          f"{summary['total_tokens']:,} tokens")
+    print(f"\nReady for analysis. Run the deep-retrospective skill analysis phase.")
+
+
+if __name__ == "__main__":
+    main()