stackmem 1.0.5 → 1.0.7

package/dist/ast-index.js

@@ -190,11 +190,22 @@ export function analyzeCodebase(projectPath) {
     const insertClass = db.prepare("INSERT INTO classes (file_id, name) VALUES (?, ?)");
     const insertImport = db.prepare("INSERT INTO imports (file_id, source) VALUES (?, ?)");
     const files = walkProjectFiles(resolvedProjectPath);
+    let filesIndexed = 0;
     let totalFunctions = 0;
     let totalClasses = 0;
     const runAll = db.transaction((filePaths) => {
         for (const filePath of filePaths) {
-            const extraction = extractFile(filePath, resolvedProjectPath);
+            let extraction;
+            try {
+                extraction = extractFile(filePath, resolvedProjectPath);
+            }
+            catch {
+                // Tree-sitter (or the file read) choked on this file — better-sqlite3
+                // transactions roll back entirely on a throw, so skipping here
+                // (rather than letting it propagate) is what keeps one bad file from
+                // wiping out every other file already processed in this run.
+                continue;
+            }
             const row = insertFile.get(extraction.relativePath, path.basename(extraction.relativePath), new Date().toISOString());
             const fileId = row.id;
             deleteChildren.run(fileId);
@@ -211,12 +222,13 @@ export function analyzeCodebase(projectPath) {
             for (const source of extraction.imports) {
                 insertImport.run(fileId, source);
             }
+            filesIndexed++;
         }
     });
     runAll(files);
     db.close();
     return {
-        files_indexed: files.length,
+        files_indexed: filesIndexed,
         functions: totalFunctions,
         classes: totalClasses,
     };

package/dist/cli.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { analyzeCodebase } from "./ast-index.js";
 import { getDeviceId } from "./device.js";
-import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, scoreMemoryRelevance, } from "./scoring.js";
+import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, indicatesFailedApproach, isAuthRelatedFile, isCodeFile, isQualityMessage, scoreMemoryRelevance, } from "./scoring.js";
 import { supabase } from "./storage.js";
 const CONTEXT_BUDGET_TOKENS = 2000;
 const COMPRESSION_THRESHOLD = 20;
@@ -29,16 +29,23 @@ function usage() {
   cm save [project] <type> <content> [--force]  (type: decision|rejection|constraint|discovery)
   cm fix [project] <problem> <solution>
   cm analyze [project] <path>
-  cm search [project] <query>
+  cm search [--project <name>] <query>
   cm resolve [project] <memory-id>
   cm delete [project] <memory-id>
   cm compress [project]
   cm init <project> <path>
-  cm context [project] <task>
+  cm context [--project <name>] <task>
+  cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
+  cm doctor
+  cm undo [project]
+  cm export [filename]
+  cm import [project] <filename>
   cm help
 
   [project] is optional if a .stackmem file exists in the current
-  directory (written by 'cm init'). Otherwise it must be given explicitly.`);
+  directory (written by 'cm init'). Otherwise it must be given explicitly.
+  search/context take --project instead of a positional project, since a
+  bare query/task can't otherwise be told apart from a project name.`);
     process.exit(1);
 }
 function cmdHelp() {
@@ -67,9 +74,10 @@ function cmdHelp() {
       Build an AST index (files, functions, classes) for the codebase
       at <path>.
 
-  cm search [project] <query>
+  cm search [--project <name>] <query>
       Search saved memories and past fixes for a project matching
-      <query>.
+      <query>. The whole query is always the full remaining text — use
+      --project to search a project other than the one in .stackmem.
 
   cm resolve [project] <memory-id>
       Mark a memory as resolved.
@@ -86,10 +94,42 @@ function cmdHelp() {
       the stackmem MCP server with Claude Code, write a CLAUDE.md and
       .stackmem file, and seed initial memories from the project scan.
 
-  cm context [project] <task>
+  cm context [--project <name>] <task>
       Return only the top 5 memories most relevant to a specific
       task, ranked by a blend of task relevance and decay score,
-      as a markdown block capped at a 2000 token budget.
+      as a markdown block capped at a 2000 token budget. Use
+      --project to target a project other than the one in .stackmem.
+
+  cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
+      Capture what happened in a session and extract memories: each
+      error becomes an unsolved execution_log entry, each approach
+      containing "failed", "didn't work", "reverted", or "switched
+      away" becomes a rejection, a summary that passes the quality
+      filter becomes a decision, auth-related files become a
+      discovery, and any .ts/.js file triggers an AST re-index.
+      Accepts the same fields as JSON on stdin instead of flags
+      (project, summary, errors_encountered, files_touched,
+      approaches_tried) when stdin is piped rather than a terminal.
+
+  cm doctor
+      Check every integration point in the current directory — backend
+      connection, MCP registration, .stackmem, git hook, and memory
+      count — and report what's working and what's broken.
+
+  cm undo [project]
+      Delete the most recently saved unresolved memory (and any
+      memory_links referencing it) for a project.
+
+  cm export [filename]
+      Export all unresolved memories, execution_log entries, and
+      memory_links for a project to a JSON file. Defaults to
+      <project>-memories.json.
+
+  cm import [project] <filename>
+      Import memories and execution_log entries from a JSON file
+      produced by 'cm export'. Inserted under the current device_id
+      and project; memory_links are skipped and get rebuilt by
+      semantic linking the next time cm save runs.
 
   cm help
       Show this help message.`);
@@ -107,7 +147,18 @@ function readProjectFromFile() {
     const content = nodeFs.readFileSync(stackmemPath, "utf-8").trim();
     return content.length > 0 ? content : null;
 }
+// Catches the common habit-slip of typing `cm fix . "problem" "solution"` by
+// muscle memory from `cm init <project> .` — "." (or "..", or anything
+// path-shaped) is never a real project name, so an explicit arg this shape
+// almost certainly means the caller meant to omit the project entirely.
+function looksLikeAPath(value) {
+    return value === "." || value === ".." || value.includes("/") || value.includes("\\");
+}
 function requireProject(explicit) {
+    if (explicit && looksLikeAPath(explicit)) {
+        console.error(`Warning: '${explicit}' is not a valid project name — reading from .stackmem instead.`);
+        explicit = null;
+    }
     if (explicit)
         return explicit;
     const fromFile = readProjectFromFile();
@@ -130,12 +181,23 @@ function splitOptionalProject(args, fixedArgCount) {
 // arg count can't disambiguate an omitted project from a multi-word query —
 // "cm search bug fix" is ambiguous by count alone. Use .stackmem's presence
 // instead: if it exists, nothing is positionally a project.
+// Arg count can't disambiguate an omitted project from a multi-word query —
+// "cm search bug fix" is ambiguous by count alone. Treating .stackmem's mere
+// presence as "project omitted" (the previous approach) was worse: it
+// silently swallowed an explicit project into the query text whenever a
+// .stackmem file happened to exist in cwd, so "cm search otherproj auth bug"
+// would search project X (from .stackmem) for the literal text "otherproj
+// auth bug" with no error. Positional args are now always the full
+// query/task; an explicit override uses --project <name> instead, which is
+// never ambiguous and is never silently absorbed.
 function splitProjectFromVariadic(args) {
-    if (readProjectFromFile() !== null) {
-        return { project: null, rest: args };
+    const flagIndex = args.indexOf("--project");
+    if (flagIndex !== -1 && args[flagIndex + 1] !== undefined) {
+        const project = args[flagIndex + 1];
+        const rest = [...args.slice(0, flagIndex), ...args.slice(flagIndex + 2)];
+        return { project, rest };
     }
-    const [project = null, ...rest] = args;
-    return { project, rest };
+    return { project: null, rest: args };
 }
 // --- cm start ----------------------------------------------------------
 async function cmdStart(project) {
@@ -488,13 +550,17 @@ const LOW_QUALITY_PREFIXES = [
   "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
 ];
 
+const SEMVER_RE = /^\\d+\\.\\d+\\.\\d+$/;
+
 // Filters out lazy/placeholder commit messages ("wip", "fix", "m", "...")
-// so only messages worth remembering become decisions. Checked against the
-// first word, not a raw prefix match, so a real message like "Migrate auth
-// to JWT" isn't rejected just for starting with the letter "m".
+// and bare version bumps ("1.0.4") so only messages worth remembering
+// become decisions. Checked against the first word, not a raw prefix
+// match, so a real message like "Migrate auth to JWT" isn't rejected just
+// for starting with the letter "m".
 function isQualityCommitMessage(message) {
   const trimmed = message.trim();
-  if (trimmed.length <= 20) return false;
+  if (trimmed.length < 15) return false;
+  if (SEMVER_RE.test(trimmed)) return false;
   if (!trimmed.includes(" ")) return false;
 
   const stripped = trimmed.replace(/\\s/g, "");
@@ -817,7 +883,7 @@ async function cmdInit(project, targetPath) {
         console.log(`stackmem is live. Open Claude Code and ask "what do you know about this project?" to verify.`);
     }
     else {
-        console.log("✗ Backend connection failed — run 'cm doctor' (once we build it)");
+        console.log("✗ Backend connection failed — run 'cm doctor'");
     }
     // Written last and deliberately: if a commit (and hence the post-commit
     // hook) fires anywhere during init, it must still see whatever project
@@ -867,6 +933,349 @@ async function cmdContext(project, task) {
     lines.push(`*(${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used)*`);
     console.log(lines.join("\n"));
 }
+function splitCommaList(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+// Flags only — stdin JSON is handled separately in cmdSessionEndEntry, since
+// it carries its own full shape (arrays, not comma-joined strings).
+function parseSessionEndFlags(args) {
+    let project = null;
+    let summary;
+    let errors = [];
+    let files = [];
+    let approaches = [];
+    let i = 0;
+    if (args[i] && !args[i].startsWith("--")) {
+        project = args[i];
+        i++;
+    }
+    for (; i < args.length; i++) {
+        const flag = args[i];
+        const value = args[i + 1];
+        if (flag === "--summary") {
+            summary = value;
+            i++;
+        }
+        else if (flag === "--errors") {
+            errors = splitCommaList(value);
+            i++;
+        }
+        else if (flag === "--files") {
+            files = splitCommaList(value);
+            i++;
+        }
+        else if (flag === "--approaches") {
+            approaches = splitCommaList(value);
+            i++;
+        }
+    }
+    return { project, summary, errors, files, approaches };
+}
+async function readStdinJson() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function cmdSessionEnd(project, input) {
+    let memoriesSaved = 0;
+    let errorsLogged = 0;
+    for (const problem of input.errors) {
+        const { error } = await supabase.from("execution_log").insert({
+            project,
+            problem,
+            solution: null,
+            resolved: false,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            errorsLogged++;
+    }
+    for (const approach of input.approaches) {
+        if (!indicatesFailedApproach(approach))
+            continue;
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "rejection",
+            content: approach,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    if (input.summary && isQualityMessage(input.summary)) {
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "decision",
+            content: input.summary.trim(),
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    const authFiles = input.files.filter(isAuthRelatedFile);
+    if (authFiles.length > 0) {
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "discovery",
+            content: `session touched auth files: ${authFiles.join(", ")}`,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    if (input.files.some(isCodeFile)) {
+        analyzeCodebase(process.cwd());
+    }
+    console.log(`Session captured. ${memoriesSaved} memories saved.`);
+    if (errorsLogged > 0) {
+        console.log(`${errorsLogged} error(s) logged to execution_log.`);
+    }
+}
+// Dispatches to JSON-from-stdin or flag parsing depending on how the
+// command was invoked — piped input (e.g. from a script) uses JSON; an
+// interactive terminal with no piped stdin uses flags.
+async function cmdSessionEndEntry(args) {
+    let input;
+    if (!process.stdin.isTTY) {
+        const json = await readStdinJson();
+        if (json) {
+            input = {
+                project: typeof json.project === "string" ? json.project : null,
+                summary: typeof json.summary === "string" ? json.summary : undefined,
+                errors: Array.isArray(json.errors_encountered) ? json.errors_encountered : [],
+                files: Array.isArray(json.files_touched) ? json.files_touched : [],
+                approaches: Array.isArray(json.approaches_tried) ? json.approaches_tried : [],
+            };
+        }
+        else {
+            input = parseSessionEndFlags(args);
+        }
+    }
+    else {
+        input = parseSessionEndFlags(args);
+    }
+    const project = requireProject(input.project);
+    await cmdSessionEnd(project, {
+        summary: input.summary,
+        errors: input.errors,
+        files: input.files,
+        approaches: input.approaches,
+    });
+}
+// --- cm doctor ---------------------------------------------------------
+async function cmdDoctor() {
+    let issues = 0;
+    const project = readProjectFromFile();
+    // 1. Backend connection
+    const backendOk = await verifyBackendConnection(project ?? "");
+    if (backendOk) {
+        console.log("✓ Backend connection verified");
+    }
+    else {
+        console.log("✗ Backend connection failed — check your network");
+        issues++;
+    }
+    // 2. MCP server registration
+    const claudeConfigPath = nodePath.join(nodeOs.homedir(), ".claude.json");
+    let mcpRegistered = false;
+    if (nodeFs.existsSync(claudeConfigPath)) {
+        try {
+            const config = JSON.parse(nodeFs.readFileSync(claudeConfigPath, "utf-8"));
+            mcpRegistered = Boolean(config?.mcpServers?.stackmem);
+        }
+        catch {
+            mcpRegistered = false;
+        }
+    }
+    if (mcpRegistered) {
+        console.log("✓ MCP server registered with Claude Code");
+    }
+    else {
+        console.log("✗ MCP server not registered — run 'cm init <project> .'");
+        issues++;
+    }
+    // 3. Project file
+    if (project) {
+        console.log(`✓ Project file found: ${project}`);
+    }
+    else {
+        console.log("✗ No .stackmem found — run 'cm init <project> .'");
+        issues++;
+    }
+    // 4. Git hook
+    const gitDir = nodePath.join(process.cwd(), ".git");
+    if (!nodeFs.existsSync(gitDir)) {
+        console.log("✗ No git repo found in current directory");
+        issues++;
+    }
+    else {
+        const hookPath = nodePath.join(gitDir, "hooks", "post-commit");
+        let hookExecutable = false;
+        if (nodeFs.existsSync(hookPath)) {
+            try {
+                nodeFs.accessSync(hookPath, nodeFs.constants.X_OK);
+                hookExecutable = true;
+            }
+            catch {
+                hookExecutable = false;
+            }
+        }
+        if (hookExecutable) {
+            console.log("✓ Git hook installed");
+        }
+        else {
+            console.log("✗ Git hook not installed — run 'cm init <project> .'");
+            issues++;
+        }
+    }
+    // 5. Memory count
+    if (project) {
+        const { count, error } = await supabase
+            .from("memories")
+            .select("id", { count: "exact", head: true })
+            .eq("project", project)
+            .eq("resolved", false);
+        if (!error && (count ?? 0) > 0) {
+            console.log(`✓ ${count} memories stored for "${project}"`);
+        }
+        else {
+            console.log(`✗ No memories yet — make a commit to start capturing`);
+            issues++;
+        }
+    }
+    else {
+        console.log(`✗ No memories yet — make a commit to start capturing`);
+        issues++;
+    }
+    console.log("");
+    if (issues === 0) {
+        console.log("All systems operational.");
+    }
+    else {
+        console.log(`${issues} issue(s) found. See above.`);
+    }
+}
+// --- cm undo -------------------------------------------------------------
+async function cmdUndo(project) {
+    const { data, error } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false)
+        .order("created_at", { ascending: false })
+        .limit(1);
+    if (error)
+        fail(`Failed to load most recent memory: ${error.message}`);
+    const memory = (data ?? [])[0];
+    if (!memory) {
+        console.log("Nothing to undo.");
+        return;
+    }
+    const { error: linksError } = await supabase
+        .from("memory_links")
+        .delete()
+        .or(`source_id.eq.${memory.id},target_id.eq.${memory.id}`);
+    if (linksError)
+        fail(`Failed to delete memory links: ${linksError.message}`);
+    const { error: deleteError } = await supabase.from("memories").delete().eq("id", memory.id);
+    if (deleteError)
+        fail(`Failed to delete memory: ${deleteError.message}`);
+    console.log(`Undone: [${memory.type}] ${memory.content}`);
+}
+// --- cm export -------------------------------------------------------------
+async function cmdExport(project, filename) {
+    const { data: memories, error: memoriesError } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (memoriesError)
+        fail(`Failed to load memories: ${memoriesError.message}`);
+    const { data: executionLog, error: executionLogError } = await supabase
+        .from("execution_log")
+        .select("*")
+        .eq("project", project);
+    if (executionLogError)
+        fail(`Failed to load execution log: ${executionLogError.message}`);
+    const memoryResults = memories ?? [];
+    const memoryIds = memoryResults.map((m) => m.id);
+    let memoryLinks = [];
+    if (memoryIds.length > 0) {
+        const idList = memoryIds.join(",");
+        const { data: links, error: linksError } = await supabase
+            .from("memory_links")
+            .select("*")
+            .or(`source_id.in.(${idList}),target_id.in.(${idList})`);
+        if (linksError)
+            fail(`Failed to load memory links: ${linksError.message}`);
+        memoryLinks = links ?? [];
+    }
+    const exportData = {
+        project,
+        exported_at: new Date().toISOString(),
+        memories: memoryResults,
+        execution_log: executionLog ?? [],
+        memory_links: memoryLinks,
+    };
+    const outputFilename = filename ?? `${project}-memories.json`;
+    nodeFs.writeFileSync(outputFilename, JSON.stringify(exportData, null, 2), "utf-8");
+    console.log(`Exported ${memoryResults.length} memories to ${outputFilename}`);
+}
+// --- cm import -------------------------------------------------------------
+async function cmdImport(project, filename) {
+    if (!nodeFs.existsSync(filename)) {
+        console.log(`File not found: ${filename}`);
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(nodeFs.readFileSync(filename, "utf-8"));
+    }
+    catch (error) {
+        fail(`Failed to parse ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const memories = Array.isArray(parsed.memories) ? parsed.memories : [];
+    const executionLogEntries = Array.isArray(parsed.execution_log) ? parsed.execution_log : [];
+    // memory_links are intentionally skipped — they get rebuilt by semantic
+    // linking the next time cm save runs against the imported memories.
+    let importedCount = 0;
+    for (const memory of memories) {
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: memory.type,
+            content: memory.content,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            importedCount++;
+    }
+    for (const entry of executionLogEntries) {
+        await supabase.from("execution_log").insert({
+            project,
+            problem: entry.problem,
+            solution: entry.solution ?? null,
+            resolved: entry.resolved ?? false,
+            device_id: getDeviceId(),
+        });
+    }
+    console.log(`Imported ${importedCount} memories from ${filename}`);
+}
 // --- main --------------------------------------------------------------
 async function main() {
     const [, , command, ...args] = process.argv;
@@ -969,6 +1378,39 @@ async function main() {
             await cmdContext(project, split.rest.join(" "));
             break;
         }
+        case "session-end": {
+            await cmdSessionEndEntry(args);
+            break;
+        }
+        case "doctor": {
+            await cmdDoctor();
+            break;
+        }
+        case "undo": {
+            const split = splitOptionalProject(args, 0);
+            if (!split)
+                usage();
+            const project = requireProject(split.project);
+            await cmdUndo(project);
+            break;
+        }
+        case "export": {
+            if (args.length > 1)
+                usage();
+            const [filename] = args;
+            const project = requireProject(null);
+            await cmdExport(project, filename);
+            break;
+        }
+        case "import": {
+            const split = splitOptionalProject(args, 1);
+            if (!split)
+                usage();
+            const project = requireProject(split.project);
+            const [filename] = split.rest;
+            await cmdImport(project, filename);
+            break;
+        }
         case "help": {
             cmdHelp();
             break;

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { analyzeCodebase, getFileSummary, findDependencies } from "./ast-index.js";
 import { getDeviceId } from "./device.js";
-import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, } from "./scoring.js";
+import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, indicatesFailedApproach, isAuthRelatedFile, isCodeFile, isQualityMessage, } from "./scoring.js";
 import { supabase } from "./storage.js";
 const CONTEXT_BUDGET_TOKENS = 2000;
 const COMPRESSION_THRESHOLD = 20;
@@ -312,6 +312,80 @@ server.registerTool("find_dependencies", {
         structuredContent: deps,
     };
 });
+// --- session_end -----------------------------------------------------------
+server.registerTool("session_end", {
+    title: "Session End",
+    description: "Capture what happened during a coding session and automatically extract memories: unsolved errors, failed approaches, a summary decision, auth-file touches, and an AST re-index.",
+    inputSchema: {
+        project: z.string().describe("Project identifier"),
+        files_touched: z.array(z.string()).describe("Files read or modified during the session"),
+        errors_encountered: z.array(z.string()).describe("Error messages encountered during the session"),
+        approaches_tried: z
+            .array(z.string())
+            .optional()
+            .describe("Things that were attempted during the session"),
+        summary: z.string().optional().describe("One sentence describing what was accomplished"),
+    },
+}, async ({ project, files_touched, errors_encountered, approaches_tried, summary }) => {
+    let memoriesSaved = 0;
+    let errorsLogged = 0;
+    for (const problem of errors_encountered) {
+        const { error } = await supabase.from("execution_log").insert({
+            project,
+            problem,
+            solution: null,
+            resolved: false,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            errorsLogged++;
+    }
+    for (const approach of approaches_tried ?? []) {
+        if (!indicatesFailedApproach(approach))
+            continue;
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "rejection",
+            content: approach,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    if (summary && isQualityMessage(summary)) {
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "decision",
+            content: summary.trim(),
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    const authFiles = files_touched.filter(isAuthRelatedFile);
+    if (authFiles.length > 0) {
+        const { error } = await supabase.from("memories").insert({
+            project,
+            type: "discovery",
+            content: `session touched auth files: ${authFiles.join(", ")}`,
+            device_id: getDeviceId(),
+        });
+        if (!error)
+            memoriesSaved++;
+    }
+    if (files_touched.some(isCodeFile)) {
+        analyzeCodebase(process.cwd());
+    }
+    const message = `Session captured. ${memoriesSaved} memories saved.`;
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: {
+            memories_saved: memoriesSaved,
+            errors_logged: errorsLogged,
+            message,
+        },
+    };
+});
 // --- transport -------------------------------------------------------------
 async function main() {
     const transport = new StdioServerTransport();