memor-code-cli 0.2.0

package/dist/analysis/buildBranchStory.js

@@ -0,0 +1,1264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileDiffRaw = getFileDiffRaw;
+exports.getFileAtRef = getFileAtRef;
+exports.resolveMergeBase = resolveMergeBase;
+exports.buildBranchStory = buildBranchStory;
+exports.buildBranchStoryForSource = buildBranchStoryForSource;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const anthropic_1 = require("../anthropic");
+const buildFileXRay_1 = require("./buildFileXRay");
+const loadTsAliases_1 = require("../scanner/loadTsAliases");
+const detectRoutes_1 = require("../scanner/detectRoutes");
+const routeHandlers_1 = require("../scanner/routeHandlers");
+const detectOutbound_1 = require("../scanner/detectOutbound");
+const classifySilentKiller_1 = require("./classifySilentKiller");
+const simulateFailure_1 = require("./simulateFailure");
+const diffChunks_1 = require("./diffChunks");
+const CODE_EXTS = [".ts", ".tsx", ".js", ".jsx"];
+function resolveImport(source, importerAbs, repoRoot, aliases) {
+    let relative = source;
+    // Non-relative: try alias map first
+    if (!source.startsWith(".")) {
+        const fromDir = path.dirname(importerAbs);
+        const aliased = (0, loadTsAliases_1.applyAlias)(source, fromDir, aliases);
+        if (!aliased)
+            return null;
+        relative = aliased;
+    }
+    const base = path.resolve(path.dirname(importerAbs), relative);
+    const candidates = [
+        base,
+        ...CODE_EXTS.map(e => base + e),
+        ...CODE_EXTS.map(e => path.join(base, "index" + e)),
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return path.relative(repoRoot, c).replace(/\\/g, "/");
+    }
+    return null;
+}
+// Strip em/en dashes from LLM prose (they read as an "AI tell") and tidy the seams.
+// Leaves real hyphens in compound words (human-readable, test-framework-helpers) intact.
+function deDash(s) {
+    return s
+        .replace(/\s*[—–]\s*/g, ", ") // em/en dash → comma
+        .replace(/ +,/g, ",") // no space before comma
+        .replace(/,(\s*,)+/g, ",") // collapse repeated commas
+        .replace(/,\s*\./g, ".") // ", ." → "."
+        .replace(/ {2,}/g, " ") // collapse double spaces
+        .trim();
+}
+// ── Entry-point tracing ─────────────────────────────────────────────────────────
+// "When does this changed code run?" Reuses detectRoutes + the import graph: a route's
+// registration file hands off to a changed handler (it imports it); that handler — and
+// everything it pulls in among the changed files — inherits the route as its trigger.
+async function traceEntryPoints(repoRoot, changedFiles, edges, aliases) {
+    const result = new Map();
+    let routes = [];
+    try {
+        routes = await (0, detectRoutes_1.detectRoutes)(repoRoot);
+    }
+    catch {
+        return result;
+    }
+    if (routes.length === 0)
+        return result;
+    const addEp = (file, ep) => {
+        if (!result.has(file))
+            result.set(file, []);
+        const arr = result.get(file);
+        if (!arr.some(e => e.method === ep.method && e.path === ep.path))
+            arr.push(ep);
+    };
+    // Parse each route-registration file once → precise per-route handler specs + mounts.
+    const routeFiles = [...new Set(routes.map(r => r.file))];
+    const parsedByFile = new Map();
+    for (const rf of routeFiles) {
+        try {
+            parsedByFile.set(rf, (0, routeHandlers_1.parseRouteFile)(fs.readFileSync(path.join(repoRoot, rf), "utf8")));
+        }
+        catch { /* skip */ }
+    }
+    // Mount map: sub-router file → { prefix it's mounted at, file it's mounted in }. Lets us
+    // chain prefixes (app.use('/v1', router) → router.use('/executions', executionsRouter)).
+    const mountMap = new Map();
+    for (const [rf, parsed] of parsedByFile) {
+        const abs = path.join(repoRoot, rf);
+        for (const mnt of parsed.mounts) {
+            const sub = resolveImport(mnt.routerSpec, abs, repoRoot, aliases);
+            if (sub && !mountMap.has(sub))
+                mountMap.set(sub, { prefix: mnt.prefix, mountedIn: rf });
+        }
+    }
+    const composePrefix = (file) => {
+        const parts = [];
+        let cur = file;
+        const seen = new Set();
+        while (cur && mountMap.has(cur) && !seen.has(cur)) {
+            seen.add(cur);
+            const mnt = mountMap.get(cur);
+            if (mnt.prefix && mnt.prefix !== "/")
+                parts.unshift(mnt.prefix);
+            cur = mnt.mountedIn;
+        }
+        return parts.join("");
+    };
+    // Seed: map each SPECIFIC route to the SPECIFIC changed file its handler resolves to.
+    for (const [rf, parsed] of parsedByFile) {
+        const abs = path.join(repoRoot, rf);
+        const prefix = composePrefix(rf);
+        for (const route of parsed.routes) {
+            const fullPath = (prefix + (route.path === "/" ? "" : route.path)) || "/";
+            for (const spec of route.handlerSpecs) {
+                const handlerFile = resolveImport(spec, abs, repoRoot, aliases);
+                if (handlerFile && changedFiles.has(handlerFile)) {
+                    addEp(handlerFile, { method: route.method, path: fullPath, via: rf });
+                }
+            }
+        }
+    }
+    if (result.size === 0)
+        return result;
+    // Propagate down the changed-file import graph: edge {from→to} means `from` imports `to`,
+    // so `to` runs within `from`'s trigger and inherits its entry points.
+    const adj = new Map();
+    for (const e of edges) {
+        if (!adj.has(e.from))
+            adj.set(e.from, []);
+        adj.get(e.from).push(e.to);
+    }
+    let changed = true, guard = 0;
+    while (changed && guard++ < 100) {
+        changed = false;
+        for (const [from, tos] of adj) {
+            const fromEps = result.get(from);
+            if (!fromEps)
+                continue;
+            for (const to of tos) {
+                if (!changedFiles.has(to))
+                    continue;
+                for (const ep of fromEps) {
+                    const before = result.get(to)?.length ?? 0;
+                    addEp(to, ep);
+                    if ((result.get(to)?.length ?? 0) !== before)
+                        changed = true;
+                }
+            }
+        }
+    }
+    return result;
+}
+function getCommitContext(repoRoot, base) {
+    try {
+        return (0, child_process_1.execSync)(`git -C "${repoRoot}" log ${base}...HEAD --oneline`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+// When the file was last changed: working-tree edit time (mtime), else the last commit that
+// touched it on the source ref. Returns an ISO string, or undefined if unknown.
+function getLastChanged(repoRoot, file, srcRef, isWorking) {
+    if (isWorking) {
+        try {
+            return new Date(fs.statSync(path.join(repoRoot, file)).mtime).toISOString();
+        }
+        catch { /* not on disk */ }
+    }
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" log -1 --format=%aI ${srcRef || "HEAD"} -- "${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (out)
+            return out;
+    }
+    catch { /* no history */ }
+    return undefined;
+}
+function getLineStats(repoRoot, file, base, srcRef = "") {
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" diff ${base} ${srcRef} --numstat -- "${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        if (out) {
+            const p = out.split("\t");
+            return { added: parseInt(p[0]) || 0, removed: parseInt(p[1]) || 0 };
+        }
+    }
+    catch { /* fall through to untracked */ }
+    // Untracked/new file: count its lines as additions via --no-index (exits 1 → read stdout).
+    try {
+        (0, child_process_1.execSync)(`git -C "${repoRoot}" diff --no-index --numstat -- /dev/null "${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    }
+    catch (e) {
+        const out = String(e?.stdout ?? "").trim();
+        if (out) {
+            const p = out.split("\t");
+            return { added: parseInt(p[0]) || 0, removed: parseInt(p[1]) || 0 };
+        }
+    }
+    return { added: 0, removed: 0 };
+}
+function getFileDiffRaw(repoRoot, file, base, srcRef = "") {
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" diff ${base} ${srcRef} -- "${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 500_000 }).trim();
+        if (out)
+            return out;
+    }
+    catch { /* fall through to untracked */ }
+    // Untracked/new file: render full content as an additions-only diff.
+    try {
+        (0, child_process_1.execSync)(`git -C "${repoRoot}" diff --no-index --no-color -- /dev/null "${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 500_000 });
+    }
+    catch (e) {
+        return String(e?.stdout ?? "").trim();
+    }
+    return "";
+}
+// Read a file's content at a specific git ref (for before/after parsing). null if absent.
+function getFileAtRef(repoRoot, ref, file) {
+    try {
+        return (0, child_process_1.execSync)(`git -C "${repoRoot}" show ${ref}:"${file}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 2_000_000 });
+    }
+    catch {
+        return null;
+    }
+}
+function findBlastRadius(repoRoot, changedFiles, aliases) {
+    // Collect all TS/JS files outside node_modules
+    let allFiles = [];
+    try {
+        const out = (0, child_process_1.execSync)(`find "${repoRoot}" -type f \\( -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" \\) ! -path "*/node_modules/*" ! -path "*/.memor/*" ! -path "*/dist/*"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 5_000_000 }).trim();
+        allFiles = out.split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    // Build set of changed file canonical paths (no extension, for fuzzy match)
+    const changedSet = new Set();
+    for (const f of changedFiles.keys()) {
+        changedSet.add(path.join(repoRoot, f));
+    }
+    const affected = new Map();
+    for (const absPath of allFiles) {
+        const rel = path.relative(repoRoot, absPath).replace(/\\/g, "/");
+        if (changedFiles.has(rel))
+            continue; // skip files already in the PR
+        if (rel.includes("node_modules") || rel.includes(".memor") || rel.includes("/dist/"))
+            continue;
+        try {
+            const xray = (0, buildFileXRay_1.buildFileXRay)(absPath, repoRoot);
+            for (const imp of xray.imports) {
+                if (imp.isType)
+                    continue;
+                const resolved = resolveImport(imp.source, absPath, repoRoot, aliases);
+                if (!resolved)
+                    continue;
+                const absResolved = path.join(repoRoot, resolved);
+                if (changedSet.has(absResolved)) {
+                    if (!affected.has(rel))
+                        affected.set(rel, []);
+                    if (!affected.get(rel).includes(resolved))
+                        affected.get(rel).push(resolved);
+                }
+            }
+        }
+        catch { /* malformed file — skip */ }
+    }
+    return [...affected.entries()].map(([file, importedFiles]) => ({
+        file,
+        importedFiles,
+        category: classifyBlastFile(file),
+    }));
+}
+function classifyBlastFile(file) {
+    const lower = file.toLowerCase();
+    // HTTP handler: route/controller files or files that export HTTP-named functions
+    if (/\/(routes?|controllers?|handlers?|endpoints?)\//.test(lower) ||
+        /\.(route|controller|handler)\.(ts|js|tsx|jsx)$/.test(lower))
+        return "handler";
+    // Service/persistence: data access layer
+    if (/\/(services?|persistence|repositories?|repos?|dao|store)\//.test(lower) ||
+        /\.(service|persistence|repository|repo)\.(ts|js|tsx|jsx)$/.test(lower))
+        return "service";
+    return "transitive";
+}
+async function generatePRSummary(nodes, apiKey) {
+    const client = (0, anthropic_1.createAnthropicClient)(apiKey);
+    const summaries = nodes
+        .filter(n => n.status !== "context" && n.summary)
+        .map(n => `• ${n.file}: ${n.summary}`)
+        .join("\n");
+    if (!summaries)
+        return "";
+    try {
+        const msg = await client.messages.create({
+            model: "claude-haiku-4-5-20251001",
+            max_tokens: 50,
+            messages: [{ role: "user", content: `PR file changes:\n${summaries}\n\nIn ONE sentence (max 12 words), what does this PR add or fix?\nRespond with ONLY the sentence.` }],
+        });
+        return msg.content[0].type === "text" ? msg.content[0].text.trim() : "";
+    }
+    catch {
+        return "";
+    }
+}
+async function generateFileSummaries(repoRoot, base, changedFiles, apiKey, nodes, blastRadius, am, entryPoints, outboundByFile, srcRef = "") {
+    const client = (0, anthropic_1.createAnthropicClient)(apiKey);
+    const commitContext = getCommitContext(repoRoot, base);
+    const results = new Map();
+    // Persistent cache: hash(file + diff) → { role, summary }. Same diff → same brief,
+    // regenerated only when the diff changes (deterministic-by-memoization).
+    const cachePath = path.join(repoRoot, ".memor", "summary-cache.json");
+    let briefCache = {};
+    try {
+        const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+        // Only keep entries in the new {role,summary} shape; ignore legacy string entries.
+        for (const [k, v] of Object.entries(raw))
+            if (v && typeof v === "object" && "summary" in v)
+                briefCache[k] = v;
+    }
+    catch { /* no cache yet */ }
+    let cacheDirty = false;
+    // Bump when the brief prompt below changes, so stale cached briefs are regenerated.
+    const BRIEF_PROMPT_VERSION = "v12-hunks";
+    // Entry points + outbound destinations are part of the prompt context → belong in the cache key.
+    const epSig = (file) => (entryPoints.get(file) ?? []).map(e => `${e.method} ${e.path}`).join(",");
+    const obSig = (file) => (outboundByFile.get(file) ?? []).map(o => `${o.method} ${o.path}`).join(",");
+    const cacheKey = (file, diff) => crypto.createHash("sha1").update(`${BRIEF_PROMPT_VERSION}\n${epSig(file)}\n${obSig(file)}\n${file}\n${diff}`).digest("hex");
+    // Grounded context: which system it's in + who depends on it.
+    const buildContext = (file) => {
+        const lines = [];
+        const node = nodes.find(n => n.file === file);
+        const sys = node?.systemId ? (am?.systems ?? []).find((s) => s.id === node.systemId) : undefined;
+        if (sys)
+            lines.push(`System: ${sys.name ?? sys.id}${sys.description ? ` — ${String(sys.description).slice(0, 160)}` : ""}`);
+        const surface = node ? (node.exports?.length ? node.exports : node.functions) ?? [] : [];
+        if (surface.length > 0)
+            lines.push(`Exports/functions: ${surface.slice(0, 10).join(", ")}`);
+        const eps = entryPoints.get(file);
+        if (eps && eps.length)
+            lines.push(`Reached from (entry point): ${eps.slice(0, 3).map(e => `${e.method} ${e.path}`).join(", ")} — this code runs when those endpoint(s) are called. Use this to say WHEN the change takes effect.`);
+        const obs = outboundByFile.get(file);
+        if (obs && obs.length)
+            lines.push(`Sends to (outbound HTTP call in this file): ${obs.slice(0, 4).map(o => `${o.method} ${o.path}`.trim()).join(", ")} — this file makes those calls. Use this to say WHERE the data is sent.`);
+        return lines.join("\n");
+    };
+    await Promise.all([...changedFiles.entries()]
+        .filter(([, status]) => status !== "deleted")
+        .map(async ([file, status]) => {
+        const diff = getFileDiffRaw(repoRoot, file, base, srcRef);
+        if (!diff && status === "modified")
+            return;
+        const key = cacheKey(file, diff ?? `__new__:${status}`);
+        if (briefCache[key]) {
+            const cached = briefCache[key];
+            if (!cached.changePoints?.length && cached.summary && diff) {
+                cached.changePoints = (0, diffChunks_1.resolveChangePoints)(cached.summary.split("\n").filter(Boolean), diff);
+            }
+            results.set(file, cached);
+            return;
+        }
+        const diffLines = diff ? diff.split("\n") : [];
+        const linesAdded = diffLines.filter(l => l.startsWith("+") && !l.startsWith("+++")).length;
+        const linesRemoved = diffLines.filter(l => l.startsWith("-") && !l.startsWith("---")).length;
+        const fileContext = buildContext(file);
+        const diffHunks = diff ? (0, diffChunks_1.parseDiffHunks)(diff) : [];
+        const hunksBlock = diff ? (0, diffChunks_1.formatHunksForPrompt)(diffHunks) : "(new file — no diff available)";
+        const prompt = `You are helping a developer understand a code change they did not write.
+
+Changed file: ${file} (${status}) — ${linesAdded > 0 || linesRemoved > 0 ? `+${linesAdded}/-${linesRemoved} lines` : "new file"}
+${fileContext ? `\n<context>\n${fileContext}\n</context>` : ""}
+<diff_hunks>
+${hunksBlock}
+</diff_hunks>
+
+Output EXACTLY this format and nothing else:
+ROLE: <what this file does in the codebase — one terse line, derived from its exports/functions, NOT from the change>
+CHANGE:
+- <one concrete point about what the change does> [hunk:N]
+- <another point, if any> [hunk:N]
+
+Rules for the CHANGE bullets:
+- ONE bullet for a simple/small change; up to 4 for a complex one. Do not pad — fewer, denser bullets beat many thin ones.
+- Each bullet MUST end with [hunk:N] where N is the Hunk number from <diff_hunks> that best supports that bullet. Use a DIFFERENT hunk when bullets describe different parts of the change. If only Hunk 0 exists, use [hunk:0].
+- Each bullet is a concrete fact in plain language: what it adds / reads / writes / calls, the trigger (when it runs), or for replaced code the before → after (the "-" lines ARE the old behaviour).
+- For a brand-new file there is no "before" — describe only what it adds, never invent a prior state.
+- If the diff has comments that state intent, USE them. Avoid bare jargon like "synchronization"/"persistence" unless you say what it concretely means.
+- If the change is config/deps/test-only with no product-behaviour effect, ONE bullet saying exactly that.
+
+Ground every claim in <diff_hunks> and <context>. Never invent. Plain words, no markdown headers.`;
+        try {
+            const msg = await client.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 400,
+                temperature: 0,
+                system: "You explain an unfamiliar code change to a developer in plain language. ROLE = what the file is; CHANGE = what the change does and why it matters (its effect/behaviour), grounded only in the numbered diff hunks and context. Each CHANGE bullet MUST end with [hunk:N] citing the hunk it comes from. When code is replaced or removed, explain the before → after delta — what the previous behaviour was and how it changed — not just the new lines; but never invent a 'before' for a brand-new file. Avoid jargon like 'synchronization'/'persistence' unless you say what it concretely means. Be honest: if a change is scaffolding (config, deps, CI, tests) with no product-behaviour effect, say so. Never use em-dashes or en-dashes (— or –); use commas, periods, or parentheses. Output only the ROLE: and CHANGE: lines. No markdown, no backticks.",
+                messages: [{ role: "user", content: prompt }],
+            });
+            const text = msg.content[0].type === "text" ? msg.content[0].text.trim() : "";
+            if (text) {
+                const lines = text.split("\n").map(l => l.trim());
+                const roleLine = (lines.find(l => /^role:/i.test(l)) ?? "").replace(/^role:\s*/i, "").trim();
+                // CHANGE is now a block of bullets after the "CHANGE:" marker.
+                const changeIdx = lines.findIndex(l => /^change:/i.test(l));
+                const bullets = [];
+                if (changeIdx >= 0) {
+                    const inline = lines[changeIdx].replace(/^change:\s*/i, "").replace(/^[-•*]\s*/, "").trim();
+                    if (inline)
+                        bullets.push(inline);
+                    for (let i = changeIdx + 1; i < lines.length; i++) {
+                        const l = lines[i];
+                        if (!l || /^role:/i.test(l)) {
+                            if (/^role:/i.test(l))
+                                break;
+                            else
+                                continue;
+                        }
+                        bullets.push(l.replace(/^[-•*]\s*/, "").trim());
+                    }
+                }
+                const cleaned = bullets.map(b => b.trim()).filter(Boolean);
+                const changePoints = (0, diffChunks_1.resolveChangePoints)(cleaned, diff ?? "");
+                const summaryText = changePoints.map(p => p.text).join("\n");
+                const brief = {
+                    role: roleLine,
+                    summary: summaryText || text,
+                    changePoints: changePoints.length ? changePoints : undefined,
+                };
+                results.set(file, brief);
+                briefCache[key] = brief;
+                cacheDirty = true;
+            }
+        }
+        catch { /* non-fatal */ }
+    }));
+    // Persist briefs so they stay stable across runs.
+    if (cacheDirty) {
+        try {
+            fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+            fs.writeFileSync(cachePath, JSON.stringify(briefCache, null, 2));
+        }
+        catch { /* best-effort */ }
+    }
+    return results;
+}
+// ── Thread clustering — group the changeset into distinct threads of work ──────
+// Deterministic inputs (briefs, import adjacency, systems, churn) → one LLM pass
+// that names, classifies, narrates and ranks the threads. Cached per changeset.
+async function generateChangeThreads(repoRoot, nodes, edges, apiKey, entryPoints, repoOutbound) {
+    const changed = nodes.filter(n => n.status !== "context");
+    if (changed.length === 0)
+        return [];
+    if (changed.length === 1) {
+        const f = changed[0];
+        return [{ id: "t0", title: f.file.split("/").pop() ?? f.file, type: "other", summary: f.summary ?? f.role ?? "", files: [f.file] }];
+    }
+    // Import adjacency among changed files only
+    const changedSet = new Set(changed.map(n => n.file));
+    const importsWithin = new Map();
+    for (const e of edges) {
+        if (changedSet.has(e.from) && changedSet.has(e.to)) {
+            if (!importsWithin.has(e.from))
+                importsWithin.set(e.from, []);
+            importsWithin.get(e.from).push(e.to.split("/").pop() ?? e.to);
+        }
+    }
+    // Compact, grounded representation of the changeset
+    const fileLines = changed.map(n => {
+        const churn = (n.linesAdded ?? 0) + (n.linesRemoved ?? 0);
+        const imp = importsWithin.get(n.file);
+        const eps = entryPoints.get(n.file);
+        return [
+            `${n.file} [${n.status}${churn ? `, ±${churn}` : ""}${n.systemId ? `, sys:${n.systemId}` : ""}]`,
+            n.role ? `  role: ${n.role}` : "",
+            n.summary ? `  change: ${(n.summary).split("\n").join("; ")}` : "",
+            imp && imp.length ? `  imports-in-change: ${imp.join(", ")}` : "",
+            eps && eps.length ? `  entry-point: ${eps.slice(0, 3).map(e => `${e.method} ${e.path}`).join(", ")}` : "",
+        ].filter(Boolean).join("\n");
+    }).join("\n\n");
+    // Cache by the shape of the changeset (paths + statuses + summaries). Bump the
+    // version token when the prompt below changes, to invalidate stale changesets.
+    const THREADS_PROMPT_VERSION = "v7-nodash";
+    const cachePath = path.join(repoRoot, ".memor", "threads-cache.json");
+    const sig = crypto.createHash("sha1").update(THREADS_PROMPT_VERSION + "|" + changed.map(n => `${n.file}:${n.status}:${n.summary ?? ""}`).sort().join("|")).digest("hex");
+    try {
+        const cached = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+        if (cached.sig === sig && Array.isArray(cached.threads))
+            return cached.threads;
+    }
+    catch { /* no cache */ }
+    const prompt = `Document the changes in a WORKING DIRECTORY — uncommitted, mid-flight. A working directory often holds SEVERAL UNRELATED CHANGESETS at once (it is NOT one clean PR). A "changeset" = a group of files whose CHANGES serve one intent.
+
+The goal is COMPREHENSION, not bookkeeping. Do two things:
+
+1) GROUP the files into changesets by the INTENT OF THEIR CHANGES — what THIS diff is building or doing. CRITICAL: group by what each file's CHANGE does, NOT by what the file permanently is.
+   - Files whose changes COLLABORATE toward one goal belong together even if they don't import each other (e.g. a new backend endpoint + the frontend change that calls it, even with no static import between them).
+   - BUT a file whose ACTUAL CHANGE is trivial or unrelated — a stray comment, a formatting tweak, a config bump — must NOT be pulled into a feature changeset just because the file normally supports that feature. Place it by what its CHANGE does (its own changeset, refactor, housekeeping, or scratch), even if the file is part of the feature's machinery.
+
+2) For each changeset, write a "summary" as an ARRAY of short BULLETS. Do NOT concatenate raw file changes. DECLARATIVE, IMPERSONAL voice — describe the change itself, like API documentation. NEVER write "The developer", "You", "They", "is building", or narrate a person. NEVER use the word "thread" — say "change" or "changeset".
+   - First bullet = the INTENT as a BEHAVIOURAL statement: what the system can now DO that it could not before, in plain language (e.g. "When an execution is posted, the server now updates the test catalog if the test's path or name changed — so renamed tests stay current without a manual edit"). State the EFFECT, not the mechanism; avoid bare jargon like "synchronization"/"persistence".
+   - Each following bullet = ONE file's role in the change, as "<file> <verb> <what>" (e.g. "server.ts exposes /api/commit-log", "App.tsx renders the change view"). Only include a file's bullet if its change is substantive — do NOT invent a role for a trivial change.
+   2–4 bullets total. Terse, concrete, naming the moving parts.
+
+Changeset types: feature (new capability) · fix (bug fix) · refactor (restructure, no behaviour change) · housekeeping (config, .gitignore, deps, generated/cache files, formatting, AND real committed unit/integration test suites — supporting work with no product-behaviour change) · scratch (only genuinely throwaway/demo/experimental files that look disposable — NEVER real committed tests).
+
+${repoOutbound.length ? `OUTBOUND — this repo sends data over HTTP to: ${repoOutbound.map(o => `${o.method} ${o.path}`.trim()).join(", ")}. If the changed code's output clearly flows to one of these, ANCHOR the intent with WHERE it goes (e.g. "registers test executions to the server at POST /v1/executions/batch"). Never claim a destination you cannot connect to the change.\n\n` : ""}Changed files (path, status, system, role = what the file does, change = what changed, imports-in-change = which other changed files it statically imports, entry-point = the HTTP route/trigger this code is reached from — use it to state WHEN the change runs, e.g. "when an execution is posted"):
+${fileLines}
+
+Rules:
+- EVERY file in exactly one changeset.
+- Group by the CHANGE, not the file's permanent role. A trivial change to a feature's file is its OWN small changeset, not part of the feature.
+- The TITLE names the INTENT (e.g. "Email verification on signup", "Rate limiting for the public API"), not the changes, and NEVER contains the word "thread".
+- Rank changesets by importance: the main body of real source work FIRST, housekeeping/scratch LAST.
+- HONESTY: for housekeeping/config/CI/deps changesets, the FIRST bullet must plainly state there is NO product behaviour change (e.g. "Test/build scaffolding only — no change to product behaviour"). Never imply behaviour where there is none. If a change's intent is genuinely unclear from the diff, say what it touches rather than inventing a purpose.
+
+Output JSON only, no prose:
+{"changesets":[{"title":"<the intent, short>","type":"feature|fix|refactor|housekeeping|scratch","summary":["<intent bullet>","<file role bullet>","<file role bullet>"],"files":["<path>", ...]}]}`;
+    try {
+        const client = (0, anthropic_1.createAnthropicClient)(apiKey);
+        const msg = await client.messages.create({
+            model: "claude-haiku-4-5-20251001",
+            max_tokens: 1400,
+            temperature: 0,
+            system: "You document a working directory's changes for an engineer. Group files into CHANGESETS by the intent of their CHANGES, not by what each file permanently is — a trivial change to a feature's file is its own small changeset, not part of the feature. Synthesize each changeset as terse declarative bullets. Never list raw per-file changes, never narrate a person ('the developer', 'you'), and never use the word 'thread' (say 'change'/'changeset'). Never use em-dashes or en-dashes (— or –); use commas, periods, or parentheses. Output ONLY valid JSON matching the requested schema, no markdown, no commentary.",
+            messages: [{ role: "user", content: prompt }],
+        });
+        const raw = msg.content[0].type === "text" ? msg.content[0].text.trim() : "{}";
+        const clean = raw.replace(/^```json?\s*/i, "").replace(/```\s*$/, "").trim();
+        const parsed = JSON.parse(clean);
+        const rawSets = parsed.changesets ?? parsed.threads ?? [];
+        const threads = rawSets.map((t, i) => ({
+            id: `t${i}`,
+            title: t.title || "Untitled",
+            type: (["feature", "fix", "refactor", "housekeeping", "scratch", "other"].includes(t.type ?? "") ? t.type : "other"),
+            // summary is an array of bullets → store as \n-joined lines (frontend splits on \n)
+            summary: Array.isArray(t.summary)
+                ? t.summary.map(s => String(s).trim().replace(/^[-•*]\s*/, "")).filter(Boolean).join("\n")
+                : String(t.summary ?? ""),
+            files: (t.files ?? []).filter(f => changedSet.has(f)),
+        }));
+        // Safety net: every changed file must appear somewhere.
+        const placed = new Set(threads.flatMap(t => t.files));
+        const orphans = changed.map(n => n.file).filter(f => !placed.has(f));
+        if (orphans.length > 0)
+            threads.push({ id: `t${threads.length}`, title: "Other changes", type: "other", summary: "", files: orphans });
+        try {
+            fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+            fs.writeFileSync(cachePath, JSON.stringify({ sig, threads }, null, 2));
+        }
+        catch { /* best-effort */ }
+        return threads.filter(t => t.files.length > 0);
+    }
+    catch {
+        // Fallback: one thread per file, ungrouped.
+        return changed.map((n, i) => ({ id: `t${i}`, title: n.file.split("/").pop() ?? n.file, type: "other", summary: n.summary ?? "", files: [n.file] }));
+    }
+}
+function parseNameStatus(raw) {
+    const result = new Map();
+    for (const line of raw.trim().split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const s = parts[0][0];
+        const file = parts[parts.length - 1];
+        result.set(file, s === "A" ? "added" : s === "D" ? "deleted" : "modified");
+    }
+    return result;
+}
+function gitDiff(repoRoot, ref, srcRef = "") {
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" diff ${ref} ${srcRef} --name-status`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        const m = parseNameStatus(out);
+        return m.size > 0 ? m : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Resolve a base ref to the MERGE-BASE with HEAD — the point the branch diverged.
+// Diffing against this (not the base's tip) shows only the branch's OWN work, the
+// way a PR diff does, instead of treating the base's later commits as "reversions"
+// when the branch is behind. Returns null if it can't be resolved.
+// Resolve a source branch name to a real ref. Prefers the remote-tracking ref
+// (origin/<name>) over the local branch — the local branch may be stale or point to
+// a different commit than what was pushed (e.g. after a force-push or rebase).
+// This matches what the forge (GitHub/GitLab) shows for the same branch.
+// HEAD / explicit SHAs / already-prefixed refs are left as-is.
+function resolveRef(repoRoot, name) {
+    if (/^(HEAD|origin\/)/.test(name) || /[~^]/.test(name) || /^[0-9a-f]{7,40}$/.test(name))
+        return name;
+    for (const cand of [`origin/${name}`, name]) {
+        try {
+            (0, child_process_1.execSync)(`git -C "${repoRoot}" rev-parse --verify ${cand}`, { stdio: "pipe" });
+            return cand;
+        }
+        catch { }
+    }
+    return name;
+}
+// For the comparison TARGET, PREFER the remote ref (origin/<name>) over a possibly-stale
+// local branch — so "vs main" means the real integration state (matches the forge's PR view,
+// immune to a stale local main). HEAD / HEAD~N / SHAs / explicit origin refs are left as-is.
+function resolveTargetRef(repoRoot, name) {
+    if (/^(HEAD|origin\/)/.test(name) || /[~^]/.test(name) || /^[0-9a-f]{7,40}$/.test(name))
+        return name;
+    for (const cand of [`origin/${name}`, name]) {
+        try {
+            (0, child_process_1.execSync)(`git -C "${repoRoot}" rev-parse --verify ${cand}`, { stdio: "pipe" });
+            return cand;
+        }
+        catch { }
+    }
+    return name;
+}
+// Merge-base of two arbitrary refs (for Source=branch vs Target=branch, no HEAD assumption).
+function mergeBaseOf(repoRoot, a, b) {
+    try {
+        const mb = (0, child_process_1.execSync)(`git -C "${repoRoot}" merge-base ${a} ${b}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        return mb || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveMergeBase(repoRoot, ref) {
+    try {
+        const mb = (0, child_process_1.execSync)(`git -C "${repoRoot}" merge-base ${ref} HEAD`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        return mb || null;
+    }
+    catch {
+        return null;
+    }
+}
+// How far the SOURCE (tip) is ahead of / behind the target — surfaces staleness AND
+// tells you a branch is "even with main" (0 ahead) so an empty diff reads as informative,
+// not broken. `tip` is HEAD for the working tree, or the source branch otherwise.
+function getBranchState(repoRoot, ref, tip = "HEAD") {
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" rev-list --left-right --count ${ref}...${tip}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        const [behind, ahead] = out.split(/\s+/).map(n => parseInt(n, 10)); // left=target-only (behind), right=tip-only (ahead)
+        if (Number.isNaN(ahead) || Number.isNaN(behind))
+            return null;
+        return { ahead, behind };
+    }
+    catch {
+        return null;
+    }
+}
+// Untracked files (respecting .gitignore) — so new, not-yet-added files still appear.
+function getUntrackedFiles(repoRoot) {
+    try {
+        const out = (0, child_process_1.execSync)(`git -C "${repoRoot}" ls-files --others --exclude-standard`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+        return out ? out.split("\n").map(s => s.trim()).filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function mapFileToSystem(relFile, am) {
+    if (!am?.systems)
+        return undefined;
+    // Strategy 1: exact key_file match
+    for (const sys of am.systems) {
+        for (const kf of (sys.key_files ?? [])) {
+            if (relFile === kf)
+                return sys.id;
+        }
+    }
+    // Strategy 2: file lives inside a deep (depth≥2) key_file directory
+    for (const sys of am.systems) {
+        for (const kf of (sys.key_files ?? [])) {
+            const kfDir = kf.replace(/\/[^/]+$/, "");
+            const depth = kfDir.split("/").filter(Boolean).length;
+            if (depth >= 2 && relFile.startsWith(kfDir + "/"))
+                return sys.id;
+        }
+    }
+    // Strategy 3: path-segment token overlap with system id
+    const skip = new Set(["app", "api", "src", "pages", "route", "index", "lib", "utils", "helpers"]);
+    const fileSegs = relFile.replace(/\.(ts|tsx|js|jsx)$/, "").split("/")
+        .filter(s => s && !skip.has(s) && !s.startsWith("[") && !s.startsWith("("));
+    let bestSys;
+    let bestScore = 0;
+    for (const sys of am.systems) {
+        const sysTokens = sys.id.split("-").filter((t) => t.length > 2);
+        let score = 0;
+        for (const t of sysTokens) {
+            if (fileSegs.some(s => s.toLowerCase().includes(t) || t.includes(s.toLowerCase())))
+                score++;
+        }
+        if (score > 0 && score >= sysTokens.length - 1 && score > bestScore) {
+            bestScore = score;
+            bestSys = sys.id;
+        }
+    }
+    if (bestSys)
+        return bestSys;
+    // Strategy 4: nearest ancestor directory that contains any key_file of a system.
+    // Build a map: directory → system id (deepest key_file dir wins for specificity).
+    const dirToSys = new Map();
+    for (const sys of am.systems) {
+        for (const kf of (sys.key_files ?? [])) {
+            const dir = kf.includes("/") ? kf.replace(/\/[^/]+$/, "") : "";
+            if (!dir)
+                continue;
+            const depth = dir.split("/").filter(Boolean).length;
+            const existing = dirToSys.get(dir);
+            if (!existing || depth > existing.depth) {
+                dirToSys.set(dir, { sysId: sys.id, depth });
+            }
+        }
+    }
+    // Walk up from the file's directory toward root, first match wins
+    let dir = relFile.includes("/") ? relFile.replace(/\/[^/]+$/, "") : "";
+    while (dir) {
+        const match = dirToSys.get(dir);
+        if (match && match.depth >= 2)
+            return match.sysId;
+        const parent = dir.includes("/") ? dir.replace(/\/[^/]+$/, "") : "";
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+// Extract bare import sources from raw file text (no AST needed — regex is fine for this)
+function extractImportSources(src) {
+    const re = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(src)) !== null)
+        out.push(m[1]);
+    return out;
+}
+function getBaseFileContent(repoRoot, file, base) {
+    try {
+        return (0, child_process_1.execSync)(`git -C "${repoRoot}" show ${base}:${file}`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 500_000 });
+    }
+    catch {
+        return "";
+    }
+}
+// Resolve a bare import source to a repo-relative path without the filesystem
+// (the base content may not be checked out, so we can't use fs.existsSync)
+function resolveImportFuzzy(source, importerFile, aliases) {
+    if (source.startsWith(".")) {
+        const dir = path.dirname(importerFile);
+        const joined = path.join(dir, source).replace(/\\/g, "/");
+        // strip extension if present, normalise
+        return joined.replace(/\.(ts|tsx|js|jsx)$/, "");
+    }
+    // Try alias map
+    const fromDir = path.dirname(path.join("/", importerFile)); // fake abs for applyAlias
+    const aliased = (0, loadTsAliases_1.applyAlias)(source, fromDir, aliases);
+    if (aliased)
+        return aliased.replace(/\.(ts|tsx|js|jsx)$/, "");
+    return null;
+}
+function computeSystemEdgeDelta(repoRoot, base, changedFiles, fileData, aliases, am) {
+    if (!am?.systems)
+        return [];
+    const deltas = [];
+    const seen = new Set();
+    for (const [file, status] of changedFiles) {
+        // Added files create the most important new cross-system edges (a new handler that
+        // first wires the handler layer to persistence/DTOs). Their base content is empty, so
+        // every import reads as "added". Deleted files symmetrically yield "removed" edges.
+        // Only non-code files (no resolvable imports) are no-ops, handled naturally below.
+        const fromSys = mapFileToSystem(file, am);
+        if (!fromSys)
+            continue;
+        // Use fuzzy resolution for BOTH sides to avoid false positives from
+        // filesystem-vs-regex resolution asymmetry (resolveImport vs resolveImportFuzzy)
+        const mapSources = (sources) => {
+            const sys = new Set();
+            for (const src of sources) {
+                const resolved = resolveImportFuzzy(src, file, aliases);
+                if (!resolved)
+                    continue;
+                const id = mapFileToSystem(resolved + ".ts", am)
+                    ?? mapFileToSystem(resolved + ".tsx", am)
+                    ?? mapFileToSystem(resolved, am);
+                if (id)
+                    sys.add(id);
+            }
+            return sys;
+        };
+        const currentContent = (() => { try {
+            return fs.readFileSync(path.join(repoRoot, file), "utf8");
+        }
+        catch {
+            return "";
+        } })();
+        const currentSystems = mapSources(extractImportSources(currentContent));
+        const baseContent = getBaseFileContent(repoRoot, file, base);
+        const baseSystems = mapSources(extractImportSources(baseContent));
+        // New edges: in current but not in base
+        for (const toSys of currentSystems) {
+            if (toSys === fromSys)
+                continue;
+            if (!baseSystems.has(toSys)) {
+                const key = `added:${fromSys}→${toSys}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    deltas.push({ from: fromSys, to: toSys, kind: "added" });
+                }
+            }
+        }
+        // Removed edges: in base but not in current
+        for (const toSys of baseSystems) {
+            if (toSys === fromSys)
+                continue;
+            if (!currentSystems.has(toSys)) {
+                const key = `removed:${fromSys}→${toSys}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    deltas.push({ from: fromSys, to: toSys, kind: "removed" });
+                }
+            }
+        }
+    }
+    return deltas;
+}
+async function buildBranchStory(repoRoot, base = "main", apiKey, am, source = "working") {
+    const displayBase = base;
+    base = resolveTargetRef(repoRoot, base); // prefer origin/<branch> over a stale local target
+    const resolvedTarget = base; // capture before merge-base overwrites `base`
+    // SOURCE = what we inspect. "working" = current working tree + HEAD (full fidelity, fs reads
+    // are valid). A branch ref = that branch's committed work (Tier 1: diff + change summaries only;
+    // fs-dependent features — XRay/blast/entry-points — are gated because the branch isn't checked out).
+    const isWorking = !source || source === "working";
+    // Resolve the source to a concrete ref (local branch, else origin/<branch> for a peer's PR).
+    const srcResolved = isWorking ? "HEAD" : resolveRef(repoRoot, source);
+    const srcRef = isWorking ? "" : srcResolved;
+    const fidelity = isWorking ? "full" : "diff-only";
+    // Diff against the MERGE-BASE (PR-style) so we see only Source's own work, not the base's
+    // later commits. For working tree that's merge-base(target, HEAD); for a branch, merge-base(target, branch).
+    const mb = isWorking ? resolveMergeBase(repoRoot, base) : mergeBaseOf(repoRoot, base, srcResolved);
+    if (mb)
+        base = mb;
+    // For working tree: git diff <merge-base> includes uncommitted changes. For a branch: diff the branch tip.
+    let changedFiles = gitDiff(repoRoot, base, srcRef);
+    const scope = "session";
+    if (!changedFiles || changedFiles.size === 0) {
+        const mbMaster = isWorking ? resolveMergeBase(repoRoot, "master") : mergeBaseOf(repoRoot, "master", srcResolved);
+        changedFiles = gitDiff(repoRoot, mbMaster ?? "master", srcRef);
+    }
+    // Untracked files only exist for the working tree (a branch ref has no working state).
+    if (isWorking) {
+        const untracked = getUntrackedFiles(repoRoot).filter(f => !f.includes(".memor/") && !f.startsWith(".memor"));
+        if (untracked.length > 0) {
+            changedFiles = changedFiles ?? new Map();
+            for (const f of untracked)
+                if (!changedFiles.has(f))
+                    changedFiles.set(f, "added");
+        }
+    }
+    const branchState = getBranchState(repoRoot, resolvedTarget, srcResolved) ?? undefined;
+    if (!changedFiles || changedFiles.size === 0) {
+        return { base: displayBase, scope, nodes: [], edges: [], summary: { added: 0, modified: 0, deleted: 0 }, blastRadius: [], systemEdgeDelta: [], branchState, baseSha: mb, source, fidelity };
+    }
+    // Load TS path aliases once for the repo
+    const aliases = await (0, loadTsAliases_1.loadTsAliases)(repoRoot);
+    const fileData = new Map();
+    for (const [file, status] of changedFiles) {
+        const abs = path.join(repoRoot, file);
+        const data = { status, exports: [], functions: [], lineCount: 0, resolvedImports: [] };
+        if (isWorking && status !== "deleted" && fs.existsSync(abs)) {
+            try {
+                const xray = (0, buildFileXRay_1.buildFileXRay)(abs, repoRoot);
+                data.exports = xray.exports.filter(e => !e.isType).map(e => e.name);
+                data.functions = xray.functions.map(f => f.name);
+                data.lineCount = xray.lineCount;
+                for (const imp of xray.imports) {
+                    if (imp.isType)
+                        continue;
+                    const resolved = resolveImport(imp.source, abs, repoRoot, aliases);
+                    if (resolved)
+                        data.resolvedImports.push({ path: resolved, names: imp.names ?? [], defaultName: imp.defaultName });
+                }
+            }
+            catch { }
+        }
+        fileData.set(file, data);
+    }
+    // ── Pass 2: Collect context files ────────────────────────────────────────────
+    // Only include context nodes imported by ADDED files (keeps graph focused on what's new)
+    const contextFiles = new Set();
+    for (const [, data] of fileData) {
+        if (data.status !== "added")
+            continue; // only fan out from new code
+        for (const imp of data.resolvedImports) {
+            if (!changedFiles.has(imp.path)) {
+                const abs = path.join(repoRoot, imp.path);
+                if (fs.existsSync(abs))
+                    contextFiles.add(imp.path);
+            }
+        }
+    }
+    // ── Build nodes ──────────────────────────────────────────────────────────────
+    const nodes = [];
+    for (const [file, data] of fileData) {
+        const ext = path.extname(file);
+        nodes.push({
+            id: file, file,
+            name: path.basename(file, ext),
+            ext, status: data.status,
+            exports: data.exports,
+            functions: data.functions,
+            lineCount: data.lineCount,
+            systemId: mapFileToSystem(file, am),
+        });
+    }
+    for (const file of contextFiles) {
+        const abs = path.join(repoRoot, file);
+        const ext = path.extname(file);
+        let exports = [], functions = [], lineCount = 0;
+        try {
+            const xray = (0, buildFileXRay_1.buildFileXRay)(abs, repoRoot);
+            exports = xray.exports.filter(e => !e.isType).map(e => e.name);
+            functions = xray.functions.map(f => f.name);
+            lineCount = xray.lineCount;
+        }
+        catch { }
+        nodes.push({
+            id: file, file, name: path.basename(file, ext),
+            ext, status: "context",
+            exports, functions, lineCount,
+            systemId: mapFileToSystem(file, am),
+        });
+    }
+    // ── Build edges ───────────────────────────────────────────────────────────────
+    const allNodeIds = new Set(nodes.map(n => n.id));
+    const edgeSeen = new Set();
+    const edges = [];
+    for (const [file, data] of fileData) {
+        for (const imp of data.resolvedImports) {
+            if (!allNodeIds.has(imp.path))
+                continue;
+            const key = `${file}→${imp.path}`;
+            if (edgeSeen.has(key))
+                continue;
+            edgeSeen.add(key);
+            const allNames = [...(imp.names ?? []).filter(n => n.length > 0)];
+            if (imp.defaultName)
+                allNames.unshift(imp.defaultName);
+            const label = allNames.length === 0 ? undefined
+                : allNames.length <= 3 ? allNames.join(", ")
+                    : `${allNames.slice(0, 2).join(", ")} +${allNames.length - 2}`;
+            edges.push({ from: file, to: imp.path, label });
+        }
+    }
+    // ── Line stats for changed files ────────────────────────────────────────────
+    for (const node of nodes) {
+        if (node.status !== "context" && node.status !== "deleted") {
+            const stats = getLineStats(repoRoot, node.file, base, srcRef);
+            node.linesAdded = stats.added;
+            node.linesRemoved = stats.removed;
+            node.lastChanged = getLastChanged(repoRoot, node.file, srcRef, isWorking);
+        }
+    }
+    // ── Blast radius + system edges: whole-tree fs analysis — valid only for the checked-out
+    //    working tree. For a non-current branch (diff-only fidelity) these are gated. ───────
+    const blastRadius = isWorking ? findBlastRadius(repoRoot, changedFiles, aliases) : [];
+    const systemEdgeDelta = isWorking ? computeSystemEdgeDelta(repoRoot, base, changedFiles, fileData, aliases, am) : [];
+    // ── Trace entry points (when does each change run?) — grounds the narration ──
+    const rawEntryPoints = (isWorking && apiKey)
+        ? await traceEntryPoints(repoRoot, new Set(changedFiles.keys()), edges, aliases)
+        : new Map();
+    if (process.env.MEMOR_DEBUG_EP)
+        console.error("[ENTRY POINTS]", JSON.stringify([...rawEntryPoints].map(([f, e]) => [f.split("/").pop(), e.map(x => `${x.method} ${x.path}`)]), null, 0));
+    // The import-proxy tracer over-assigns routes (it can't tell which route calls which handler,
+    // nor which mount prefix applies). Gate it OUT of the narration until call-site precision lands —
+    // we never feed a wrong trigger to the model. Flip EP_PRECISE once the precise resolver is in.
+    const EP_PRECISE = true; // precise Babel call-site resolver verified on test-coverage-ui
+    const entryPoints = EP_PRECISE ? rawEntryPoints : new Map();
+    // ── Trace outbound destinations (where does the changed code SEND data?) ──────
+    // The mirror of entry points: for a producer repo, "where it sends" is the orienting fact.
+    const outboundByFile = new Map();
+    const repoOutbound = [];
+    if (isWorking && apiKey) {
+        for (const f of changedFiles.keys()) {
+            if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f))
+                continue;
+            let src = "";
+            try {
+                src = fs.readFileSync(path.join(repoRoot, f), "utf8");
+            }
+            catch {
+                continue;
+            }
+            const calls = (0, detectOutbound_1.detectOutboundInSource)(src);
+            if (calls.length) {
+                outboundByFile.set(f, calls);
+                for (const c of calls)
+                    if (!repoOutbound.some(o => o.method === c.method && o.path === c.path))
+                        repoOutbound.push(c);
+            }
+        }
+    }
+    // ── Attach grounding facts to each node (deterministic — shown before the narration) ──
+    // These are static-graph derived, so they're instant and never fabricated: the unfakeable
+    // layer the right pane leads with, narration layers on top.
+    for (const node of nodes) {
+        const eps = entryPoints.get(node.file);
+        if (eps && eps.length)
+            node.entryPoints = eps;
+        const obs = outboundByFile.get(node.file);
+        if (obs && obs.length)
+            node.outbound = obs;
+        // Blast = the inverse of blastRadius: every file that imports THIS changed file.
+        const importers = blastRadius.filter(b => b.importedFiles.includes(node.file));
+        if (importers.length) {
+            node.blast = {
+                total: importers.length,
+                handlers: importers.filter(b => b.category === "handler").length,
+                services: importers.filter(b => b.category === "service").length,
+                transitive: importers.filter(b => b.category === "transitive").length,
+                files: importers.map(b => b.file),
+            };
+        }
+        // Silent Killer: runtime/infra risk the code graph can't see (deterministic, diff-aware).
+        // Works for any source (just needs the diff), so it runs in PR-review mode too.
+        if (node.status !== "context" && (0, classifySilentKiller_1.isRiskCandidate)(node.file)) {
+            let risk = null;
+            if (node.file.split("/").pop() === "package.json") {
+                // package.json gets precise block/type-aware parsing (prod vs dev vs @types).
+                const readJson = (txt) => { try {
+                    return txt ? JSON.parse(txt) : null;
+                }
+                catch {
+                    return null;
+                } };
+                const before = readJson(getFileAtRef(repoRoot, base, node.file));
+                const afterTxt = isWorking
+                    ? (() => { try {
+                        return fs.readFileSync(path.join(repoRoot, node.file), "utf8");
+                    }
+                    catch {
+                        return null;
+                    } })()
+                    : getFileAtRef(repoRoot, srcRef || source || "HEAD", node.file);
+                const after = readJson(afterTxt);
+                risk = (before || after) ? (0, classifySilentKiller_1.analyzePackageJson)(before ?? {}, after ?? {}) : (0, classifySilentKiller_1.classifySilentKiller)(node.file, getFileDiffRaw(repoRoot, node.file, base, srcRef));
+            }
+            else {
+                risk = (0, classifySilentKiller_1.classifySilentKiller)(node.file, getFileDiffRaw(repoRoot, node.file, base, srcRef));
+            }
+            if (risk)
+                node.risk = risk;
+        }
+    }
+    // ── Simulate a Failure: evidence-chain pre-mortem (deterministic, no LLM) ──────
+    // Risk as a CHAIN across files + architecture — catches what file-level flags miss
+    // (the @types bump that crashes a runtime schema generator on the prod startup path).
+    let failureReport;
+    try {
+        const changedForSim = nodes.filter(n => n.status !== "context").map(n => ({ file: n.file, status: n.status }));
+        const pkgNode = changedForSim.find(c => c.file.split("/").pop() === "package.json");
+        const rd = (t) => { try {
+            return t ? JSON.parse(t) : null;
+        }
+        catch {
+            return null;
+        } };
+        let pkgBefore = null, pkgAfter = null;
+        if (pkgNode) {
+            pkgBefore = rd(getFileAtRef(repoRoot, base, pkgNode.file));
+            pkgAfter = isWorking
+                ? rd((() => { try {
+                    return fs.readFileSync(path.join(repoRoot, pkgNode.file), "utf8");
+                }
+                catch {
+                    return null;
+                } })())
+                : rd(getFileAtRef(repoRoot, srcRef || source || "HEAD", pkgNode.file));
+        }
+        failureReport = (0, simulateFailure_1.runSimulateFailure)({
+            repoRoot, changed: changedForSim, pkgBefore, pkgAfter,
+            getDiff: (f) => getFileDiffRaw(repoRoot, f, base, srcRef),
+            readSource: (f) => isWorking
+                ? (() => { try {
+                    return fs.readFileSync(path.join(repoRoot, f), "utf8");
+                }
+                catch {
+                    return null;
+                } })()
+                : getFileAtRef(repoRoot, srcRef || source || "HEAD", f),
+        });
+        // Escalate the triggering file's badge to the finding severity so the file card reflects the chain.
+        for (const f of failureReport.findings) {
+            const triggerFile = f.evidence[0]?.file;
+            const node = triggerFile ? nodes.find(n => n.file === triggerFile) : undefined;
+            if (node && (!node.risk || (node.risk.tier !== "critical" && f.severity === "critical"))) {
+                node.risk = { tier: f.severity, silentKiller: true, dimension: "runtime",
+                    reason: `${f.title}. ${f.ciBlindSpot ?? ""}`.trim(), signals: [f.patternId] };
+            }
+        }
+    }
+    catch {
+        failureReport = undefined;
+    }
+    // ── LLM narration (narrate-only): tighten the deterministic pre-mortem prose. ──
+    // The model may restate evidence facts; it must NEVER invent a file, cause, or severity.
+    // Guardrail: reject any rewrite that mentions a file not already in the evidence chain.
+    if (apiKey && failureReport && failureReport.findings.length) {
+        try {
+            const client = (0, anthropic_1.createAnthropicClient)(apiKey);
+            const payload = failureReport.findings.map((f, idx) => ({ idx, title: f.title, severity: f.severity, failureMode: f.failureMode, narrative: f.narrative, evidence: f.evidence.map(e => ({ file: e.file, line: e.line, detail: e.detail })), questions: f.questions }));
+            const msg = await client.messages.create({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 900,
+                system: "You rewrite deterministic pre-mortem findings into crisp prose for an engineer about to merge. You may ONLY restate facts already present in each finding's narrative and evidence. NEVER introduce a file, cause, or severity that is not already there. No em-dashes or en-dashes. Each narrative <= 55 words, concrete and direct. Output ONLY valid JSON.",
+                messages: [{ role: "user", content: `Findings:\n${JSON.stringify(payload)}\n\nFor each finding, rewrite "narrative" and optionally tighten "questions" (keep <= 2). Return ONLY JSON: {"findings":[{"idx":0,"narrative":"...","questions":["..."]}]}` }],
+            });
+            const text = msg.content.filter(b => b.type === "text").map(b => b.text).join("");
+            const parsed = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+            const allFiles = new Set(failureReport.findings.flatMap(f => f.evidence.map(e => e.file.split("/").pop())));
+            for (const r of parsed.findings ?? []) {
+                const f = failureReport.findings[r.idx];
+                if (!f || typeof r.narrative !== "string")
+                    continue;
+                const badFile = (r.narrative.match(/[\w./-]+\.(ts|tsx|js|cjs|json|yml|yaml)/g) || []).some((m) => !allFiles.has(m.split("/").pop()));
+                if (badFile)
+                    continue; // hallucinated a file → keep deterministic narrative
+                f.narrative = deDash(r.narrative.trim());
+                if (Array.isArray(r.questions) && r.questions.length)
+                    f.questions = r.questions.slice(0, 2).map((q) => deDash(String(q)));
+            }
+        }
+        catch { /* keep deterministic narrative */ }
+    }
+    // ── Generate LLM summaries for changed files ─────────────────────────────────
+    let prSummary;
+    if (apiKey) {
+        const summaries = await generateFileSummaries(repoRoot, base, changedFiles, apiKey, nodes, blastRadius, am, entryPoints, outboundByFile, srcRef);
+        for (const node of nodes) {
+            const s = summaries.get(node.file);
+            if (s) {
+                node.summary = s.summary;
+                node.role = s.role;
+                if (s.changePoints?.length)
+                    node.changePoints = s.changePoints;
+            }
+        }
+        prSummary = await generatePRSummary(nodes, apiKey);
+    }
+    // ── Cluster the changeset into threads of work ──────────────────────────────
+    // PAUSED: changeset grouping is intentionally off (files-first UX). Flip to re-enable.
+    // Skipping it also drops one LLM call per analysis → faster.
+    const ENABLE_THREADS = false;
+    let threads;
+    if (ENABLE_THREADS && apiKey) {
+        threads = await generateChangeThreads(repoRoot, nodes, edges, apiKey, entryPoints, repoOutbound);
+    }
+    // ── Strip em/en dashes from ALL narration (the "AI tell") — the deterministic guarantee ──
+    for (const n of nodes) {
+        if (n.summary)
+            n.summary = n.summary.split("\n").map(deDash).filter(Boolean).join("\n");
+        if (n.role)
+            n.role = deDash(n.role);
+        if (n.changePoints) {
+            n.changePoints = n.changePoints.map(p => ({ ...p, text: deDash(p.text) }));
+        }
+    }
+    if (threads)
+        for (const t of threads) {
+            t.title = deDash(t.title);
+            if (t.summary)
+                t.summary = t.summary.split("\n").map(deDash).filter(Boolean).join("\n");
+        }
+    if (prSummary)
+        prSummary = deDash(prSummary);
+    const vals = [...changedFiles.values()];
+    return {
+        base: displayBase, scope, nodes, edges,
+        summary: {
+            added: vals.filter(s => s === "added").length,
+            modified: vals.filter(s => s === "modified").length,
+            deleted: vals.filter(s => s === "deleted").length,
+        },
+        blastRadius,
+        systemEdgeDelta,
+        prSummary,
+        threads,
+        branchState,
+        baseSha: mb,
+        source,
+        fidelity,
+        failureReport,
+    };
+}
+/**
+ * Public entry point. For the working tree, runs the normal full analysis. For a Source that is a
+ * BRANCH (peer PR review), checks the branch out into an ISOLATED git worktree (a temp dir that
+ * never touches the user's working tree), runs the full analysis there — so blast radius and the
+ * deep import-graph analysis work without checkout friction — then tears the worktree down.
+ * Falls back to diff-only on the main repo if the worktree can't be created.
+ */
+async function buildBranchStoryForSource(repoRoot, base = "main", apiKey, am, source = "working") {
+    const isWorking = !source || source === "working";
+    if (isWorking)
+        return buildBranchStory(repoRoot, base, apiKey, am, source);
+    const ref = resolveRef(repoRoot, source); // local branch, else origin/<branch>
+    const wt = path.join(os.tmpdir(), `memor-wt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    try {
+        // --detach checks out the ref's commit without claiming the branch (works for origin/<x> too).
+        (0, child_process_1.execSync)(`git -C "${repoRoot}" worktree add --detach "${wt}" ${ref}`, { stdio: ["pipe", "pipe", "pipe"], timeout: 90000 });
+        // In the worktree the branch IS the working tree → run the normal full-fidelity path.
+        const story = await buildBranchStory(wt, base, apiKey, am, "working");
+        story.source = source; // reflect the branch under review (worktree HEAD is detached)
+        return story;
+    }
+    catch {
+        // Worktree unavailable (missing ref, git too old, disk) → honest diff-only on the main repo.
+        return buildBranchStory(repoRoot, base, apiKey, am, source);
+    }
+    finally {
+        try {
+            (0, child_process_1.execSync)(`git -C "${repoRoot}" worktree remove --force "${wt}"`, { stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch { }
+        try {
+            (0, child_process_1.execSync)(`git -C "${repoRoot}" worktree prune`, { stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=buildBranchStory.js.map