stackmem 1.0.10 → 1.0.12

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, indicatesFailedApproach, isAuthRelatedFile, isCodeFile, isQualityMessage, scoreMemoryRelevance, } from "./scoring.js";
+import { applyContextBudget, buildSummaryContent, clusterMemories, computeDecayScore, computeMemoryLinks, decideSaveAction, estimateTokens, extractEntities, indicatesFailedApproach, isAuthRelatedFile, isCodeFile, isQualityMessage, scoreMemoryRelevance, } from "./scoring.js";
 import { supabase } from "./storage.js";
 const CONTEXT_BUDGET_TOKENS = 2000;
 const COMPRESSION_THRESHOLD = 20;
@@ -32,8 +32,10 @@ function usage() {
   cm search [--project <name>] <query>
   cm resolve [project] <memory-id>
   cm delete [project] <memory-id>
+  cm inspect [project] <memory-id>
   cm compress [project]
   cm init <project> <path>
+  cm sync
   cm context [--project <name>] <task>
   cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
   cm doctor
@@ -88,6 +90,13 @@ function cmdHelp() {
   cm delete [project] <memory-id>
       Delete a memory and any memory_links referencing it.
 
+  cm inspect [project] <memory-id>
+      Show a rich view of a single memory: type, content, created
+      date, access count, decay score, and resolved status, plus
+      every linked memory (in either link direction) with its link
+      score, and any execution_log fixes whose problem or solution
+      shares a key entity with the memory's content.
+
   cm compress [project]
       Cluster related unresolved memories (needs 20+) and collapse
       clusters of 3 or more into a single summary memory.
@@ -97,8 +106,16 @@ function cmdHelp() {
       the stackmem MCP server with Claude Code, write a CLAUDE.md,
       .cursorrules, .windsurfrules, and .stackmem file, and seed
       initial memories from the project scan. .cursorrules and
-      .windsurfrules (for Cursor and Windsurf) are skipped if they
-      already exist.
+      .windsurfrules are pre-filled with the project's current
+      memories (for Cursor and Windsurf) and skipped if they already
+      exist. The post-commit hook keeps them fresh afterward by
+      running 'cm sync' on every commit.
+
+  cm sync
+      Regenerate .cursorrules and .windsurfrules from the project's
+      current unresolved memories (decay-ranked, capped at a 2000
+      token budget) and its 5 most recent open execution_log fixes,
+      overwriting both files. Project is read from .stackmem.
 
   cm context [--project <name>] <task>
       Return only the top 5 memories most relevant to a specific
@@ -496,6 +513,86 @@ async function cmdDelete(project, memoryId) {
         fail(`Failed to delete memory: ${error.message}`);
     console.log(`Deleted memory [${memoryId}]`);
 }
+// --- cm inspect ------------------------------------------------------------
+function formatDate(dateString) {
+    return new Date(dateString).toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+    });
+}
+async function cmdInspect(project, memoryId) {
+    const { data: memory, error } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("id", memoryId)
+        .single();
+    if (error || !memory)
+        fail(`Memory [${memoryId}] not found for "${project}".`);
+    const decayScore = computeDecayScore(new Date(memory.created_at), memory.access_count ?? 0);
+    const { data: links, error: linksError } = await supabase
+        .from("memory_links")
+        .select("source_id, target_id, score")
+        .or(`source_id.eq.${memoryId},target_id.eq.${memoryId}`);
+    if (linksError)
+        fail(`Failed to load memory links: ${linksError.message}`);
+    const linkedEntries = (links ?? []).map((link) => ({
+        linkedId: link.source_id === memoryId ? link.target_id : link.source_id,
+        score: link.score,
+    }));
+    let linkedMemories = [];
+    if (linkedEntries.length > 0) {
+        const linkedIds = linkedEntries.map((entry) => entry.linkedId);
+        const { data: linkedRows, error: linkedError } = await supabase
+            .from("memories")
+            .select("id, type, content, created_at")
+            .in("id", linkedIds);
+        if (linkedError)
+            fail(`Failed to load linked memories: ${linkedError.message}`);
+        const scoreById = new Map(linkedEntries.map((entry) => [entry.linkedId, entry.score]));
+        linkedMemories = (linkedRows ?? [])
+            .map((row) => ({ ...row, score: scoreById.get(row.id) ?? 0 }))
+            .sort((a, b) => b.score - a.score);
+    }
+    const entities = extractEntities(memory.content);
+    const { data: fixes, error: fixesError } = await supabase
+        .from("execution_log")
+        .select("problem, solution")
+        .eq("project", project);
+    if (fixesError)
+        fail(`Failed to load execution log: ${fixesError.message}`);
+    const relatedFixes = (fixes ?? []).filter((fix) => {
+        const fixEntities = extractEntities(`${fix.problem} ${fix.solution}`);
+        for (const entity of entities) {
+            if (fixEntities.has(entity))
+                return true;
+        }
+        return false;
+    });
+    const divider = "─".repeat(40);
+    console.log(divider);
+    console.log(`${memory.type.toUpperCase()} · accessed ${memory.access_count ?? 0}x · decay ${decayScore.toFixed(2)}`);
+    console.log(divider);
+    console.log(memory.content);
+    console.log("");
+    console.log(`Created: ${formatDate(memory.created_at)}`);
+    console.log(`Status:  ${memory.resolved ? "resolved" : "unresolved"}`);
+    console.log("");
+    console.log(`LINKED MEMORIES (${linkedMemories.length})`);
+    for (const linked of linkedMemories) {
+        console.log(`  └─ [score: ${linked.score.toFixed(2)}] ${linked.type.toUpperCase()}`);
+        console.log(`     ${linked.content}`);
+        console.log(`     ${formatDate(linked.created_at)}`);
+        console.log("");
+    }
+    if (relatedFixes.length > 0) {
+        console.log(`RELATED FIXES (${relatedFixes.length})`);
+        for (const fix of relatedFixes) {
+            console.log(`  └─ FIX: ${fix.problem} → ${fix.solution}`);
+        }
+    }
+}
 // --- cm init -------------------------------------------------------------
 // The hook logic lives in its own .mjs file (not directly in
 // .git/hooks/post-commit) so its module type is unambiguous — an
@@ -585,6 +682,15 @@ const savedItems = [];
 
 const commitMessage = git(["log", "-1", "--pretty=%B"]);
 
+// The sync commit below is itself a commit, so it fires this same
+// post-commit hook again — git's --no-verify only skips pre-commit and
+// commit-msg hooks, never post-commit. Without this guard, the hook would
+// save its own commit message as a new decision memory, which changes the
+// rules-file content and triggers another sync commit, indefinitely.
+if (commitMessage.includes("[skip ci]")) {
+  process.exit(0);
+}
+
 const isFirstCommit = (() => {
   try {
     execFileSync("git", ["rev-parse", "HEAD~1"], { stdio: "pipe" });
@@ -747,6 +853,22 @@ console.log(\`coding-memory post-commit summary (\${changedFiles.length} file(s)
 for (const item of savedItems) {
   console.log(\`  - \${item}\`);
 }
+
+execFileSync("node", [CLI_PATH, "sync"], { stdio: "inherit" });
+
+// cm sync rewrites .cursorrules/.windsurfrules, which would otherwise leave
+// the working directory dirty (breaking things like \`npm version patch\`
+// that require a clean tree). Commit the sync ourselves instead. --no-verify
+// skips pre-commit/commit-msg hooks (not post-commit — see the [skip ci]
+// guard above, which is what actually stops this from recursing).
+try {
+  execFileSync("git", ["add", ".cursorrules", ".windsurfrules"], { stdio: "pipe" });
+  execFileSync("git", ["commit", "--no-verify", "-m", "chore: sync memory to rules files [skip ci]"], {
+    stdio: "pipe",
+  });
+} catch {
+  // Nothing to commit (rules files unchanged) — fine, ignore.
+}
 `;
 }
 function registerMcpServer(distIndexPath) {
@@ -793,40 +915,96 @@ cm save ${project} <type> "<content>"
     nodeFs.writeFileSync(claudeMdPath, content, "utf-8");
     console.log("CLAUDE.md written.");
 }
-const EDITOR_RULES_CONTENT = `# stackmem
-
-At the start of every session, run:
-cm start
-
-and paste the output here before starting work.
-
-When you make a decision, discover a constraint,
-reject an approach, or make a discovery, save it:
-cm save <type> "<content>"
-
-Types: decision, rejection, constraint, discovery
-`;
+// Section order for the generated rules-file markdown — matches the order
+// memories are presented in everywhere else (cm context's CONTEXT_TYPE_ORDER),
+// not MEMORY_TYPES' declaration order.
+const RULES_FILE_TYPE_ORDER = ["decision", "constraint", "rejection", "discovery"];
+// Builds the markdown written into .cursorrules / .windsurfrules: the
+// project's unresolved memories (decay-ranked, budget-capped so an
+// editor's system prompt never balloons) plus its most recent open fixes.
+// Shared by `cm init` (first write) and `cm sync` (refresh on every commit).
+async function generateRulesContent(project) {
+    const { data: memoryRows, error: memoriesError } = await supabase
+        .from("memories")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false);
+    if (memoriesError)
+        fail(`Failed to load memories: ${memoriesError.message}`);
+    const scoredMemories = (memoryRows ?? [])
+        .map((memory) => ({
+        ...memory,
+        decay_score: computeDecayScore(new Date(memory.created_at), memory.access_count ?? 0),
+    }))
+        .sort((a, b) => b.decay_score - a.decay_score);
+    const budgetedMemories = applyContextBudget(scoredMemories, CONTEXT_BUDGET_TOKENS);
+    const { data: fixRows, error: fixesError } = await supabase
+        .from("execution_log")
+        .select("*")
+        .eq("project", project)
+        .eq("resolved", false)
+        .order("created_at", { ascending: false })
+        .limit(5);
+    if (fixesError)
+        fail(`Failed to load execution log: ${fixesError.message}`);
+    const fixes = fixRows ?? [];
+    const lines = [];
+    lines.push("# stackmem — project memory (auto-updated)");
+    lines.push(`## Project: ${project}`);
+    if (budgetedMemories.length === 0 && fixes.length === 0) {
+        lines.push("");
+        lines.push("No memories yet. Make a commit to start capturing.");
+    }
+    else {
+        for (const type of RULES_FILE_TYPE_ORDER) {
+            const group = budgetedMemories.filter((memory) => memory.type === type);
+            if (group.length === 0)
+                continue;
+            lines.push("");
+            lines.push(`### ${TYPE_LABELS[type]}`);
+            for (const memory of group) {
+                lines.push(`- ${memory.content}`);
+            }
+        }
+        if (fixes.length > 0) {
+            lines.push("");
+            lines.push("### Recent Fixes");
+            for (const fix of fixes) {
+                const solution = fix.solution && fix.solution.trim().length > 0
+                    ? fix.solution
+                    : "(solution pending)";
+                lines.push(`- ${fix.problem} → ${solution}`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push(`*Last updated: ${new Date().toLocaleString("en-US")}*`);
+    lines.push("*Run `cm start` for full details with decay scores*");
+    lines.push("");
+    return lines.join("\n");
+}
 // Returns true if the file was written, false if it already existed
 // (and was skipped).
-function writeCursorRules(resolvedPath) {
+function writeCursorRules(resolvedPath, content) {
     const cursorRulesPath = nodePath.join(resolvedPath, ".cursorrules");
     if (nodeFs.existsSync(cursorRulesPath)) {
         console.log(".cursorrules already exists — skipping.");
         return false;
     }
-    nodeFs.writeFileSync(cursorRulesPath, EDITOR_RULES_CONTENT, "utf-8");
+    nodeFs.writeFileSync(cursorRulesPath, content, "utf-8");
     console.log(".cursorrules written.");
     return true;
 }
 // Returns true if the file was written, false if it already existed
 // (and was skipped).
-function writeWindsurfRules(resolvedPath) {
+function writeWindsurfRules(resolvedPath, content) {
     const windsurfRulesPath = nodePath.join(resolvedPath, ".windsurfrules");
     if (nodeFs.existsSync(windsurfRulesPath)) {
         console.log(".windsurfrules already exists — skipping.");
         return false;
     }
-    nodeFs.writeFileSync(windsurfRulesPath, EDITOR_RULES_CONTENT, "utf-8");
+    nodeFs.writeFileSync(windsurfRulesPath, content, "utf-8");
     console.log(".windsurfrules written.");
     return true;
 }
@@ -928,10 +1106,11 @@ async function cmdInit(project, targetPath) {
     console.log(`coding-memory hook installed for project ${project} at ${targetPath}`);
     registerMcpServer(DIST_INDEX_PATH);
     writeClaudeMd(project, resolvedPath);
-    const cursorRulesWritten = writeCursorRules(resolvedPath);
-    const windsurfRulesWritten = writeWindsurfRules(resolvedPath);
     const seededCount = await seedMemories(project, resolvedPath);
     console.log(`Seeded ${seededCount} initial memories from project scan.`);
+    const rulesContent = await generateRulesContent(project);
+    const cursorRulesWritten = writeCursorRules(resolvedPath, rulesContent);
+    const windsurfRulesWritten = writeWindsurfRules(resolvedPath, rulesContent);
     const backendOk = await verifyBackendConnection(project);
     console.log("");
     console.log("✓ Git hook installed");
@@ -953,6 +1132,14 @@ async function cmdInit(project, targetPath) {
     // .stackmem pointed to before this run, not the one being initialized now.
     writeProjectFile(project, resolvedPath);
 }
+// --- cm sync ---------------------------------------------------------------
+async function cmdSync(project) {
+    const resolvedPath = process.cwd();
+    const rulesContent = await generateRulesContent(project);
+    nodeFs.writeFileSync(nodePath.join(resolvedPath, ".cursorrules"), rulesContent, "utf-8");
+    nodeFs.writeFileSync(nodePath.join(resolvedPath, ".windsurfrules"), rulesContent, "utf-8");
+    console.log("Synced memories to .cursorrules and .windsurfrules");
+}
 // --- cm context ------------------------------------------------------------
 const CONTEXT_TYPE_ORDER = ["decision", "constraint", "rejection", "discovery"];
 const CONTEXT_TOP_N = 5;
@@ -1418,6 +1605,15 @@ async function main() {
             await cmdDelete(project, memoryId);
             break;
         }
+        case "inspect": {
+            const split = splitOptionalProject(args, 1);
+            if (!split)
+                usage();
+            const project = requireProject(split.project);
+            const [memoryId] = split.rest;
+            await cmdInspect(project, memoryId);
+            break;
+        }
         case "compress": {
             const split = splitOptionalProject(args, 0);
             if (!split)
@@ -1433,6 +1629,13 @@ async function main() {
             await cmdInit(project, targetPath);
             break;
         }
+        case "sync": {
+            if (args.length > 0)
+                usage();
+            const project = requireProject(null);
+            await cmdSync(project);
+            break;
+        }
         case "context": {
             const split = splitProjectFromVariadic(args);
             const project = requireProject(split.project);

package/package.json

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

package/src/cli.ts

@@ -14,6 +14,7 @@ import {
   computeMemoryLinks,
   decideSaveAction,
   estimateTokens,
+  extractEntities,
   indicatesFailedApproach,
   isAuthRelatedFile,
   isCodeFile,
@@ -50,8 +51,10 @@ function usage(): never {
   cm search [--project <name>] <query>
   cm resolve [project] <memory-id>
   cm delete [project] <memory-id>
+  cm inspect [project] <memory-id>
   cm compress [project]
   cm init <project> <path>
+  cm sync
   cm context [--project <name>] <task>
   cm session-end [project] [--summary <text>] [--errors <a,b>] [--files <a,b>] [--approaches <a,b>]
   cm doctor
@@ -107,6 +110,13 @@ function cmdHelp() {
   cm delete [project] <memory-id>
       Delete a memory and any memory_links referencing it.
 
+  cm inspect [project] <memory-id>
+      Show a rich view of a single memory: type, content, created
+      date, access count, decay score, and resolved status, plus
+      every linked memory (in either link direction) with its link
+      score, and any execution_log fixes whose problem or solution
+      shares a key entity with the memory's content.
+
   cm compress [project]
       Cluster related unresolved memories (needs 20+) and collapse
       clusters of 3 or more into a single summary memory.
@@ -116,8 +126,16 @@ function cmdHelp() {
       the stackmem MCP server with Claude Code, write a CLAUDE.md,
       .cursorrules, .windsurfrules, and .stackmem file, and seed
       initial memories from the project scan. .cursorrules and
-      .windsurfrules (for Cursor and Windsurf) are skipped if they
-      already exist.
+      .windsurfrules are pre-filled with the project's current
+      memories (for Cursor and Windsurf) and skipped if they already
+      exist. The post-commit hook keeps them fresh afterward by
+      running 'cm sync' on every commit.
+
+  cm sync
+      Regenerate .cursorrules and .windsurfrules from the project's
+      current unresolved memories (decay-ranked, capped at a 2000
+      token budget) and its 5 most recent open execution_log fixes,
+      overwriting both files. Project is read from .stackmem.
 
   cm context [--project <name>] <task>
       Return only the top 5 memories most relevant to a specific
@@ -593,6 +611,107 @@ async function cmdDelete(project: string, memoryId: string) {
   console.log(`Deleted memory [${memoryId}]`);
 }
 
+// --- cm inspect ------------------------------------------------------------
+
+function formatDate(dateString: string): string {
+  return new Date(dateString).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+}
+
+async function cmdInspect(project: string, memoryId: string) {
+  const { data: memory, error } = await supabase
+    .from("memories")
+    .select("*")
+    .eq("project", project)
+    .eq("id", memoryId)
+    .single();
+
+  if (error || !memory) fail(`Memory [${memoryId}] not found for "${project}".`);
+
+  const decayScore = computeDecayScore(new Date(memory.created_at), memory.access_count ?? 0);
+
+  const { data: links, error: linksError } = await supabase
+    .from("memory_links")
+    .select("source_id, target_id, score")
+    .or(`source_id.eq.${memoryId},target_id.eq.${memoryId}`);
+
+  if (linksError) fail(`Failed to load memory links: ${linksError.message}`);
+
+  const linkedEntries = (links ?? []).map((link) => ({
+    linkedId: link.source_id === memoryId ? link.target_id : link.source_id,
+    score: link.score,
+  }));
+
+  let linkedMemories: Array<{
+    id: string;
+    type: string;
+    content: string;
+    created_at: string;
+    score: number;
+  }> = [];
+
+  if (linkedEntries.length > 0) {
+    const linkedIds = linkedEntries.map((entry) => entry.linkedId);
+    const { data: linkedRows, error: linkedError } = await supabase
+      .from("memories")
+      .select("id, type, content, created_at")
+      .in("id", linkedIds);
+
+    if (linkedError) fail(`Failed to load linked memories: ${linkedError.message}`);
+
+    const scoreById = new Map(linkedEntries.map((entry) => [entry.linkedId, entry.score]));
+    linkedMemories = (linkedRows ?? [])
+      .map((row) => ({ ...row, score: scoreById.get(row.id) ?? 0 }))
+      .sort((a, b) => b.score - a.score);
+  }
+
+  const entities = extractEntities(memory.content);
+  const { data: fixes, error: fixesError } = await supabase
+    .from("execution_log")
+    .select("problem, solution")
+    .eq("project", project);
+
+  if (fixesError) fail(`Failed to load execution log: ${fixesError.message}`);
+
+  const relatedFixes = (fixes ?? []).filter((fix) => {
+    const fixEntities = extractEntities(`${fix.problem} ${fix.solution}`);
+    for (const entity of entities) {
+      if (fixEntities.has(entity)) return true;
+    }
+    return false;
+  });
+
+  const divider = "─".repeat(40);
+  console.log(divider);
+  console.log(
+    `${memory.type.toUpperCase()} · accessed ${memory.access_count ?? 0}x · decay ${decayScore.toFixed(2)}`
+  );
+  console.log(divider);
+  console.log(memory.content);
+  console.log("");
+  console.log(`Created: ${formatDate(memory.created_at)}`);
+  console.log(`Status:  ${memory.resolved ? "resolved" : "unresolved"}`);
+  console.log("");
+
+  console.log(`LINKED MEMORIES (${linkedMemories.length})`);
+  for (const linked of linkedMemories) {
+    console.log(`  └─ [score: ${linked.score.toFixed(2)}] ${linked.type.toUpperCase()}`);
+    console.log(`     ${linked.content}`);
+    console.log(`     ${formatDate(linked.created_at)}`);
+    console.log("");
+  }
+
+  if (relatedFixes.length > 0) {
+    console.log(`RELATED FIXES (${relatedFixes.length})`);
+    for (const fix of relatedFixes) {
+      console.log(`  └─ FIX: ${fix.problem} → ${fix.solution}`);
+    }
+  }
+}
+
 // --- cm init -------------------------------------------------------------
 
 // The hook logic lives in its own .mjs file (not directly in
@@ -683,6 +802,15 @@ const savedItems = [];
 
 const commitMessage = git(["log", "-1", "--pretty=%B"]);
 
+// The sync commit below is itself a commit, so it fires this same
+// post-commit hook again — git's --no-verify only skips pre-commit and
+// commit-msg hooks, never post-commit. Without this guard, the hook would
+// save its own commit message as a new decision memory, which changes the
+// rules-file content and triggers another sync commit, indefinitely.
+if (commitMessage.includes("[skip ci]")) {
+  process.exit(0);
+}
+
 const isFirstCommit = (() => {
   try {
     execFileSync("git", ["rev-parse", "HEAD~1"], { stdio: "pipe" });
@@ -845,6 +973,22 @@ console.log(\`coding-memory post-commit summary (\${changedFiles.length} file(s)
 for (const item of savedItems) {
   console.log(\`  - \${item}\`);
 }
+
+execFileSync("node", [CLI_PATH, "sync"], { stdio: "inherit" });
+
+// cm sync rewrites .cursorrules/.windsurfrules, which would otherwise leave
+// the working directory dirty (breaking things like \`npm version patch\`
+// that require a clean tree). Commit the sync ourselves instead. --no-verify
+// skips pre-commit/commit-msg hooks (not post-commit — see the [skip ci]
+// guard above, which is what actually stops this from recursing).
+try {
+  execFileSync("git", ["add", ".cursorrules", ".windsurfrules"], { stdio: "pipe" });
+  execFileSync("git", ["commit", "--no-verify", "-m", "chore: sync memory to rules files [skip ci]"], {
+    stdio: "pipe",
+  });
+} catch {
+  // Nothing to commit (rules files unchanged) — fine, ignore.
+}
 `;
 }
 
@@ -901,23 +1045,88 @@ cm save ${project} <type> "<content>"
   console.log("CLAUDE.md written.");
 }
 
-const EDITOR_RULES_CONTENT = `# stackmem
+// Section order for the generated rules-file markdown — matches the order
+// memories are presented in everywhere else (cm context's CONTEXT_TYPE_ORDER),
+// not MEMORY_TYPES' declaration order.
+const RULES_FILE_TYPE_ORDER: MemoryType[] = ["decision", "constraint", "rejection", "discovery"];
+
+// Builds the markdown written into .cursorrules / .windsurfrules: the
+// project's unresolved memories (decay-ranked, budget-capped so an
+// editor's system prompt never balloons) plus its most recent open fixes.
+// Shared by `cm init` (first write) and `cm sync` (refresh on every commit).
+async function generateRulesContent(project: string): Promise<string> {
+  const { data: memoryRows, error: memoriesError } = await supabase
+    .from("memories")
+    .select("*")
+    .eq("project", project)
+    .eq("resolved", false);
 
-At the start of every session, run:
-cm start
+  if (memoriesError) fail(`Failed to load memories: ${memoriesError.message}`);
 
-and paste the output here before starting work.
+  const scoredMemories = (memoryRows ?? [])
+    .map((memory) => ({
+      ...memory,
+      decay_score: computeDecayScore(new Date(memory.created_at), memory.access_count ?? 0),
+    }))
+    .sort((a, b) => b.decay_score - a.decay_score);
 
-When you make a decision, discover a constraint,
-reject an approach, or make a discovery, save it:
-cm save <type> "<content>"
+  const budgetedMemories = applyContextBudget(scoredMemories, CONTEXT_BUDGET_TOKENS);
 
-Types: decision, rejection, constraint, discovery
-`;
+  const { data: fixRows, error: fixesError } = await supabase
+    .from("execution_log")
+    .select("*")
+    .eq("project", project)
+    .eq("resolved", false)
+    .order("created_at", { ascending: false })
+    .limit(5);
+
+  if (fixesError) fail(`Failed to load execution log: ${fixesError.message}`);
+
+  const fixes = fixRows ?? [];
+
+  const lines: string[] = [];
+  lines.push("# stackmem — project memory (auto-updated)");
+  lines.push(`## Project: ${project}`);
+
+  if (budgetedMemories.length === 0 && fixes.length === 0) {
+    lines.push("");
+    lines.push("No memories yet. Make a commit to start capturing.");
+  } else {
+    for (const type of RULES_FILE_TYPE_ORDER) {
+      const group = budgetedMemories.filter((memory) => memory.type === type);
+      if (group.length === 0) continue;
+
+      lines.push("");
+      lines.push(`### ${TYPE_LABELS[type]}`);
+      for (const memory of group) {
+        lines.push(`- ${memory.content}`);
+      }
+    }
+
+    if (fixes.length > 0) {
+      lines.push("");
+      lines.push("### Recent Fixes");
+      for (const fix of fixes) {
+        const solution = fix.solution && fix.solution.trim().length > 0
+          ? fix.solution
+          : "(solution pending)";
+        lines.push(`- ${fix.problem} → ${solution}`);
+      }
+    }
+  }
+
+  lines.push("");
+  lines.push("---");
+  lines.push(`*Last updated: ${new Date().toLocaleString("en-US")}*`);
+  lines.push("*Run `cm start` for full details with decay scores*");
+  lines.push("");
+
+  return lines.join("\n");
+}
 
 // Returns true if the file was written, false if it already existed
 // (and was skipped).
-function writeCursorRules(resolvedPath: string): boolean {
+function writeCursorRules(resolvedPath: string, content: string): boolean {
   const cursorRulesPath = nodePath.join(resolvedPath, ".cursorrules");
 
   if (nodeFs.existsSync(cursorRulesPath)) {
@@ -925,14 +1134,14 @@ function writeCursorRules(resolvedPath: string): boolean {
     return false;
   }
 
-  nodeFs.writeFileSync(cursorRulesPath, EDITOR_RULES_CONTENT, "utf-8");
+  nodeFs.writeFileSync(cursorRulesPath, content, "utf-8");
   console.log(".cursorrules written.");
   return true;
 }
 
 // Returns true if the file was written, false if it already existed
 // (and was skipped).
-function writeWindsurfRules(resolvedPath: string): boolean {
+function writeWindsurfRules(resolvedPath: string, content: string): boolean {
   const windsurfRulesPath = nodePath.join(resolvedPath, ".windsurfrules");
 
   if (nodeFs.existsSync(windsurfRulesPath)) {
@@ -940,7 +1149,7 @@ function writeWindsurfRules(resolvedPath: string): boolean {
     return false;
   }
 
-  nodeFs.writeFileSync(windsurfRulesPath, EDITOR_RULES_CONTENT, "utf-8");
+  nodeFs.writeFileSync(windsurfRulesPath, content, "utf-8");
   console.log(".windsurfrules written.");
   return true;
 }
@@ -1058,12 +1267,14 @@ async function cmdInit(project: string, targetPath: string) {
 
   registerMcpServer(DIST_INDEX_PATH);
   writeClaudeMd(project, resolvedPath);
-  const cursorRulesWritten = writeCursorRules(resolvedPath);
-  const windsurfRulesWritten = writeWindsurfRules(resolvedPath);
 
   const seededCount = await seedMemories(project, resolvedPath);
   console.log(`Seeded ${seededCount} initial memories from project scan.`);
 
+  const rulesContent = await generateRulesContent(project);
+  const cursorRulesWritten = writeCursorRules(resolvedPath, rulesContent);
+  const windsurfRulesWritten = writeWindsurfRules(resolvedPath, rulesContent);
+
   const backendOk = await verifyBackendConnection(project);
 
   console.log("");
@@ -1093,6 +1304,18 @@ async function cmdInit(project: string, targetPath: string) {
   writeProjectFile(project, resolvedPath);
 }
 
+// --- cm sync ---------------------------------------------------------------
+
+async function cmdSync(project: string) {
+  const resolvedPath = process.cwd();
+  const rulesContent = await generateRulesContent(project);
+
+  nodeFs.writeFileSync(nodePath.join(resolvedPath, ".cursorrules"), rulesContent, "utf-8");
+  nodeFs.writeFileSync(nodePath.join(resolvedPath, ".windsurfrules"), rulesContent, "utf-8");
+
+  console.log("Synced memories to .cursorrules and .windsurfrules");
+}
+
 // --- cm context ------------------------------------------------------------
 
 const CONTEXT_TYPE_ORDER: MemoryType[] = ["decision", "constraint", "rejection", "discovery"];
@@ -1600,6 +1823,14 @@ async function main() {
       await cmdDelete(project, memoryId);
       break;
     }
+    case "inspect": {
+      const split = splitOptionalProject(args, 1);
+      if (!split) usage();
+      const project = requireProject(split.project);
+      const [memoryId] = split.rest;
+      await cmdInspect(project, memoryId);
+      break;
+    }
     case "compress": {
       const split = splitOptionalProject(args, 0);
       if (!split) usage();
@@ -1613,6 +1844,12 @@ async function main() {
       await cmdInit(project, targetPath);
       break;
     }
+    case "sync": {
+      if (args.length > 0) usage();
+      const project = requireProject(null);
+      await cmdSync(project);
+      break;
+    }
     case "context": {
       const split = splitProjectFromVariadic(args);
       const project = requireProject(split.project);

package/src/tools.ts

@@ -0,0 +1 @@
+const test = 1