gitmem-mcp 0.2.0 → 1.0.1

package/dist/tools/session-close.js

@@ -12,12 +12,16 @@ import * as supabase from "../services/supabase-client.js";
 import { embed, isEmbeddingAvailable } from "../services/embedding.js";
 import { hasSupabase } from "../services/tier.js";
 import { getStorage } from "../services/storage.js";
-import { clearCurrentSession, getSurfacedScars, getObservations, getChildren, getThreads, getSessionActivity } from "../services/session-state.js"; // OD-547, OD-552, v2 Phase 2
-import { normalizeThreads, mergeThreadStates, migrateStringThread } from "../services/thread-manager.js"; // OD-thread-lifecycle
+import { clearCurrentSession, getSurfacedScars, getConfirmations, getObservations, getChildren, getThreads, getSessionActivity } from "../services/session-state.js"; // OD-547, OD-552, v2 Phase 2
+import { normalizeThreads, mergeThreadStates, migrateStringThread, saveThreadsFile } from "../services/thread-manager.js"; // OD-thread-lifecycle
+import { deduplicateThreadList } from "../services/thread-dedup.js"; // OD-641
 import { syncThreadsToSupabase, loadOpenThreadEmbeddings } from "../services/thread-supabase.js"; // OD-624
 import { validateSessionClose, buildCloseCompliance, } from "../services/compliance-validator.js";
+import { normalizeReflectionKeys } from "../constants/closing-questions.js";
 import { Timer, recordMetrics, buildPerformanceData, updateRelevanceData, } from "../services/metrics.js";
+import { wrapDisplay, truncate } from "../services/display-protocol.js";
 import { recordScarUsageBatch } from "./record-scar-usage-batch.js";
+import { getEffectTracker } from "../services/effect-tracker.js";
 import { saveTranscript } from "./save-transcript.js";
 import { processTranscript } from "../services/transcript-chunker.js";
 import * as fs from "fs";
@@ -26,6 +30,28 @@ import * as os from "os";
 import { getGitmemPath, getGitmemDir, getSessionPath } from "../services/gitmem-dir.js";
 import { unregisterSession, findSessionByHostPid } from "../services/active-sessions.js";
 import { loadSuggestions, saveSuggestions, detectSuggestedThreads, loadRecentSessionEmbeddings } from "../services/thread-suggestions.js";
+/**
+ * Normalize scars_applied to string[].
+ * Handles both string (prose answer from agents) and string[] (schema-correct array).
+ * When agents write Q6 as prose, splits on common delimiters.
+ */
+function normalizeScarsApplied(scarsApplied) {
+    if (!scarsApplied)
+        return [];
+    if (Array.isArray(scarsApplied))
+        return scarsApplied;
+    const trimmed = scarsApplied.trim();
+    if (!trimmed)
+        return [];
+    const parts = trimmed.split(/(?:\.\s+|\;\s*|\s+—\s+)/).filter(p => p.trim().length > 0);
+    return parts.length > 0 ? parts : [trimmed];
+}
+/**
+ * Count scars applied from closing_reflection.scars_applied.
+ */
+function countScarsApplied(scarsApplied) {
+    return normalizeScarsApplied(scarsApplied).length;
+}
 /**
  * Find the most recently modified transcript file in Claude Code projects directory
  * OD-538: Search by recency, not by filename matching (supports post-compaction)
@@ -121,7 +147,7 @@ async function sessionCloseFree(params, timer) {
         questions_answered_by_agent: !!params.closing_reflection,
         human_asked_for_corrections: !!params.human_corrections || params.human_corrections === "",
         learnings_stored: learningsCount,
-        scars_applied: params.closing_reflection?.scars_applied?.length || 0,
+        scars_applied: countScarsApplied(params.closing_reflection?.scars_applied),
     };
     try {
         // Load existing session if available
@@ -146,8 +172,8 @@ async function sessionCloseFree(params, timer) {
         if (params.open_threads && params.open_threads.length > 0) {
             const normalized = normalizeThreads(params.open_threads, params.session_id);
             const merged = freeSessionThreads.length > 0
-                ? mergeThreadStates(normalized, freeSessionThreads)
-                : normalized;
+                ? deduplicateThreadList(mergeThreadStates(normalized, freeSessionThreads))
+                : deduplicateThreadList(normalized);
             sessionData.open_threads = merged;
         }
         else if (freeSessionThreads.length > 0) {
@@ -210,66 +236,110 @@ async function sessionCloseFree(params, timer) {
         };
     }
 }
-/**
- * Build a pre-formatted display string for consistent CLI output.
- * Agents echo this string directly instead of formatting ad-hoc.
- */
-function formatCloseDisplay(sessionId, compliance, params, learningsCount, success, errors) {
+function formatCloseDisplay(sessionId, compliance, params, learningsCount, success, errors, transcriptStatus) {
     const lines = [];
-    if (!success) {
-        lines.push("**Session close FAILED.**");
-        if (errors?.length) {
-            for (const e of errors)
-                lines.push(`- Error: ${e}`);
-        }
-        lines.push("");
-    }
     // Header
+    const B = "\x1b[1m"; // bold on
+    const D = "\x1b[2m"; // dim on
+    const R = "\x1b[0m"; // reset
     const closeLabel = compliance.close_type.toUpperCase();
-    lines.push(`## ${closeLabel} CLOSE — ${success ? "COMPLETE" : "FAILED"}`);
-    lines.push(`**Session:** \`${sessionId.slice(0, 8)}\` | **Agent:** ${compliance.agent}`);
-    // Checklist
-    const check = (ok) => ok ? "done" : "missing";
+    const status = success ? "COMPLETE" : "FAILED";
+    lines.push(`${B}${closeLabel} CLOSE — ${status}${R}`);
+    lines.push(`Session ${sessionId.slice(0, 8)} · ${compliance.agent}`);
+    if (!success && errors?.length) {
+        lines.push("");
+        for (const e of errors)
+            lines.push(`  !! ${e}`);
+    }
+    // Checklist (compact)
     lines.push("");
-    lines.push(`### Checklist`);
+    const ok = "\u2713";
+    const no = "\u2717";
     if (compliance.close_type === "standard") {
-        lines.push(`- [${check(compliance.checklist_displayed)}] Read active-session.json`);
-        lines.push(`- [${check(compliance.questions_answered_by_agent)}] Agent answered 7 questions`);
-        lines.push(`- [${check(compliance.human_asked_for_corrections)}] Human asked for corrections`);
-        lines.push(`- [${check(learningsCount > 0)}] Created learning entries (${learningsCount})`);
-        lines.push(`- [${check(compliance.scars_applied > 0)}] Recorded scar usage (${compliance.scars_applied})`);
-        lines.push(`- [${check(success)}] Session persisted`);
+        lines.push(`  ${ok} Session state read`);
+        lines.push(`  ${compliance.questions_answered_by_agent ? ok : no} Reflection (9 questions)`);
+        lines.push(`  ${compliance.human_asked_for_corrections ? ok : no} Human corrections`);
+        lines.push(`  ${success ? ok : no} Persisted`);
     }
     else {
-        lines.push(`- [${check(success)}] Session persisted`);
-        lines.push(`- Agent: ${compliance.agent} | Close type: ${compliance.close_type}`);
+        lines.push(`  ${success ? ok : no} Persisted (${compliance.close_type})`);
+    }
+    // Decisions table
+    if (params.decisions?.length) {
+        lines.push("");
+        lines.push(`${B}Decisions${R}`);
+        for (const d of params.decisions) {
+            lines.push(`  ${truncate(d.title, 60)}`);
+            lines.push(`    ${truncate(d.decision, 70)}`);
+        }
+    }
+    // Learnings created
+    if (params.learnings_created?.length) {
+        lines.push("");
+        lines.push(`${B}Learnings (${params.learnings_created.length})${R}`);
+        for (const l of params.learnings_created) {
+            // learnings_created is (string | Record)[] — show truncated ID or object key
+            const label = typeof l === "string" ? (l.length > 12 ? l.slice(0, 8) : l) : String(l);
+            lines.push(`  ${label}`);
+        }
+    }
+    // Scars applied
+    if (params.scars_to_record?.length) {
+        const acknowledged = params.scars_to_record.filter(s => s.reference_type !== "none");
+        const ignored = params.scars_to_record.length - acknowledged.length;
+        lines.push("");
+        lines.push(`${B}Scars (${acknowledged.length} applied${ignored > 0 ? `, ${ignored} surfaced-only` : ""})${R}`);
+        for (const s of acknowledged) {
+            const ref = s.reference_type === "explicit" ? "applied" :
+                s.reference_type === "implicit" ? "implicit" :
+                    s.reference_type === "acknowledged" ? "ack'd" :
+                        s.reference_type === "refuted" ? "REFUTED" : s.reference_type;
+            const id = s.scar_identifier.length > 12 ? s.scar_identifier.slice(0, 8) : s.scar_identifier;
+            lines.push(`  ${id}  ${ref.padEnd(8)}  ${truncate(s.reference_context, 50)}`);
+        }
+    }
+    // Transcript status
+    if (transcriptStatus) {
+        lines.push("");
+        lines.push(`### Transcript`);
+        if (transcriptStatus.saved) {
+            let line = `- [done] Saved (${transcriptStatus.size_kb}KB) -> ${transcriptStatus.path}`;
+            if (transcriptStatus.patch_warning) {
+                line += ` (warning: session record not updated)`;
+            }
+            lines.push(line);
+        }
+        else {
+            lines.push(`- [FAILED] ${transcriptStatus.error || "Unknown error"}`);
+        }
     }
     // Threads summary
     const threads = params.open_threads || [];
     if (threads.length > 0) {
-        const openCount = threads.filter(t => {
-            if (typeof t === "string")
-                return true;
-            return t.status === "open";
-        }).length;
+        const openCount = threads.filter(t => typeof t === "string" || t.status === "open").length;
         const resolvedCount = threads.length - openCount;
         lines.push("");
-        lines.push(`### Threads`);
-        lines.push(`${openCount} open, ${resolvedCount} resolved, ${threads.length} total`);
+        lines.push(`${B}Threads${R}: ${openCount} open${resolvedCount > 0 ? `, ${resolvedCount} resolved` : ""}`);
     }
-    // Decisions
-    if (params.decisions?.length) {
+    // Write health (compact)
+    const healthSummary = getEffectTracker().formatSummary();
+    if (healthSummary && healthSummary !== "No tracked effects this session.") {
         lines.push("");
-        lines.push(`### Decisions`);
-        lines.push(`${params.decisions.length} captured`);
+        lines.push(`${B}Write Health${R}`);
+        lines.push(healthSummary);
     }
-    // Learnings
-    if (learningsCount > 0) {
-        lines.push("");
-        lines.push(`### Learnings`);
-        lines.push(`${learningsCount} created`);
+    // Reflection highlights (Q4 what worked, Q3 do differently)
+    if (params.closing_reflection) {
+        const r = params.closing_reflection;
+        if (r.what_worked) {
+            lines.push("");
+            lines.push(`${B}What worked${R}: ${truncate(r.what_worked, 80)}`);
+        }
+        if (r.do_differently) {
+            lines.push(`${B}Next time${R}: ${truncate(r.do_differently, 80)}`);
+        }
     }
-    return lines.join("\n");
+    return wrapDisplay(lines.join("\n"));
 }
 /**
  * GIT-21: Clean up all session files for a closed session.
@@ -296,12 +366,339 @@ function cleanupSessionFiles(sessionId) {
     }
     // Legacy active-session.json cleanup removed — file is no longer written
 }
+// UUID and short-ID format validation for session_id (OD-548)
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const SHORT_ID_REGEX = /^[0-9a-f]{8}$/i;
+function isValidSessionId(id) {
+    return UUID_REGEX.test(id) || SHORT_ID_REGEX.test(id);
+}
+/**
+ * Build the session data record from params and existing session state.
+ * Handles retroactive vs normal mode, reflection, decisions, threads,
+ * observations, children, linear_issue, and title updates.
+ */
+function buildSessionRecord(params, existingSession, isRetroactive, agentIdentity, closeCompliance, sessionId) {
+    let sessionData;
+    if (isRetroactive) {
+        const now = new Date().toISOString();
+        sessionData = {
+            id: sessionId,
+            agent: agentIdentity,
+            project: "default",
+            session_title: "Retroactive Session",
+            session_date: now,
+            created_at: now,
+            close_compliance: closeCompliance,
+        };
+    }
+    else {
+        // Remove embedding from existing to avoid re-embedding unchanged text
+        const { embedding: _embedding, ...existingWithoutEmbedding } = existingSession;
+        sessionData = {
+            ...existingWithoutEmbedding,
+            close_compliance: closeCompliance,
+        };
+    }
+    // Add closing reflection if provided
+    if (params.closing_reflection) {
+        const reflection = { ...params.closing_reflection };
+        if (params.human_corrections) {
+            reflection.human_additions = params.human_corrections;
+        }
+        sessionData.closing_reflection = reflection;
+        // OD-666: Distill Q8+Q9 into rapport_summary for cross-agent surfacing
+        const q8 = params.closing_reflection.collaborative_dynamic;
+        const q9 = params.closing_reflection.rapport_notes;
+        if (q8 || q9) {
+            const parts = [q8, q9].filter(Boolean);
+            sessionData.rapport_summary = parts.join(" | ");
+        }
+    }
+    // Add decisions if provided
+    if (params.decisions && params.decisions.length > 0) {
+        sessionData.decisions = params.decisions.map((d) => d.title);
+    }
+    // OD-thread-lifecycle: Normalize and merge open threads
+    const sessionThreads = getThreads();
+    if (params.open_threads && params.open_threads.length > 0) {
+        const normalized = normalizeThreads(params.open_threads, params.session_id);
+        const merged = sessionThreads.length > 0
+            ? deduplicateThreadList(mergeThreadStates(normalized, sessionThreads))
+            : deduplicateThreadList(normalized);
+        sessionData.open_threads = merged;
+    }
+    else if (sessionThreads.length > 0) {
+        sessionData.open_threads = sessionThreads;
+    }
+    // OD-534: If project_state provided, prepend it to open_threads as a ThreadObject
+    if (params.project_state) {
+        const projectStateText = `PROJECT STATE: ${params.project_state}`;
+        const existing = (sessionData.open_threads || []);
+        const filtered = existing.filter(t => {
+            const text = typeof t === "string" ? t : t.text;
+            return !text.startsWith("PROJECT STATE:");
+        });
+        sessionData.open_threads = [migrateStringThread(projectStateText, params.session_id), ...filtered];
+    }
+    // v2 Phase 2: Persist observations and children from multi-agent work
+    const observations = getObservations();
+    if (observations.length > 0) {
+        sessionData.task_observations = observations;
+    }
+    const sessionChildren = getChildren();
+    if (sessionChildren.length > 0) {
+        sessionData.children = sessionChildren;
+    }
+    // Add linear issue if provided
+    if (params.linear_issue) {
+        sessionData.linear_issue = params.linear_issue;
+    }
+    // Update session title if we have meaningful content
+    if (params.closing_reflection?.what_worked || params.decisions?.length) {
+        const titleParts = [];
+        if (params.linear_issue) {
+            titleParts.push(params.linear_issue);
+        }
+        if (params.decisions?.length) {
+            titleParts.push(params.decisions[0].title);
+        }
+        else if (params.closing_reflection?.what_worked) {
+            titleParts.push(params.closing_reflection.what_worked.slice(0, 50));
+        }
+        if (titleParts.length > 0 &&
+            (sessionData.session_title === "Interactive Session" ||
+                sessionData.session_title === "Retroactive Session")) {
+            sessionData.session_title = titleParts.join(" - ");
+        }
+    }
+    return sessionData;
+}
+/**
+ * Capture and save the conversation transcript for a session.
+ * Returns transcript status and optionally the Claude Code session ID.
+ */
+async function captureSessionTranscript(sessionId, params, existingSession, isRetroactive) {
+    try {
+        let transcriptFilePath = null;
+        // Option 1: Explicit transcript path provided
+        if (params.transcript_path) {
+            if (fs.existsSync(params.transcript_path)) {
+                transcriptFilePath = params.transcript_path;
+                console.error(`[session_close] Using explicit transcript path: ${transcriptFilePath}`);
+            }
+            else {
+                console.warn(`[session_close] Explicit transcript path does not exist: ${params.transcript_path}`);
+            }
+        }
+        // Option 2: Auto-detect by searching for most recent transcript
+        if (!transcriptFilePath) {
+            const homeDir = os.homedir();
+            const projectsDir = path.join(homeDir, ".claude", "projects");
+            const cwd = process.cwd();
+            const projectDirName = path.basename(cwd);
+            transcriptFilePath = findMostRecentTranscript(projectsDir, projectDirName, cwd);
+            if (transcriptFilePath) {
+                console.error(`[session_close] Auto-detected transcript: ${transcriptFilePath}`);
+            }
+            else {
+                console.error(`[session_close] No transcript file found in ${projectsDir}`);
+            }
+        }
+        if (!transcriptFilePath)
+            return {};
+        const transcriptContent = fs.readFileSync(transcriptFilePath, "utf-8");
+        // Extract Claude Code session ID for traceability (sync, fast)
+        const claudeSessionId = extractClaudeSessionId(transcriptContent, transcriptFilePath) || undefined;
+        if (claudeSessionId) {
+            console.error(`[session_close] Extracted Claude session ID: ${claudeSessionId}`);
+        }
+        // Deterministic transcript save — await to guarantee persistence
+        const transcriptProject = isRetroactive ? "default" : existingSession?.project;
+        const saveResult = await saveTranscript({
+            session_id: sessionId,
+            transcript: transcriptContent,
+            format: "json",
+            project: transcriptProject,
+        });
+        if (saveResult.success && saveResult.transcript_path) {
+            const status = {
+                saved: true,
+                path: saveResult.transcript_path,
+                size_kb: saveResult.size_kb,
+                patch_warning: saveResult.patch_warning,
+            };
+            console.error(`[session_close] Transcript saved: ${saveResult.transcript_path} (${saveResult.size_kb}KB)`);
+            // OD-540: Process transcript for semantic search (fire-and-forget — chunking is expensive)
+            processTranscript(sessionId, transcriptContent, transcriptProject)
+                .then(result => {
+                if (result.success) {
+                    console.error(`[session_close] Transcript chunking completed: ${result.chunksCreated} chunks created`);
+                }
+                else {
+                    console.warn(`[session_close] Transcript chunking failed: ${result.error}`);
+                }
+            }).catch(err => {
+                console.error("[session_close] Transcript chunking error:", err);
+            });
+            return { status, claudeSessionId };
+        }
+        else {
+            console.warn(`[session_close] Failed to save transcript: ${saveResult.error}`);
+            return {
+                status: { saved: false, error: saveResult.error || "Unknown save error" },
+                claudeSessionId,
+            };
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error("[session_close] Exception during transcript capture:", msg);
+        return {
+            status: { saved: false, error: `Exception during transcript capture: ${msg}` },
+        };
+    }
+}
+/**
+ * Map confirmation decisions to scar_usage reference_type.
+ * APPLYING = explicit compliance, N_A = acknowledged but not applicable, REFUTED = overridden.
+ */
+function decisionToRefType(decision) {
+    switch (decision) {
+        case "APPLYING": return "explicit";
+        case "N_A": return "acknowledged";
+        case "REFUTED": return "refuted";
+        default: return "acknowledged";
+    }
+}
+/**
+ * Auto-bridge Q6 answers (closing_reflection.scars_applied) to scar_usage records.
+ * Uses three-pass matching:
+ *   1. Structured confirmations from confirm_scars (preferred, includes variant_id)
+ *   2. Q6 text matching for scars without confirmations (fallback)
+ *   3. Unmatched surfaced scars recorded as "none"
+ * Returns empty array if no surfaced scars available.
+ */
+function bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdentity) {
+    try {
+        // Load surfaced scars: prefer in-memory, fall back to per-session dir, then legacy file
+        let surfacedScars = getSurfacedScars();
+        if (surfacedScars.length === 0 && sessionId) {
+            // GIT-21: Try per-session directory first
+            try {
+                const sessionFilePath = getSessionPath(sessionId, "session.json");
+                if (fs.existsSync(sessionFilePath)) {
+                    const fileData = JSON.parse(fs.readFileSync(sessionFilePath, "utf-8"));
+                    if (fileData.surfaced_scars && Array.isArray(fileData.surfaced_scars)) {
+                        surfacedScars = fileData.surfaced_scars;
+                        console.error(`[session_close] Loaded ${surfacedScars.length} surfaced scars from per-session file`);
+                    }
+                }
+            }
+            catch { /* per-session file read failed */ }
+        }
+        if (surfacedScars.length === 0) {
+            console.error("[session_close] No surfaced scars available for auto-bridge");
+            return [];
+        }
+        const autoBridgedScars = [];
+        const matchedScarIds = new Set();
+        // Load structured confirmations from confirm_scars (preferred source)
+        const confirmations = getConfirmations();
+        const confirmationMap = new Map();
+        for (const conf of confirmations) {
+            confirmationMap.set(conf.scar_id, conf);
+        }
+        // First pass: match surfaced scars against structured confirmations
+        for (const scar of surfacedScars) {
+            const confirmation = confirmationMap.get(scar.scar_id);
+            if (confirmation) {
+                matchedScarIds.add(scar.scar_id);
+                autoBridgedScars.push({
+                    scar_identifier: scar.scar_id,
+                    session_id: sessionId,
+                    agent: agentIdentity,
+                    surfaced_at: scar.surfaced_at,
+                    reference_type: decisionToRefType(confirmation.decision),
+                    reference_context: `Confirmed via confirm_scars: ${confirmation.decision} — ${confirmation.evidence.slice(0, 100)}`,
+                    variant_id: scar.variant_id,
+                });
+            }
+        }
+        // Second pass: fallback to Q6 text matching for scars without confirmations
+        for (const scarApplied of normalizedScarsApplied) {
+            const lowerApplied = scarApplied.toLowerCase();
+            const match = surfacedScars.find((s) => {
+                if (matchedScarIds.has(s.scar_id))
+                    return false;
+                return (s.scar_id === scarApplied ||
+                    s.scar_title.toLowerCase().includes(lowerApplied) ||
+                    lowerApplied.includes(s.scar_title.toLowerCase()));
+            });
+            if (match) {
+                matchedScarIds.add(match.scar_id);
+                autoBridgedScars.push({
+                    scar_identifier: match.scar_id,
+                    session_id: sessionId,
+                    agent: agentIdentity,
+                    surfaced_at: match.surfaced_at,
+                    reference_type: "acknowledged",
+                    reference_context: `Auto-bridged from Q6 answer: "${scarApplied}"`,
+                    variant_id: match.variant_id,
+                });
+            }
+        }
+        // For surfaced scars NOT matched by either method, record as "none"
+        for (const scar of surfacedScars) {
+            if (!matchedScarIds.has(scar.scar_id)) {
+                autoBridgedScars.push({
+                    scar_identifier: scar.scar_id,
+                    session_id: sessionId,
+                    agent: agentIdentity,
+                    surfaced_at: scar.surfaced_at,
+                    reference_type: "none",
+                    reference_context: `Surfaced during ${scar.source} but not mentioned in closing reflection`,
+                    variant_id: scar.variant_id,
+                });
+            }
+        }
+        if (autoBridgedScars.length > 0) {
+            console.error(`[session_close] Auto-bridged ${autoBridgedScars.length} scar usage records (${matchedScarIds.size} acknowledged, ${autoBridgedScars.length - matchedScarIds.size} unmentioned)`);
+        }
+        return autoBridgedScars;
+    }
+    catch (bridgeError) {
+        console.error("[session_close] Auto-bridge failed (non-fatal):", bridgeError);
+        return [];
+    }
+}
 /**
  * Execute session_close tool
  */
 export async function sessionClose(params) {
     const timer = new Timer();
     const metricsId = uuidv4();
+    // OD-548: Validate session_id format before any DB calls
+    if (params.session_id && !isValidSessionId(params.session_id)) {
+        const latencyMs = timer.stop();
+        const perfData = buildPerformanceData("session_close", latencyMs, 0);
+        return {
+            success: false,
+            session_id: params.session_id,
+            close_compliance: {
+                close_type: params.close_type,
+                agent: "Unknown",
+                checklist_displayed: false,
+                questions_answered_by_agent: false,
+                human_asked_for_corrections: false,
+                learnings_stored: 0,
+                scars_applied: 0,
+            },
+            validation_errors: [
+                `Invalid session_id format: "${params.session_id}". Expected UUID (e.g., '393adb34-a80c-4c3a-b71a-bc0053b7a7ea') or short form (e.g., '393adb34'). Run session_start first.`,
+            ],
+            performance: perfData,
+        };
+    }
     // GIT-21: Recover session_id from active-sessions registry (hostname+PID) or legacy file
     if (!params.session_id && params.close_type !== "retroactive") {
         // Try registry first (GIT-20 writes here)
@@ -321,22 +718,38 @@ export async function sessionClose(params) {
     // merge it with inline params (inline params take precedence).
     // This keeps the visible MCP tool call small: just session_id + close_type.
     const payloadPath = getGitmemPath("closing-payload.json");
+    let payloadConsumed = false;
     try {
         if (fs.existsSync(payloadPath)) {
             const filePayload = JSON.parse(fs.readFileSync(payloadPath, "utf-8"));
             // File provides defaults; inline params override
             params = { ...filePayload, ...params };
+            payloadConsumed = true;
             console.error(`[session_close] Loaded closing payload from ${payloadPath}`);
-            // Clean up payload file
-            try {
-                fs.unlinkSync(payloadPath);
-            }
-            catch { /* ignore */ }
+            // Payload file is cleaned up AFTER successful close (see end of function).
+            // If the tool crashes, the payload survives for retry.
         }
     }
     catch (error) {
         console.warn("[session_close] Failed to read closing-payload.json:", error);
     }
+    // Normalize closing_reflection field aliases (q1_broke → what_broke, etc.)
+    // Agents frequently guess field names instead of using canonical keys from CLOSING_QUESTIONS.
+    if (params.closing_reflection && typeof params.closing_reflection === "object") {
+        params.closing_reflection = normalizeReflectionKeys(params.closing_reflection);
+    }
+    // Normalize task_completion: if agent passed a string, wrap it in the expected object shape
+    if (params.task_completion && typeof params.task_completion === "string") {
+        const now = new Date().toISOString();
+        const fiveSecsAgo = new Date(Date.now() - 5000).toISOString();
+        params.task_completion = {
+            questions_displayed_at: fiveSecsAgo,
+            reflection_completed_at: fiveSecsAgo,
+            human_asked_at: fiveSecsAgo,
+            human_response_at: now,
+            human_response: "auto-normalized from string payload",
+        };
+    }
     // Close type auto-detection: reject mismatched close types based on session activity.
     // Standard close on a short/trivial session is wasteful; quick close on a long session loses data.
     // t-f7c2fa01: If closing_reflection is already present (agent answered 7 questions),
@@ -493,13 +906,52 @@ export async function sessionClose(params) {
         sessionId = uuidv4();
     }
     else {
-        // Normal mode: require existing session (guaranteed to exist by step 0 above)
+        // Normal mode: require existing session
         sessionId = params.session_id;
+        // Try Supabase first
         try {
             existingSession = await supabase.getRecord("orchestra_sessions", sessionId);
         }
         catch {
-            // Session might not exist yet, which is fine
+            // Supabase might not be configured (free tier) or session not found
+        }
+        // Fall back to local per-session file if Supabase didn't find it
+        if (!existingSession) {
+            try {
+                const localSessionPath = getSessionPath(sessionId, "session.json");
+                if (fs.existsSync(localSessionPath)) {
+                    const localData = JSON.parse(fs.readFileSync(localSessionPath, "utf-8"));
+                    existingSession = {
+                        id: sessionId,
+                        session_date: localData.started_at?.split("T")[0] || new Date().toISOString().split("T")[0],
+                        agent: localData.agent,
+                        project: localData.project,
+                        ...localData,
+                    };
+                    console.error(`[session_close] Session found in local file (not in Supabase)`);
+                }
+            }
+            catch {
+                // Local file read failed
+            }
+        }
+        // Fall back to active-sessions registry as last resort
+        if (!existingSession) {
+            try {
+                const mySession = findSessionByHostPid(os.hostname(), process.pid);
+                if (mySession && mySession.session_id === sessionId) {
+                    existingSession = {
+                        id: sessionId,
+                        session_date: mySession.started_at?.split("T")[0] || new Date().toISOString().split("T")[0],
+                        agent: mySession.agent,
+                        project: mySession.project,
+                    };
+                    console.error(`[session_close] Session found in registry (not in Supabase or local file)`);
+                }
+            }
+            catch {
+                // Registry lookup failed
+            }
         }
         if (!existingSession) {
             const latencyMs = timer.stop();
@@ -508,266 +960,58 @@ export async function sessionClose(params) {
                 success: false,
                 session_id: sessionId,
                 close_compliance: closeCompliance,
-                validation_errors: [`Session ${sessionId} not found. Was session_start called?`],
+                validation_errors: [`Session ${sessionId} not found in Supabase, local files, or registry. Was session_start called?`],
                 performance: perfData,
             };
         }
     }
     // 5. Build session data (merge with existing or create from scratch)
-    let sessionData;
-    if (isRetroactive) {
-        // Retroactive mode: create minimal session from scratch
-        const now = new Date().toISOString();
-        sessionData = {
-            id: sessionId,
-            agent: agentIdentity,
-            project: "orchestra_dev", // Default for retroactive
-            session_title: "Retroactive Session", // Will be updated below if we have content
-            session_date: now,
-            created_at: now,
-            close_compliance: closeCompliance,
-        };
-    }
-    else {
-        // Normal mode: merge with existing session
-        // Remove embedding from existing to avoid re-embedding unchanged text
-        const { embedding: _embedding, ...existingWithoutEmbedding } = existingSession;
-        sessionData = {
-            ...existingWithoutEmbedding,
-            close_compliance: closeCompliance,
-        };
-    }
-    // Add closing reflection if provided
-    if (params.closing_reflection) {
-        const reflection = { ...params.closing_reflection };
-        // Add human corrections to reflection if provided
-        if (params.human_corrections) {
-            reflection.human_additions = params.human_corrections;
-        }
-        sessionData.closing_reflection = reflection;
-    }
-    // Add decisions if provided
-    if (params.decisions && params.decisions.length > 0) {
-        sessionData.decisions = params.decisions.map((d) => d.title);
-    }
-    // OD-thread-lifecycle: Normalize and merge open threads
-    const sessionThreads = getThreads(); // Mid-session thread state (may have resolutions)
-    if (params.open_threads && params.open_threads.length > 0) {
-        const normalized = normalizeThreads(params.open_threads, params.session_id);
-        // Merge incoming with mid-session state (preserves resolutions from resolve_thread calls)
-        const merged = sessionThreads.length > 0
-            ? mergeThreadStates(normalized, sessionThreads)
-            : normalized;
-        sessionData.open_threads = merged;
-    }
-    else if (sessionThreads.length > 0) {
-        // No new threads from close payload, but we have mid-session state (e.g., resolutions)
-        sessionData.open_threads = sessionThreads;
-    }
-    // OD-534: If project_state provided, prepend it to open_threads as a ThreadObject
-    if (params.project_state) {
-        const projectStateText = `PROJECT STATE: ${params.project_state}`;
-        const existing = (sessionData.open_threads || []);
-        // Replace existing PROJECT STATE if present, otherwise prepend
-        const filtered = existing.filter(t => {
-            const text = typeof t === "string" ? t : t.text;
-            return !text.startsWith("PROJECT STATE:");
-        });
-        sessionData.open_threads = [migrateStringThread(projectStateText, params.session_id), ...filtered];
-    }
-    // OD-624: Sync threads to Supabase (source of truth)
-    // New threads get created, resolved threads get updated, existing threads get touched.
-    // This runs async — does not block session close on failure.
+    const sessionData = buildSessionRecord(params, existingSession, isRetroactive, agentIdentity, closeCompliance, sessionId);
+    // OD-624: Sync threads to Supabase (fire-and-forget, non-blocking)
     const closeThreads = (sessionData.open_threads || []);
     if (closeThreads.length > 0) {
-        const closeProject = isRetroactive ? "orchestra_dev" : existingSession?.project || "orchestra_dev";
+        const closeProject = isRetroactive ? "default" : existingSession?.project || "default";
         syncThreadsToSupabase(closeThreads, closeProject, sessionId).catch((err) => {
             console.error("[session_close] Thread Supabase sync failed (non-fatal):", err);
         });
     }
-    // v2 Phase 2: Persist observations and children from multi-agent work
-    const observations = getObservations();
-    if (observations.length > 0) {
-        sessionData.task_observations = observations;
-    }
-    const sessionChildren = getChildren();
-    if (sessionChildren.length > 0) {
-        sessionData.children = sessionChildren;
-    }
-    // Add linear issue if provided
-    if (params.linear_issue) {
-        sessionData.linear_issue = params.linear_issue;
+    // Prune threads.json: only keep open threads
+    try {
+        const openThreadsOnly = closeThreads.filter(t => t.status === "open" || !t.status);
+        saveThreadsFile(openThreadsOnly);
+        console.error(`[session_close] Pruned threads.json: ${openThreadsOnly.length} open threads (removed ${closeThreads.length - openThreadsOnly.length} resolved/archived)`);
     }
-    // Update session title if we have meaningful content
-    if (params.closing_reflection?.what_worked || params.decisions?.length) {
-        const titleParts = [];
-        if (params.linear_issue) {
-            titleParts.push(params.linear_issue);
-        }
-        if (params.decisions?.length) {
-            titleParts.push(params.decisions[0].title);
-        }
-        else if (params.closing_reflection?.what_worked) {
-            // Use first 50 chars of what_worked as title hint
-            titleParts.push(params.closing_reflection.what_worked.slice(0, 50));
-        }
-        if (titleParts.length > 0 &&
-            (sessionData.session_title === "Interactive Session" ||
-                sessionData.session_title === "Retroactive Session")) {
-            sessionData.session_title = titleParts.join(" - ");
-        }
+    catch (err) {
+        console.error("[session_close] Failed to prune threads.json (non-fatal):", err);
     }
     // OD-538: Capture transcript if enabled (default true for CLI/DAC)
+    let transcriptStatus;
     const shouldCaptureTranscript = params.capture_transcript !== false &&
         (agentIdentity === "CLI" || agentIdentity === "DAC");
     if (shouldCaptureTranscript) {
-        try {
-            let transcriptFilePath = null;
-            // Option 1: Explicit transcript path provided (overrides auto-detection)
-            if (params.transcript_path) {
-                if (fs.existsSync(params.transcript_path)) {
-                    transcriptFilePath = params.transcript_path;
-                    console.error(`[session_close] Using explicit transcript path: ${transcriptFilePath}`);
-                }
-                else {
-                    console.warn(`[session_close] Explicit transcript path does not exist: ${params.transcript_path}`);
-                }
-            }
-            // Option 2: Auto-detect by searching for most recent transcript
-            if (!transcriptFilePath) {
-                const homeDir = os.homedir();
-                const projectsDir = path.join(homeDir, ".claude", "projects");
-                const cwd = process.cwd();
-                const projectDirName = path.basename(cwd);
-                transcriptFilePath = findMostRecentTranscript(projectsDir, projectDirName, cwd);
-                if (transcriptFilePath) {
-                    console.error(`[session_close] Auto-detected transcript: ${transcriptFilePath}`);
-                }
-                else {
-                    console.error(`[session_close] No transcript file found in ${projectsDir}`);
-                }
-            }
-            // If we found a transcript, capture it
-            if (transcriptFilePath) {
-                const transcriptContent = fs.readFileSync(transcriptFilePath, "utf-8");
-                // Extract Claude Code session ID for traceability
-                const claudeSessionId = extractClaudeSessionId(transcriptContent, transcriptFilePath);
-                if (claudeSessionId) {
-                    sessionData.claude_code_session_id = claudeSessionId;
-                    console.error(`[session_close] Extracted Claude session ID: ${claudeSessionId}`);
-                }
-                // Call save_transcript tool
-                const saveResult = await saveTranscript({
-                    session_id: sessionId,
-                    transcript: transcriptContent,
-                    format: "json",
-                    project: isRetroactive ? "orchestra_dev" : existingSession?.project,
-                });
-                if (saveResult.success && saveResult.transcript_path) {
-                    sessionData.transcript_path = saveResult.transcript_path;
-                    console.error(`[session_close] Transcript saved: ${saveResult.transcript_path} (${saveResult.size_kb}KB)`);
-                    // OD-540: Process transcript for semantic search (async, don't block session close)
-                    processTranscript(sessionId, transcriptContent, isRetroactive ? "orchestra_dev" : existingSession?.project).then(result => {
-                        if (result.success) {
-                            console.error(`[session_close] Transcript chunking completed: ${result.chunksCreated} chunks created`);
-                        }
-                        else {
-                            console.warn(`[session_close] Transcript chunking failed: ${result.error}`);
-                        }
-                    }).catch(err => {
-                        console.error("[session_close] Transcript chunking error:", err);
-                    });
-                }
-                else {
-                    console.warn(`[session_close] Failed to save transcript: ${saveResult.error}`);
-                }
-            }
-        }
-        catch (error) {
-            // Don't fail session close if transcript capture fails
-            console.error("[session_close] Exception during transcript capture:", error);
+        const transcriptResult = await captureSessionTranscript(sessionId, params, existingSession, isRetroactive);
+        transcriptStatus = transcriptResult.status;
+        if (transcriptResult.claudeSessionId) {
+            sessionData.claude_code_session_id = transcriptResult.claudeSessionId;
         }
     }
-    // OD-552: Auto-bridge Q6 answers (closing_reflection.scars_applied) to scar_usage records
-    // This is the core fix: CLI/DAC sessions answer Q6 with scar names but these never
-    // became structured scar_usage records. Now we match Q6 answers against surfaced scars.
+    // OD-552: Auto-bridge Q6 answers to scar_usage records
+    const normalizedScarsApplied = normalizeScarsApplied(params.closing_reflection?.scars_applied);
     if ((!params.scars_to_record || params.scars_to_record.length === 0) &&
-        params.closing_reflection?.scars_applied?.length) {
-        try {
-            // Load surfaced scars: prefer in-memory, fall back to per-session dir, then legacy file
-            let surfacedScars = getSurfacedScars();
-            if (surfacedScars.length === 0 && params.session_id) {
-                // GIT-21: Try per-session directory first
-                try {
-                    const sessionFilePath = getSessionPath(params.session_id, "session.json");
-                    if (fs.existsSync(sessionFilePath)) {
-                        const sessionData = JSON.parse(fs.readFileSync(sessionFilePath, "utf-8"));
-                        if (sessionData.surfaced_scars && Array.isArray(sessionData.surfaced_scars)) {
-                            surfacedScars = sessionData.surfaced_scars;
-                            console.error(`[session_close] Loaded ${surfacedScars.length} surfaced scars from per-session file`);
-                        }
-                    }
-                }
-                catch { /* per-session file read failed */ }
-            }
-            if (surfacedScars.length > 0) {
-                const autoBridgedScars = [];
-                const matchedScarIds = new Set();
-                // For each Q6 answer, try to match against surfaced scars
-                for (const scarApplied of params.closing_reflection.scars_applied) {
-                    const lowerApplied = scarApplied.toLowerCase();
-                    // Match by UUID or title substring
-                    const match = surfacedScars.find((s) => {
-                        if (matchedScarIds.has(s.scar_id))
-                            return false; // Don't double-match
-                        return (s.scar_id === scarApplied || // Exact UUID match
-                            s.scar_title.toLowerCase().includes(lowerApplied) || // Title contains answer
-                            lowerApplied.includes(s.scar_title.toLowerCase()) // Answer contains title
-                        );
-                    });
-                    if (match) {
-                        matchedScarIds.add(match.scar_id);
-                        autoBridgedScars.push({
-                            scar_identifier: match.scar_id,
-                            session_id: sessionId,
-                            agent: agentIdentity,
-                            surfaced_at: match.surfaced_at,
-                            reference_type: "acknowledged",
-                            reference_context: `Auto-bridged from Q6 answer: "${scarApplied}"`,
-                        });
-                    }
-                }
-                // For surfaced scars NOT mentioned in Q6, record as "none" (surfaced but ignored)
-                for (const scar of surfacedScars) {
-                    if (!matchedScarIds.has(scar.scar_id)) {
-                        autoBridgedScars.push({
-                            scar_identifier: scar.scar_id,
-                            session_id: sessionId,
-                            agent: agentIdentity,
-                            surfaced_at: scar.surfaced_at,
-                            reference_type: "none",
-                            reference_context: `Surfaced during ${scar.source} but not mentioned in closing reflection`,
-                        });
-                    }
-                }
-                if (autoBridgedScars.length > 0) {
-                    params = { ...params, scars_to_record: autoBridgedScars };
-                    console.error(`[session_close] Auto-bridged ${autoBridgedScars.length} scar usage records (${matchedScarIds.size} acknowledged, ${autoBridgedScars.length - matchedScarIds.size} unmentioned)`);
-                }
-            }
-            else {
-                console.error("[session_close] No surfaced scars available for auto-bridge");
-            }
-        }
-        catch (bridgeError) {
-            console.error("[session_close] Auto-bridge failed (non-fatal):", bridgeError);
+        normalizedScarsApplied.length > 0) {
+        const bridgedScars = bridgeScarsToUsageRecords(normalizedScarsApplied, sessionId, agentIdentity);
+        if (bridgedScars.length > 0) {
+            params = { ...params, scars_to_record: bridgedScars };
         }
     }
     // 6. Persist to Supabase (direct REST API, bypasses ww-mcp)
     try {
-        // Generate embedding for session data
+        // OD-646: Upsert session WITHOUT embedding (fast path)
+        // Embedding + thread detection run fire-and-forget after
+        await supabase.directUpsert("orchestra_sessions", sessionData);
+        // OD-646: Tracked fire-and-forget embedding generation + session update + thread detection
         if (isEmbeddingAvailable()) {
-            try {
+            getEffectTracker().track("embedding", "session_close", async () => {
                 const embeddingParts = [
                     sessionData.session_title || "",
                     params.closing_reflection?.what_worked || "",
@@ -778,51 +1022,39 @@ export async function sessionClose(params) {
                 if (embeddingText.length > 10) {
                     const embeddingVector = await embed(embeddingText);
                     if (embeddingVector) {
-                        sessionData.embedding = JSON.stringify(embeddingVector);
-                    }
-                }
-            }
-            catch (embError) {
-                console.warn("[session_close] Embedding generation failed (non-fatal):", embError);
-            }
-        }
-        await supabase.directUpsert("orchestra_sessions", sessionData);
-        // Phase 5: Implicit thread detection (fire-and-forget)
-        if (sessionData.embedding) {
-            (async () => {
-                try {
-                    const sessionEmb = JSON.parse(sessionData.embedding);
-                    const suggestProject = existingSession?.project || "orchestra_dev";
-                    const recentSessions = await loadRecentSessionEmbeddings(suggestProject, 30, 20);
-                    const threadEmbs = await loadOpenThreadEmbeddings(suggestProject);
-                    if (recentSessions && threadEmbs) {
-                        const existing = loadSuggestions();
-                        const updated = detectSuggestedThreads({ session_id: sessionId, title: sessionData.session_title, embedding: sessionEmb }, recentSessions, threadEmbs, existing);
-                        saveSuggestions(updated);
+                        const embeddingJson = JSON.stringify(embeddingVector);
+                        // Update session with embedding (PATCH, not upsert — row already exists)
+                        await supabase.directPatch("orchestra_sessions", { id: sessionId }, { embedding: embeddingJson });
+                        console.error("[session_close] Embedding saved to session");
+                        // Phase 5: Implicit thread detection (chained after embedding)
+                        const suggestProject = existingSession?.project || "default";
+                        const recentSessions = await loadRecentSessionEmbeddings(suggestProject, 30, 20);
+                        const threadEmbs = await loadOpenThreadEmbeddings(suggestProject);
+                        if (recentSessions && threadEmbs) {
+                            const existing = loadSuggestions();
+                            const updated = detectSuggestedThreads({ session_id: sessionId, title: sessionData.session_title, embedding: embeddingVector }, recentSessions, threadEmbs, existing);
+                            saveSuggestions(updated);
+                        }
                     }
                 }
-                catch (err) {
-                    console.error("[session_close] Thread suggestion detection failed (non-fatal):", err);
-                }
-            })();
+            });
         }
-        // 7. Record scar usage if provided (parallel with metrics)
+        // OD-646: Tracked fire-and-forget scar usage recording (was blocking ~200-500ms)
         // OD-552: scars_to_record may now come from auto-bridge above
-        let scarRecordingResults;
         if (params.scars_to_record && params.scars_to_record.length > 0) {
             const project = isRetroactive
-                ? "orchestra_dev"
+                ? "default"
                 : existingSession.project;
-            scarRecordingResults = await recordScarUsageBatch({
+            getEffectTracker().track("scar_usage", "session_close_batch", () => recordScarUsageBatch({
                 scars: params.scars_to_record,
                 project,
-            });
+            }));
         }
         const latencyMs = timer.stop();
         const perfData = buildPerformanceData("session_close", latencyMs, 1);
         // Update relevance data for memories applied during session
-        if (params.closing_reflection?.scars_applied?.length) {
-            updateRelevanceData(sessionId, params.closing_reflection.scars_applied).catch(() => { });
+        if (normalizedScarsApplied.length > 0) {
+            updateRelevanceData(sessionId, normalizedScarsApplied).catch(() => { });
         }
         // Record metrics
         recordMetrics({
@@ -842,8 +1074,6 @@ export async function sessionClose(params) {
                 decisions_count: params.decisions?.length || 0,
                 open_threads_count: params.open_threads?.length || 0,
                 ceremony_duration_ms: params.ceremony_duration_ms,
-                scars_recorded_batch: scarRecordingResults?.resolved_count || 0,
-                scars_failed_batch: scarRecordingResults?.failed_count || 0,
                 retroactive: isRetroactive,
             },
         }).catch(() => { });
@@ -851,7 +1081,14 @@ export async function sessionClose(params) {
         clearCurrentSession();
         // GIT-21: Clean up session files (registry, per-session dir, legacy file)
         cleanupSessionFiles(sessionId);
-        const display = formatCloseDisplay(sessionId, closeCompliance, params, learningsCount, true, validation.warnings.length > 0 ? validation.warnings : undefined);
+        // Clean up payload file AFTER successful close (not before — crash safety)
+        if (payloadConsumed) {
+            try {
+                fs.unlinkSync(payloadPath);
+            }
+            catch { /* already gone */ }
+        }
+        const display = formatCloseDisplay(sessionId, closeCompliance, params, learningsCount, true, validation.warnings.length > 0 ? validation.warnings : undefined, transcriptStatus);
         return {
             success: true,
             session_id: sessionId,
@@ -867,7 +1104,7 @@ export async function sessionClose(params) {
         const perfData = buildPerformanceData("session_close", latencyMs, 0);
         // OD-547: Clear session state even on error (session is done either way)
         clearCurrentSession();
-        const errorDisplay = formatCloseDisplay(sessionId, closeCompliance, params, learningsCount, false, [`Failed to persist session: ${errorMessage}`]);
+        const errorDisplay = formatCloseDisplay(sessionId, closeCompliance, params, learningsCount, false, [`Failed to persist session: ${errorMessage}`], transcriptStatus);
         return {
             success: false,
             session_id: sessionId,