stackmem 1.0.4 → 1.0.6

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,19 @@ 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 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 +70,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 +90,22 @@ 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 help
       Show this help message.`);
@@ -107,7 +123,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 +157,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) {
@@ -483,21 +521,64 @@ function isSchemaFile(filePath) {
   );
 }
 
+const LOW_QUALITY_PREFIXES = [
+  "wip", "fix", "update", "misc", "temp", "test", "patch", "minor",
+  "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
+];
+
+const SEMVER_RE = /^\\d+\\.\\d+\\.\\d+$/;
+
+// Filters out lazy/placeholder commit messages ("wip", "fix", "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 < 15) return false;
+  if (SEMVER_RE.test(trimmed)) return false;
+  if (!trimmed.includes(" ")) return false;
+
+  const stripped = trimmed.replace(/\\s/g, "");
+  if (stripped.length > 0 && new Set(stripped).size === 1) return false;
+
+  const lowerTrimmed = trimmed.toLowerCase();
+  if (LOW_QUALITY_PREFIXES.includes(lowerTrimmed)) return false;
+
+  const firstWord = (lowerTrimmed.match(/^[a-z0-9]+/) || [""])[0];
+  if (LOW_QUALITY_PREFIXES.includes(firstWord)) return false;
+
+  return true;
+}
+
 const savedItems = [];
 
 const commitMessage = git(["log", "-1", "--pretty=%B"]);
-cmSave("decision", commitMessage);
-savedItems.push(\`decision: \${commitMessage}\`);
 
-const changedFiles = git(["diff-tree", "--no-commit-id", "-r", "--name-only", "HEAD"])
+const isFirstCommit = (() => {
+  try {
+    execFileSync("git", ["rev-parse", "HEAD~1"], { stdio: "pipe" });
+    return false;
+  } catch {
+    return true;
+  }
+})();
+
+const changedFiles = git(
+  isFirstCommit
+    ? ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"]
+    : ["diff-tree", "--no-commit-id", "-r", "--name-only", "HEAD"]
+)
   .split("\\n")
   .filter(Boolean);
 
 let diff = "";
-try {
-  diff = execFileSync("git", ["diff", "HEAD~1", "HEAD"], { encoding: "utf-8" });
-} catch {
-  diff = "";
+if (!isFirstCommit) {
+  try {
+    diff = execFileSync("git", ["diff", "HEAD~1", "HEAD"], { encoding: "utf-8" });
+  } catch {
+    diff = "";
+  }
 }
 
 const lines = diff.split("\\n");
@@ -505,7 +586,7 @@ let currentFile = null;
 let isNewFile = false;
 let inDependenciesSection = false;
 
-for (const line of lines) {
+for (const line of isFirstCommit ? [] : lines) {
   if (line.startsWith("diff --git")) {
     isNewFile = false;
     inDependenciesSection = false;
@@ -555,10 +636,20 @@ for (const line of lines) {
   if (line.startsWith("-") && !line.startsWith("---")) {
     const codeLine = line.slice(1).trim();
 
-    if (codeLine.startsWith("import") || codeLine.startsWith("require")) {
-      const pathMatch = codeLine.match(/['"]([^'"]+)['"]/);
-      const importPath = pathMatch ? pathMatch[1] : codeLine;
-      const content = \`removed dependency: \${importPath}\`;
+    const importMatch = line.match(
+      /^-\\s*(import\\s+.*\\s+from\\s+['"]([^'"]+)['"]|import\\s+['"]([^'"]+)['"])/
+    );
+    const requireMatch = line.match(
+      /^-\\s*(?:const|let|var)\\s+\\S+\\s*=\\s*require\\(['"]([^'"]+)['"]\\)/
+    );
+    const removedModulePath = importMatch
+      ? importMatch[2] || importMatch[3]
+      : requireMatch
+        ? requireMatch[1]
+        : null;
+
+    if (removedModulePath) {
+      const content = \`removed dependency: \${removedModulePath}\`;
       cmSave("rejection", content);
       savedItems.push(\`rejection: \${content}\`);
     }
@@ -614,6 +705,14 @@ for (const line of lines) {
   }
 }
 
+// Saved last, after every diff-detected memory, and only if it clears the
+// quality filter — diff analysis always runs regardless of commit message.
+if (isQualityCommitMessage(commitMessage)) {
+  const trimmedMessage = commitMessage.trim();
+  cmSave("decision", trimmedMessage);
+  savedItems.push(\`decision: \${trimmedMessage}\`);
+}
+
 console.log(\`coding-memory post-commit summary (\${changedFiles.length} file(s) changed):\`);
 for (const item of savedItems) {
   console.log(\`  - \${item}\`);
@@ -810,6 +909,151 @@ 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,
+    });
+}
 // --- main --------------------------------------------------------------
 async function main() {
     const [, , command, ...args] = process.argv;
@@ -912,6 +1156,10 @@ async function main() {
             await cmdContext(project, split.rest.join(" "));
             break;
         }
+        case "session-end": {
+            await cmdSessionEndEntry(args);
+            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();

package/dist/scoring.js

@@ -192,6 +192,50 @@ export function buildSummaryContent(cluster) {
         .join("; ");
     return `[${mostCommonType.toUpperCase()} cluster] ${topic}: ${items}`;
 }
+// --- message quality filter ------------------------------------------------
+const LOW_QUALITY_PREFIXES = [
+    "wip", "fix", "update", "misc", "temp", "test", "patch", "minor",
+    "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
+];
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+// Filters out lazy/placeholder messages ("wip", "fix", "m", "...") and bare
+// version bumps ("1.0.4"). Checked against the first word (and the whole
+// message), not a raw prefix match, so a real message like "Migrate auth to
+// JWT" isn't rejected just for starting with the letter "m". The git hook
+// keeps its own inline copy of this same logic since it runs as a standalone
+// script with no access to this module — keep the two in sync by hand if
+// this changes.
+export function isQualityMessage(message) {
+    const trimmed = message.trim();
+    if (trimmed.length < 15)
+        return false;
+    if (SEMVER_RE.test(trimmed))
+        return false;
+    if (!trimmed.includes(" "))
+        return false;
+    const stripped = trimmed.replace(/\s/g, "");
+    if (stripped.length > 0 && new Set(stripped).size === 1)
+        return false;
+    const lowerTrimmed = trimmed.toLowerCase();
+    if (LOW_QUALITY_PREFIXES.includes(lowerTrimmed))
+        return false;
+    const firstWord = (lowerTrimmed.match(/^[a-z0-9]+/) || [""])[0];
+    if (LOW_QUALITY_PREFIXES.includes(firstWord))
+        return false;
+    return true;
+}
+// --- session-end classification ---------------------------------------------
+const FAILURE_PHRASES = ["failed", "didn't work", "reverted", "switched away"];
+export function indicatesFailedApproach(text) {
+    const lower = text.toLowerCase();
+    return FAILURE_PHRASES.some((phrase) => lower.includes(phrase));
+}
+export function isAuthRelatedFile(filePath) {
+    return /(auth|login|session|token)/i.test(filePath);
+}
+export function isCodeFile(filePath) {
+    return /\.(ts|js)$/i.test(filePath);
+}
 // --- task relevance --------------------------------------------------------
 function splitWords(text) {
     return text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackmem",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/ast-index.ts

@@ -217,12 +217,23 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
   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: string[]) => {
     for (const filePath of filePaths) {
-      const extraction = extractFile(filePath, resolvedProjectPath);
+      let extraction: FileExtraction;
+      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),
@@ -245,6 +256,8 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
       for (const source of extraction.imports) {
         insertImport.run(fileId, source);
       }
+
+      filesIndexed++;
     }
   });
 
@@ -252,7 +265,7 @@ export function analyzeCodebase(projectPath: string): AnalyzeCodebaseResult {
   db.close();
 
   return {
-    files_indexed: files.length,
+    files_indexed: filesIndexed,
     functions: totalFunctions,
     classes: totalClasses,
   };

package/src/cli.ts

@@ -14,6 +14,10 @@ import {
   computeMemoryLinks,
   decideSaveAction,
   estimateTokens,
+  indicatesFailedApproach,
+  isAuthRelatedFile,
+  isCodeFile,
+  isQualityMessage,
   scoreMemoryRelevance,
 } from "./scoring.js";
 import { supabase } from "./storage.js";
@@ -43,16 +47,19 @@ function usage(): never {
   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 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);
 }
 
@@ -82,9 +89,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.
@@ -101,10 +109,22 @@ 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 help
       Show this help message.`);
@@ -126,7 +146,22 @@ function readProjectFromFile(): string | null {
   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: string): boolean {
+  return value === "." || value === ".." || value.includes("/") || value.includes("\\");
+}
+
 function requireProject(explicit: string | null): string {
+  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();
@@ -154,12 +189,23 @@ function splitOptionalProject(
 // 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: string[]): { project: string | null; rest: string[] } {
-  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 ----------------------------------------------------------
@@ -573,21 +619,64 @@ function isSchemaFile(filePath) {
   );
 }
 
+const LOW_QUALITY_PREFIXES = [
+  "wip", "fix", "update", "misc", "temp", "test", "patch", "minor",
+  "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
+];
+
+const SEMVER_RE = /^\\d+\\.\\d+\\.\\d+$/;
+
+// Filters out lazy/placeholder commit messages ("wip", "fix", "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 < 15) return false;
+  if (SEMVER_RE.test(trimmed)) return false;
+  if (!trimmed.includes(" ")) return false;
+
+  const stripped = trimmed.replace(/\\s/g, "");
+  if (stripped.length > 0 && new Set(stripped).size === 1) return false;
+
+  const lowerTrimmed = trimmed.toLowerCase();
+  if (LOW_QUALITY_PREFIXES.includes(lowerTrimmed)) return false;
+
+  const firstWord = (lowerTrimmed.match(/^[a-z0-9]+/) || [""])[0];
+  if (LOW_QUALITY_PREFIXES.includes(firstWord)) return false;
+
+  return true;
+}
+
 const savedItems = [];
 
 const commitMessage = git(["log", "-1", "--pretty=%B"]);
-cmSave("decision", commitMessage);
-savedItems.push(\`decision: \${commitMessage}\`);
 
-const changedFiles = git(["diff-tree", "--no-commit-id", "-r", "--name-only", "HEAD"])
+const isFirstCommit = (() => {
+  try {
+    execFileSync("git", ["rev-parse", "HEAD~1"], { stdio: "pipe" });
+    return false;
+  } catch {
+    return true;
+  }
+})();
+
+const changedFiles = git(
+  isFirstCommit
+    ? ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"]
+    : ["diff-tree", "--no-commit-id", "-r", "--name-only", "HEAD"]
+)
   .split("\\n")
   .filter(Boolean);
 
 let diff = "";
-try {
-  diff = execFileSync("git", ["diff", "HEAD~1", "HEAD"], { encoding: "utf-8" });
-} catch {
-  diff = "";
+if (!isFirstCommit) {
+  try {
+    diff = execFileSync("git", ["diff", "HEAD~1", "HEAD"], { encoding: "utf-8" });
+  } catch {
+    diff = "";
+  }
 }
 
 const lines = diff.split("\\n");
@@ -595,7 +684,7 @@ let currentFile = null;
 let isNewFile = false;
 let inDependenciesSection = false;
 
-for (const line of lines) {
+for (const line of isFirstCommit ? [] : lines) {
   if (line.startsWith("diff --git")) {
     isNewFile = false;
     inDependenciesSection = false;
@@ -645,10 +734,20 @@ for (const line of lines) {
   if (line.startsWith("-") && !line.startsWith("---")) {
     const codeLine = line.slice(1).trim();
 
-    if (codeLine.startsWith("import") || codeLine.startsWith("require")) {
-      const pathMatch = codeLine.match(/['"]([^'"]+)['"]/);
-      const importPath = pathMatch ? pathMatch[1] : codeLine;
-      const content = \`removed dependency: \${importPath}\`;
+    const importMatch = line.match(
+      /^-\\s*(import\\s+.*\\s+from\\s+['"]([^'"]+)['"]|import\\s+['"]([^'"]+)['"])/
+    );
+    const requireMatch = line.match(
+      /^-\\s*(?:const|let|var)\\s+\\S+\\s*=\\s*require\\(['"]([^'"]+)['"]\\)/
+    );
+    const removedModulePath = importMatch
+      ? importMatch[2] || importMatch[3]
+      : requireMatch
+        ? requireMatch[1]
+        : null;
+
+    if (removedModulePath) {
+      const content = \`removed dependency: \${removedModulePath}\`;
       cmSave("rejection", content);
       savedItems.push(\`rejection: \${content}\`);
     }
@@ -704,6 +803,14 @@ for (const line of lines) {
   }
 }
 
+// Saved last, after every diff-detected memory, and only if it clears the
+// quality filter — diff analysis always runs regardless of commit message.
+if (isQualityCommitMessage(commitMessage)) {
+  const trimmedMessage = commitMessage.trim();
+  cmSave("decision", trimmedMessage);
+  savedItems.push(\`decision: \${trimmedMessage}\`);
+}
+
 console.log(\`coding-memory post-commit summary (\${changedFiles.length} file(s) changed):\`);
 for (const item of savedItems) {
   console.log(\`  - \${item}\`);
@@ -942,6 +1049,165 @@ async function cmdContext(project: string, task: string) {
   console.log(lines.join("\n"));
 }
 
+// --- cm session-end --------------------------------------------------------
+
+interface SessionEndInput {
+  project: string | null;
+  summary?: string;
+  errors: string[];
+  files: string[];
+  approaches: string[];
+}
+
+function splitCommaList(value: string | undefined): string[] {
+  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: string[]): SessionEndInput {
+  let project: string | null = null;
+  let summary: string | undefined;
+  let errors: string[] = [];
+  let files: string[] = [];
+  let approaches: string[] = [];
+
+  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(): Promise<Record<string, unknown> | null> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  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: string, input: Omit<SessionEndInput, "project">) {
+  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: string[]) {
+  let input: SessionEndInput;
+
+  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,
+  });
+}
+
 // --- main --------------------------------------------------------------
 
 async function main() {
@@ -1037,6 +1303,10 @@ async function main() {
       await cmdContext(project, split.rest.join(" "));
       break;
     }
+    case "session-end": {
+      await cmdSessionEndEntry(args);
+      break;
+    }
     case "help": {
       cmdHelp();
       break;

package/src/index.ts

@@ -12,6 +12,10 @@ import {
   computeMemoryLinks,
   decideSaveAction,
   estimateTokens,
+  indicatesFailedApproach,
+  isAuthRelatedFile,
+  isCodeFile,
+  isQualityMessage,
 } from "./scoring.js";
 import { supabase } from "./storage.js";
 
@@ -422,6 +426,89 @@ server.registerTool(
   }
 );
 
+// --- 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() {

package/src/scoring.ts

@@ -247,6 +247,57 @@ export function buildSummaryContent(cluster: any[]): string {
   return `[${mostCommonType.toUpperCase()} cluster] ${topic}: ${items}`;
 }
 
+// --- message quality filter ------------------------------------------------
+
+const LOW_QUALITY_PREFIXES = [
+  "wip", "fix", "update", "misc", "temp", "test", "patch", "minor",
+  "tweak", "change", "stuff", "done", "commit", "save", "ok", "m", "x",
+];
+
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+
+// Filters out lazy/placeholder messages ("wip", "fix", "m", "...") and bare
+// version bumps ("1.0.4"). Checked against the first word (and the whole
+// message), not a raw prefix match, so a real message like "Migrate auth to
+// JWT" isn't rejected just for starting with the letter "m". The git hook
+// keeps its own inline copy of this same logic since it runs as a standalone
+// script with no access to this module — keep the two in sync by hand if
+// this changes.
+export function isQualityMessage(message: string): boolean {
+  const trimmed = message.trim();
+  if (trimmed.length < 15) return false;
+  if (SEMVER_RE.test(trimmed)) return false;
+  if (!trimmed.includes(" ")) return false;
+
+  const stripped = trimmed.replace(/\s/g, "");
+  if (stripped.length > 0 && new Set(stripped).size === 1) return false;
+
+  const lowerTrimmed = trimmed.toLowerCase();
+  if (LOW_QUALITY_PREFIXES.includes(lowerTrimmed)) return false;
+
+  const firstWord = (lowerTrimmed.match(/^[a-z0-9]+/) || [""])[0];
+  if (LOW_QUALITY_PREFIXES.includes(firstWord)) return false;
+
+  return true;
+}
+
+// --- session-end classification ---------------------------------------------
+
+const FAILURE_PHRASES = ["failed", "didn't work", "reverted", "switched away"];
+
+export function indicatesFailedApproach(text: string): boolean {
+  const lower = text.toLowerCase();
+  return FAILURE_PHRASES.some((phrase) => lower.includes(phrase));
+}
+
+export function isAuthRelatedFile(filePath: string): boolean {
+  return /(auth|login|session|token)/i.test(filePath);
+}
+
+export function isCodeFile(filePath: string): boolean {
+  return /\.(ts|js)$/i.test(filePath);
+}
+
 // --- task relevance --------------------------------------------------------
 
 function splitWords(text: string): string[] {