@locusai/cli 0.25.6 → 0.26.1

package/bin/locus.js

@@ -1880,6 +1880,210 @@ var init_github = __esm(() => {
   init_rate_limiter();
 });
 
+// src/core/memory.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+import {
+  appendFile,
+  mkdir,
+  readFile,
+  stat,
+  unlink,
+  writeFile
+} from "node:fs/promises";
+import { join as join6 } from "node:path";
+function getMemoryDir(projectRoot) {
+  return join6(projectRoot, ".locus", MEMORY_DIR);
+}
+async function ensureMemoryDir(projectRoot) {
+  const dir = getMemoryDir(projectRoot);
+  await mkdir(dir, { recursive: true });
+  for (const category of Object.values(MEMORY_CATEGORIES)) {
+    const filePath = join6(dir, category.file);
+    if (!existsSync6(filePath)) {
+      const header = `# ${category.title}
+
+${category.description}
+
+`;
+      await writeFile(filePath, header, "utf-8");
+    }
+  }
+}
+async function readMemoryFile(projectRoot, category) {
+  const meta = MEMORY_CATEGORIES[category];
+  if (!meta)
+    return "";
+  const filePath = join6(getMemoryDir(projectRoot), meta.file);
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function readAllMemory(projectRoot) {
+  const parts = [];
+  for (const category of Object.keys(MEMORY_CATEGORIES)) {
+    const content = await readMemoryFile(projectRoot, category);
+    if (content.trim()) {
+      parts.push(content.trim());
+    }
+  }
+  return parts.join(`
+
+`);
+}
+function readAllMemorySync(projectRoot) {
+  const dir = getMemoryDir(projectRoot);
+  if (!existsSync6(dir))
+    return "";
+  const parts = [];
+  for (const meta of Object.values(MEMORY_CATEGORIES)) {
+    const filePath = join6(dir, meta.file);
+    try {
+      const content = readFileSync4(filePath, "utf-8").trim();
+      if (content)
+        parts.push(content);
+    } catch {}
+  }
+  return parts.join(`
+
+`);
+}
+async function appendMemoryEntries(projectRoot, entries) {
+  const dir = getMemoryDir(projectRoot);
+  for (const entry of entries) {
+    const meta = MEMORY_CATEGORIES[entry.category];
+    if (!meta)
+      continue;
+    const filePath = join6(dir, meta.file);
+    const line = `- **[${meta.title}]**: ${entry.text}
+`;
+    await appendFile(filePath, line, "utf-8");
+  }
+}
+function resolveLearningsCategory(tag) {
+  return LEARNINGS_CATEGORY_MAP[tag.toLowerCase()] ?? "conventions";
+}
+async function migrateFromLearnings(projectRoot) {
+  const learningsPath = join6(projectRoot, ".locus", "LEARNINGS.md");
+  let content;
+  try {
+    content = await readFile(learningsPath, "utf-8");
+  } catch {
+    return { migrated: 0, skipped: 0 };
+  }
+  if (!content.trim()) {
+    return { migrated: 0, skipped: 0 };
+  }
+  const entryPattern = /^- \*\*\[([^\]]+)\]\*\*:\s*/;
+  const lines = content.split(`
+`);
+  const parsed = [];
+  for (let i = 0;i < lines.length; i++) {
+    const match = lines[i].match(entryPattern);
+    if (!match)
+      continue;
+    const tag = match[1];
+    const category = resolveLearningsCategory(tag);
+    let text = lines[i].slice(match[0].length);
+    for (let j = i + 1;j < lines.length; j++) {
+      if (lines[j].match(entryPattern) || lines[j].trim() === "")
+        break;
+      text += `
+${lines[j]}`;
+      i = j;
+    }
+    parsed.push({ category, text: text.trim() });
+  }
+  if (parsed.length === 0) {
+    return { migrated: 0, skipped: 0 };
+  }
+  await ensureMemoryDir(projectRoot);
+  const existingContent = {};
+  for (const key of Object.keys(MEMORY_CATEGORIES)) {
+    existingContent[key] = await readMemoryFile(projectRoot, key);
+  }
+  let migrated = 0;
+  let skipped = 0;
+  for (const entry of parsed) {
+    const existing = existingContent[entry.category] ?? "";
+    if (existing.includes(entry.text)) {
+      skipped++;
+      continue;
+    }
+    await appendMemoryEntries(projectRoot, [entry]);
+    existingContent[entry.category] = (existingContent[entry.category] ?? "") + `- **[${MEMORY_CATEGORIES[entry.category]?.title}]**: ${entry.text}
+`;
+    migrated++;
+  }
+  if (migrated > 0 || skipped > 0) {
+    try {
+      await unlink(learningsPath);
+    } catch {}
+  }
+  return { migrated, skipped };
+}
+async function getMemoryStats(projectRoot) {
+  const dir = getMemoryDir(projectRoot);
+  const result = {};
+  for (const [key, meta] of Object.entries(MEMORY_CATEGORIES)) {
+    const filePath = join6(dir, meta.file);
+    try {
+      const [content, fileStat] = await Promise.all([
+        readFile(filePath, "utf-8"),
+        stat(filePath)
+      ]);
+      const count = content.split(`
+`).filter((line) => line.startsWith("- ")).length;
+      result[key] = {
+        count,
+        size: fileStat.size,
+        lastModified: fileStat.mtime
+      };
+    } catch {
+      result[key] = { count: 0, size: 0, lastModified: new Date(0) };
+    }
+  }
+  return result;
+}
+var MEMORY_DIR = "memory", MEMORY_CATEGORIES, LEARNINGS_CATEGORY_MAP;
+var init_memory = __esm(() => {
+  MEMORY_CATEGORIES = {
+    architecture: {
+      file: "architecture.md",
+      title: "Architecture",
+      description: "Package ownership, module boundaries, data flow"
+    },
+    conventions: {
+      file: "conventions.md",
+      title: "Conventions",
+      description: "Code style, naming, patterns"
+    },
+    decisions: {
+      file: "decisions.md",
+      title: "Decisions",
+      description: "Trade-off rationale: why X over Y"
+    },
+    preferences: {
+      file: "preferences.md",
+      title: "Preferences",
+      description: "User corrections, rejected approaches"
+    },
+    debugging: {
+      file: "debugging.md",
+      title: "Debugging",
+      description: "Non-obvious gotchas, environment quirks"
+    }
+  };
+  LEARNINGS_CATEGORY_MAP = {
+    architecture: "architecture",
+    conventions: "conventions",
+    packages: "architecture",
+    "user preferences": "preferences",
+    debugging: "debugging"
+  };
+});
+
 // src/types.ts
 var PRIORITY_LABELS, TYPE_LABELS, STATUS_LABELS, AGENT_LABEL, ALL_LABELS;
 var init_types = __esm(() => {
@@ -1937,8 +2141,8 @@ var exports_init = {};
 __export(exports_init, {
   initCommand: () => initCommand
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join7 } from "node:path";
 async function initCommand(cwd) {
   const log = getLogger();
   process.stderr.write(`
@@ -1982,23 +2186,47 @@ ${bold2("Initializing Locus...")}
   }
   process.stderr.write(`${green("✓")} Repository: ${bold2(`${context.owner}/${context.repo}`)} (branch: ${context.defaultBranch})
 `);
-  const locusDir = join6(cwd, ".locus");
+  const locusDir = join7(cwd, ".locus");
   const dirs = [
     locusDir,
-    join6(locusDir, "sessions"),
-    join6(locusDir, "discussions"),
-    join6(locusDir, "artifacts"),
-    join6(locusDir, "plans"),
-    join6(locusDir, "logs"),
-    join6(locusDir, "run-state")
+    join7(locusDir, "sessions"),
+    join7(locusDir, "discussions"),
+    join7(locusDir, "artifacts"),
+    join7(locusDir, "plans"),
+    join7(locusDir, "logs"),
+    join7(locusDir, "run-state")
   ];
   for (const dir of dirs) {
-    if (!existsSync6(dir)) {
+    if (!existsSync7(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
   }
   process.stderr.write(`${green("✓")} Created .locus/ directory structure
 `);
+  const memoryDirExists = existsSync7(getMemoryDir(cwd));
+  await ensureMemoryDir(cwd);
+  if (!memoryDirExists) {
+    process.stderr.write(`${green("✓")} Created .locus/memory/ with category files
+`);
+  } else {
+    process.stderr.write(`${dim2("○")} .locus/memory/ already exists (preserved)
+`);
+  }
+  if (existsSync7(join7(locusDir, "LEARNINGS.md"))) {
+    const result = await migrateFromLearnings(cwd);
+    if (result.migrated > 0) {
+      process.stderr.write(`${green("✓")} Migrated ${result.migrated} entries from LEARNINGS.md to .locus/memory/
+`);
+    }
+    if (result.skipped > 0) {
+      process.stderr.write(`${dim2("○")} Skipped ${result.skipped} duplicate entries during migration
+`);
+    }
+    if (result.migrated > 0 || result.skipped > 0) {
+      process.stderr.write(`${green("✓")} Removed legacy LEARNINGS.md
+`);
+    }
+  }
   const isReInit = isInitialized(cwd);
   const config = {
     ...DEFAULT_CONFIG2,
@@ -2014,7 +2242,7 @@ ${bold2("Initializing Locus...")}
   };
   if (isReInit) {
     try {
-      const existing = JSON.parse(readFileSync4(join6(locusDir, "config.json"), "utf-8"));
+      const existing = JSON.parse(readFileSync5(join7(locusDir, "config.json"), "utf-8"));
       if (existing.ai)
         config.ai = { ...config.ai, ...existing.ai };
       if (existing.agent)
@@ -2035,8 +2263,8 @@ ${bold2("Initializing Locus...")}
 `);
   }
   saveConfig(cwd, config);
-  const locusMdPath = join6(locusDir, "LOCUS.md");
-  if (!existsSync6(locusMdPath)) {
+  const locusMdPath = join7(locusDir, "LOCUS.md");
+  if (!existsSync7(locusMdPath)) {
     writeFileSync4(locusMdPath, LOCUS_MD_TEMPLATE, "utf-8");
     process.stderr.write(`${green("✓")} Generated LOCUS.md (edit to add project context)
 `);
@@ -2044,17 +2272,8 @@ ${bold2("Initializing Locus...")}
     process.stderr.write(`${dim2("○")} LOCUS.md already exists (preserved)
 `);
   }
-  const learningsMdPath = join6(locusDir, "LEARNINGS.md");
-  if (!existsSync6(learningsMdPath)) {
-    writeFileSync4(learningsMdPath, LEARNINGS_MD_TEMPLATE, "utf-8");
-    process.stderr.write(`${green("✓")} Generated LEARNINGS.md
-`);
-  } else {
-    process.stderr.write(`${dim2("○")} LEARNINGS.md already exists (preserved)
-`);
-  }
-  const sandboxIgnorePath = join6(cwd, ".sandboxignore");
-  if (!existsSync6(sandboxIgnorePath)) {
+  const sandboxIgnorePath = join7(cwd, ".sandboxignore");
+  if (!existsSync7(sandboxIgnorePath)) {
     writeFileSync4(sandboxIgnorePath, SANDBOXIGNORE_TEMPLATE, "utf-8");
     process.stderr.write(`${green("✓")} Generated .sandboxignore
 `);
@@ -2063,8 +2282,8 @@ ${bold2("Initializing Locus...")}
 `);
   }
   const ecosystem = detectProjectEcosystem(cwd);
-  const sandboxSetupPath = join6(locusDir, "sandbox-setup.sh");
-  if (!existsSync6(sandboxSetupPath)) {
+  const sandboxSetupPath = join7(locusDir, "sandbox-setup.sh");
+  if (!existsSync7(sandboxSetupPath)) {
     const template = generateSandboxSetupTemplate(ecosystem);
     if (template) {
       writeFileSync4(sandboxSetupPath, template, {
@@ -2087,10 +2306,10 @@ ${bold2("Initializing Locus...")}
     process.stderr.write(`\r${yellow2("⚠")} Some labels could not be created: ${e.message}
 `);
   }
-  const gitignorePath = join6(cwd, ".gitignore");
+  const gitignorePath = join7(cwd, ".gitignore");
   let gitignoreContent = "";
-  if (existsSync6(gitignorePath)) {
-    gitignoreContent = readFileSync4(gitignorePath, "utf-8");
+  if (existsSync7(gitignorePath)) {
+    gitignoreContent = readFileSync5(gitignorePath, "utf-8");
   }
   const entriesToAdd = GITIGNORE_ENTRIES.filter((entry) => entry && !gitignoreContent.includes(entry.trim()));
   if (entriesToAdd.length > 0) {
@@ -2222,12 +2441,19 @@ When a task produces knowledge, analysis, or research output rather than (or in
 
 ## Continuous Learning (MANDATORY)
 
-**CRITICAL: Updating \`.locus/LEARNINGS.md\` is a required step, not optional.** You MUST read it before starting work AND update it before finishing if you learned anything worth recording. Failing to update learnings when a reusable lesson was discovered is a defect — treat it with the same severity as forgetting to run tests.
+**CRITICAL: Updating \`.locus/memory/\` is a required step, not optional.** You MUST read memory files before starting work AND update them before finishing if you learned anything worth recording. Failing to update memory when a reusable lesson was discovered is a defect — treat it with the same severity as forgetting to run tests.
+
+**Memory is organized into 5 category files in \`.locus/memory/\`:**
+- \`architecture.md\` — Package ownership, module boundaries, data flow
+- \`conventions.md\` — Code style, naming, patterns
+- \`decisions.md\` — Trade-off rationale: why X over Y
+- \`preferences.md\` — User corrections, rejected approaches
+- \`debugging.md\` — Non-obvious gotchas, environment quirks
 
 **Workflow:**
-1. **Read** \`.locus/LEARNINGS.md\` at the start of every task
+1. **Read** files in \`.locus/memory/\` at the start of every task
 2. **During execution**, note any reusable lessons (architectural discoveries, user corrections, non-obvious constraints)
-3. **Before finishing**, append new entries to \`.locus/LEARNINGS.md\` if any were discovered. Do this as one of your final steps, alongside running tests and linters
+3. **Before finishing**, append new entries to the appropriate category file in \`.locus/memory/\`. Do this as one of your final steps, alongside running tests and linters
 
 **The quality bar:** Ask yourself — "Would a new agent working on a completely different task benefit from knowing this?" If yes, record it. If it only matters for the current task or file, skip it.
 
@@ -2253,19 +2479,19 @@ When a task produces knowledge, analysis, or research output rather than (or in
 **Good examples:**
 - \`[Architecture]\`: Shared types for all packages live in \`@locusai/shared\` — never redefine them locally in CLI or API packages.
 - \`[User Preferences]\`: User prefers not to track low-level interrupt/signal handling patterns in learnings — focus on architectural and decision-level entries.
-- \`[Packages]\`: Validation uses Zod throughout — do not introduce a second validation library.
+- \`[Conventions]\`: Validation uses Zod throughout — do not introduce a second validation library.
 
 **Bad examples (do not write these):**
-- \`[Patterns]\`: \`run.ts\` must call \`registerShutdownHandlers()\` at startup. ← too local, obvious from the file.
+- \`[Conventions]\`: \`run.ts\` must call \`registerShutdownHandlers()\` at startup. ← too local, obvious from the file.
 - \`[Debugging]\`: Fixed a regex bug in \`image-detect.ts\`. ← one-time fix, irrelevant to future tasks.
 
-**Format (append-only, never delete):**
+**Format (append to the appropriate category file):**
 
 \`\`\`
 - **[Category]**: Concise description (1-2 lines max). *Rationale if non-obvious.*
 \`\`\`
 
-**Categories:** Architecture, Packages, User Preferences, Conventions, Debugging
+**Categories:** Architecture, Conventions, Decisions, Preferences, Debugging
 
 ## Error Handling
 
@@ -2317,12 +2543,6 @@ service-account*.json
 
 # Docker secrets
 docker-compose.override.yml
-`, LEARNINGS_MD_TEMPLATE = `# Learnings
-
-This file captures important lessons, decisions, and corrections made during development.
-It is read by AI agents before every task to avoid repeating mistakes and to follow established patterns.
-
-<!-- Add learnings below this line. Format: - **[Category]**: Description -->
 `, GITIGNORE_ENTRIES;
 var init_init = __esm(() => {
   init_config();
@@ -2330,9 +2550,10 @@ var init_init = __esm(() => {
   init_ecosystem();
   init_github();
   init_logger();
+  init_memory();
   init_terminal();
   init_types();
-  GITIGNORE_ENTRIES = ["", "# Locus", ".locus/", "!.locus/LEARNINGS.md"];
+  GITIGNORE_ENTRIES = ["", "# Locus", ".locus/", "!.locus/memory/"];
 });
 
 // src/commands/create.ts
@@ -2341,8 +2562,8 @@ __export(exports_create, {
   createCommand: () => createCommand
 });
 import { execSync as execSync5 } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
 function validateName(name) {
   if (!name)
     return "Package name is required.";
@@ -2614,8 +2835,8 @@ ${bold2("Creating package:")} ${cyan2(fullNpmName)}
   }
   process.stderr.write(`${green("✓")} Name is valid: ${bold2(name)}
 `);
-  const packagesDir = join7(process.cwd(), "packages", name);
-  if (existsSync7(packagesDir)) {
+  const packagesDir = join8(process.cwd(), "packages", name);
+  if (existsSync8(packagesDir)) {
     process.stderr.write(`${red2("✗")} Directory already exists: ${bold2(`packages/${name}/`)}
 `);
     process.exit(1);
@@ -2632,37 +2853,37 @@ ${bold2("Creating package:")} ${cyan2(fullNpmName)}
   let sdkVersion = "0.22.0";
   let gatewayVersion = "0.22.0";
   try {
-    const { readFileSync: readFileSync5 } = await import("node:fs");
-    const sdkPkgPath = join7(process.cwd(), "packages", "sdk", "package.json");
-    if (existsSync7(sdkPkgPath)) {
-      const sdkPkg = JSON.parse(readFileSync5(sdkPkgPath, "utf-8"));
+    const { readFileSync: readFileSync6 } = await import("node:fs");
+    const sdkPkgPath = join8(process.cwd(), "packages", "sdk", "package.json");
+    if (existsSync8(sdkPkgPath)) {
+      const sdkPkg = JSON.parse(readFileSync6(sdkPkgPath, "utf-8"));
       if (sdkPkg.version)
         sdkVersion = sdkPkg.version;
     }
-    const gatewayPkgPath = join7(process.cwd(), "packages", "gateway", "package.json");
-    if (existsSync7(gatewayPkgPath)) {
-      const gatewayPkg = JSON.parse(readFileSync5(gatewayPkgPath, "utf-8"));
+    const gatewayPkgPath = join8(process.cwd(), "packages", "gateway", "package.json");
+    if (existsSync8(gatewayPkgPath)) {
+      const gatewayPkg = JSON.parse(readFileSync6(gatewayPkgPath, "utf-8"));
       if (gatewayPkg.version)
         gatewayVersion = gatewayPkg.version;
     }
   } catch {}
-  mkdirSync6(join7(packagesDir, "src"), { recursive: true });
-  mkdirSync6(join7(packagesDir, "bin"), { recursive: true });
+  mkdirSync6(join8(packagesDir, "src"), { recursive: true });
+  mkdirSync6(join8(packagesDir, "bin"), { recursive: true });
   process.stderr.write(`${green("✓")} Created directory structure
 `);
-  writeFileSync5(join7(packagesDir, "package.json"), generatePackageJson(name, displayName, description, sdkVersion, gatewayVersion), "utf-8");
+  writeFileSync5(join8(packagesDir, "package.json"), generatePackageJson(name, displayName, description, sdkVersion, gatewayVersion), "utf-8");
   process.stderr.write(`${green("✓")} Generated package.json
 `);
-  writeFileSync5(join7(packagesDir, "tsconfig.json"), generateTsconfig(), "utf-8");
+  writeFileSync5(join8(packagesDir, "tsconfig.json"), generateTsconfig(), "utf-8");
   process.stderr.write(`${green("✓")} Generated tsconfig.json
 `);
-  writeFileSync5(join7(packagesDir, "src", "cli.ts"), generateCliTs(), "utf-8");
+  writeFileSync5(join8(packagesDir, "src", "cli.ts"), generateCliTs(), "utf-8");
   process.stderr.write(`${green("✓")} Generated src/cli.ts
 `);
-  writeFileSync5(join7(packagesDir, "src", "index.ts"), generateIndexTs(name), "utf-8");
+  writeFileSync5(join8(packagesDir, "src", "index.ts"), generateIndexTs(name), "utf-8");
   process.stderr.write(`${green("✓")} Generated src/index.ts
 `);
-  writeFileSync5(join7(packagesDir, "README.md"), generateReadme(name, description), "utf-8");
+  writeFileSync5(join8(packagesDir, "README.md"), generateReadme(name, description), "utf-8");
   process.stderr.write(`${green("✓")} Generated README.md
 `);
   process.stderr.write(`
@@ -2694,37 +2915,37 @@ var init_create = __esm(() => {
 
 // src/packages/registry.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   renameSync,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function getPackagesDir() {
   const home = process.env.HOME || homedir2();
-  const dir = join8(home, ".locus", "packages");
-  if (!existsSync8(dir)) {
+  const dir = join9(home, ".locus", "packages");
+  if (!existsSync9(dir)) {
     mkdirSync7(dir, { recursive: true });
   }
-  const pkgJson = join8(dir, "package.json");
-  if (!existsSync8(pkgJson)) {
+  const pkgJson = join9(dir, "package.json");
+  if (!existsSync9(pkgJson)) {
     writeFileSync6(pkgJson, `${JSON.stringify({ private: true }, null, 2)}
 `, "utf-8");
   }
   return dir;
 }
 function getRegistryPath() {
-  return join8(getPackagesDir(), "registry.json");
+  return join9(getPackagesDir(), "registry.json");
 }
 function loadRegistry() {
   const registryPath = getRegistryPath();
-  if (!existsSync8(registryPath)) {
+  if (!existsSync9(registryPath)) {
     return { packages: {} };
   }
   try {
-    const raw = readFileSync5(registryPath, "utf-8");
+    const raw = readFileSync6(registryPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "packages" in parsed && typeof parsed.packages === "object") {
       const registry = parsed;
@@ -2758,8 +2979,8 @@ function saveRegistry(registry) {
 function resolvePackageBinary(packageName) {
   const fullName = normalizePackageName(packageName);
   const binName = fullName.includes("/") ? fullName.split("/").pop() : fullName;
-  const binPath = join8(getPackagesDir(), "node_modules", ".bin", binName);
-  return existsSync8(binPath) ? binPath : null;
+  const binPath = join9(getPackagesDir(), "node_modules", ".bin", binName);
+  return existsSync9(binPath) ? binPath : null;
 }
 function normalizePackageName(input) {
   if (input.startsWith(SCOPED_PREFIX)) {
@@ -2785,7 +3006,7 @@ __export(exports_pkg, {
   listInstalledPackages: () => listInstalledPackages
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 function listInstalledPackages() {
   const registry = loadRegistry();
   const entries = Object.values(registry.packages);
@@ -2864,7 +3085,7 @@ async function pkgCommand(args, _flags) {
     return;
   }
   let binaryPath = entry.binaryPath;
-  if (!binaryPath || !existsSync9(binaryPath)) {
+  if (!binaryPath || !existsSync10(binaryPath)) {
     const resolved = resolvePackageBinary(packageName);
     if (resolved) {
       binaryPath = resolved;
@@ -2997,8 +3218,8 @@ __export(exports_install, {
   installCommand: () => installCommand
 });
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { join as join10 } from "node:path";
 function parsePackageArg(raw) {
   if (raw.startsWith("@")) {
     const slashIdx = raw.indexOf("/");
@@ -3075,8 +3296,8 @@ ${red2("✗")} Failed to install ${bold2(packageSpec)}.
     process.exit(1);
     return;
   }
-  const installedPkgJsonPath = join9(packagesDir, "node_modules", packageName, "package.json");
-  if (!existsSync10(installedPkgJsonPath)) {
+  const installedPkgJsonPath = join10(packagesDir, "node_modules", packageName, "package.json");
+  if (!existsSync11(installedPkgJsonPath)) {
     process.stderr.write(`
 ${red2("✗")} Package installed but package.json not found at:
 `);
@@ -3087,7 +3308,7 @@ ${red2("✗")} Package installed but package.json not found at:
   }
   let installedPkgJson;
   try {
-    installedPkgJson = JSON.parse(readFileSync6(installedPkgJsonPath, "utf-8"));
+    installedPkgJson = JSON.parse(readFileSync7(installedPkgJsonPath, "utf-8"));
   } catch {
     process.stderr.write(`
 ${red2("✗")} Could not parse installed package.json.
@@ -3329,19 +3550,19 @@ var REGISTRY_REPO = "asgarovf/locusai", REGISTRY_BRANCH = "master", SKILLS_LOCK_
 
 // src/skills/lock.ts
 import { createHash } from "node:crypto";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join10 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join11 } from "node:path";
 function readLockFile(projectRoot) {
-  const filePath = join10(projectRoot, SKILLS_LOCK_FILENAME);
+  const filePath = join11(projectRoot, SKILLS_LOCK_FILENAME);
   try {
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync8(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { ...DEFAULT_LOCK_FILE, skills: {} };
   }
 }
 function writeLockFile(projectRoot, lockFile) {
-  const filePath = join10(projectRoot, SKILLS_LOCK_FILENAME);
+  const filePath = join11(projectRoot, SKILLS_LOCK_FILENAME);
   writeFileSync7(filePath, `${JSON.stringify(lockFile, null, 2)}
 `, "utf-8");
 }
@@ -3355,29 +3576,29 @@ var init_lock = __esm(() => {
 
 // src/skills/installer.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   renameSync as renameSync2,
   rmSync,
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function installSkill(projectRoot, name, content, source) {
-  const claudeDir = join11(projectRoot, CLAUDE_SKILLS_DIR, name);
-  const agentsDir = join11(projectRoot, AGENTS_SKILLS_DIR, name);
-  const stagingDir = join11(tmpdir(), `locus-skill-${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  const stagingClaudeDir = join11(stagingDir, "claude");
-  const stagingAgentsDir = join11(stagingDir, "agents");
+  const claudeDir = join12(projectRoot, CLAUDE_SKILLS_DIR, name);
+  const agentsDir = join12(projectRoot, AGENTS_SKILLS_DIR, name);
+  const stagingDir = join12(tmpdir(), `locus-skill-${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const stagingClaudeDir = join12(stagingDir, "claude");
+  const stagingAgentsDir = join12(stagingDir, "agents");
   let wroteClaudeDir = false;
   let wroteAgentsDir = false;
   try {
     try {
       mkdirSync8(stagingClaudeDir, { recursive: true });
       mkdirSync8(stagingAgentsDir, { recursive: true });
-      writeFileSync8(join11(stagingClaudeDir, "SKILL.md"), content, "utf-8");
-      writeFileSync8(join11(stagingAgentsDir, "SKILL.md"), content, "utf-8");
+      writeFileSync8(join12(stagingClaudeDir, "SKILL.md"), content, "utf-8");
+      writeFileSync8(join12(stagingAgentsDir, "SKILL.md"), content, "utf-8");
     } catch (err) {
       throw new SkillInstallError(name, "stage", err);
     }
@@ -3386,7 +3607,7 @@ async function installSkill(projectRoot, name, content, source) {
         throw new Error("Skill content is empty");
       }
       const expectedHash = computeSkillHash(content);
-      const stagedContent = readFileSync8(join11(stagingClaudeDir, "SKILL.md"), "utf-8");
+      const stagedContent = readFileSync9(join12(stagingClaudeDir, "SKILL.md"), "utf-8");
       const stagedHash = computeSkillHash(stagedContent);
       if (stagedHash !== expectedHash) {
         throw new Error("Staged file hash does not match expected content");
@@ -3397,12 +3618,12 @@ async function installSkill(projectRoot, name, content, source) {
       throw new SkillInstallError(name, "validate", err);
     }
     try {
-      mkdirSync8(join11(projectRoot, CLAUDE_SKILLS_DIR), { recursive: true });
-      mkdirSync8(join11(projectRoot, AGENTS_SKILLS_DIR), { recursive: true });
-      if (existsSync11(claudeDir)) {
+      mkdirSync8(join12(projectRoot, CLAUDE_SKILLS_DIR), { recursive: true });
+      mkdirSync8(join12(projectRoot, AGENTS_SKILLS_DIR), { recursive: true });
+      if (existsSync12(claudeDir)) {
         rmSync(claudeDir, { recursive: true, force: true });
       }
-      if (existsSync11(agentsDir)) {
+      if (existsSync12(agentsDir)) {
         rmSync(agentsDir, { recursive: true, force: true });
       }
       try {
@@ -3410,7 +3631,7 @@ async function installSkill(projectRoot, name, content, source) {
         wroteClaudeDir = true;
       } catch {
         mkdirSync8(claudeDir, { recursive: true });
-        writeFileSync8(join11(claudeDir, "SKILL.md"), content, "utf-8");
+        writeFileSync8(join12(claudeDir, "SKILL.md"), content, "utf-8");
         wroteClaudeDir = true;
       }
       try {
@@ -3418,7 +3639,7 @@ async function installSkill(projectRoot, name, content, source) {
         wroteAgentsDir = true;
       } catch {
         mkdirSync8(agentsDir, { recursive: true });
-        writeFileSync8(join11(agentsDir, "SKILL.md"), content, "utf-8");
+        writeFileSync8(join12(agentsDir, "SKILL.md"), content, "utf-8");
         wroteAgentsDir = true;
       }
     } catch (err) {
@@ -3438,26 +3659,26 @@ async function installSkill(projectRoot, name, content, source) {
       throw new SkillInstallError(name, "register", err);
     }
   } catch (err) {
-    if (wroteClaudeDir && existsSync11(claudeDir)) {
+    if (wroteClaudeDir && existsSync12(claudeDir)) {
       rmSync(claudeDir, { recursive: true, force: true });
     }
-    if (wroteAgentsDir && existsSync11(agentsDir)) {
+    if (wroteAgentsDir && existsSync12(agentsDir)) {
       rmSync(agentsDir, { recursive: true, force: true });
     }
     throw err;
   } finally {
-    if (existsSync11(stagingDir)) {
+    if (existsSync12(stagingDir)) {
       rmSync(stagingDir, { recursive: true, force: true });
     }
   }
 }
 async function removeSkill(projectRoot, name) {
-  const claudeDir = join11(projectRoot, CLAUDE_SKILLS_DIR, name);
-  const agentsDir = join11(projectRoot, AGENTS_SKILLS_DIR, name);
+  const claudeDir = join12(projectRoot, CLAUDE_SKILLS_DIR, name);
+  const agentsDir = join12(projectRoot, AGENTS_SKILLS_DIR, name);
   const lock = readLockFile(projectRoot);
   const inLockFile = name in lock.skills;
-  const hasClaude = existsSync11(claudeDir);
-  const hasAgents = existsSync11(agentsDir);
+  const hasClaude = existsSync12(claudeDir);
+  const hasAgents = existsSync12(agentsDir);
   if (!inLockFile && !hasClaude && !hasAgents) {
     console.warn(`Skill "${name}" is not installed.`);
     return;
@@ -3478,10 +3699,10 @@ function isSkillInstalled(projectRoot, name) {
   return name in lock.skills;
 }
 function hasOrphanedSkillFiles(projectRoot, name) {
-  const claudeDir = join11(projectRoot, CLAUDE_SKILLS_DIR, name);
-  const agentsDir = join11(projectRoot, AGENTS_SKILLS_DIR, name);
+  const claudeDir = join12(projectRoot, CLAUDE_SKILLS_DIR, name);
+  const agentsDir = join12(projectRoot, AGENTS_SKILLS_DIR, name);
   const inLockFile = isSkillInstalled(projectRoot, name);
-  return !inLockFile && (existsSync11(claudeDir) || existsSync11(agentsDir));
+  return !inLockFile && (existsSync12(claudeDir) || existsSync12(agentsDir));
 }
 var SkillInstallError;
 var init_installer = __esm(() => {
@@ -3880,6 +4101,80 @@ ${bold2("Skill Information")}
   process.stderr.write(`
 `);
 }
+async function searchSkills(query, flags) {
+  if (!query && !flags.tag) {
+    process.stderr.write(`${red2("✗")} Please provide a search query.
+`);
+    process.stderr.write(`  Usage: ${bold2("locus skills search <query>")} or ${bold2("locus skills search --tag <tag>")}
+`);
+    process.exit(1);
+  }
+  let registry;
+  try {
+    registry = await fetchRegistry();
+  } catch (err) {
+    process.stderr.write(`${red2("✗")} Failed to fetch skills registry. Check your internet connection.
+`);
+    process.stderr.write(`  ${dim2(err.message)}
+`);
+    process.exit(1);
+  }
+  const tagFilter = flags.tag?.toLowerCase();
+  const queryLower = query?.toLowerCase() ?? "";
+  const matches = registry.skills.filter((s) => {
+    if (tagFilter) {
+      return s.tags.some((t) => t.toLowerCase() === tagFilter);
+    }
+    const nameMatch = s.name.toLowerCase().includes(queryLower);
+    const descMatch = s.description.toLowerCase().includes(queryLower);
+    const tagMatch = s.tags.some((t) => t.toLowerCase().includes(queryLower));
+    return nameMatch || descMatch || tagMatch;
+  });
+  if (matches.length === 0) {
+    process.stderr.write(`
+${yellow2("⚠")}  No skills found matching "${bold2(tagFilter || query)}"
+`);
+    process.stderr.write(`  Run ${bold2("locus skills list")} to see all available skills.
+
+`);
+    return;
+  }
+  const cwd = process.cwd();
+  const lockFile = readLockFile(cwd);
+  process.stderr.write(`
+${bold2("Search Results")} for "${cyan2(tagFilter || query)}"
+
+`);
+  const columns = [
+    { key: "name", header: "Name", minWidth: 12, maxWidth: 24 },
+    { key: "description", header: "Description", minWidth: 20, maxWidth: 44 },
+    {
+      key: "tags",
+      header: "Tags",
+      minWidth: 10,
+      maxWidth: 30,
+      format: (val) => dim2(val.join(", "))
+    },
+    {
+      key: "status",
+      header: "Status",
+      minWidth: 8,
+      maxWidth: 12
+    }
+  ];
+  const rows = matches.map((s) => ({
+    name: cyan2(s.name),
+    description: s.description,
+    tags: s.tags,
+    status: s.name in lockFile.skills ? green("installed") : dim2("available")
+  }));
+  process.stderr.write(`${renderTable(columns, rows)}
+
+`);
+  process.stderr.write(`  ${dim2(`${matches.length} skill(s) found.`)} Install with: ${bold2("locus skills install <name>")}
+
+`);
+}
 function printSkillsHelp() {
   process.stderr.write(`
 ${bold2("Usage:")}
@@ -3888,6 +4183,7 @@ ${bold2("Usage:")}
 ${bold2("Subcommands:")}
   ${cyan2("list")}              List available skills from the registry
   ${cyan2("list")} ${dim2("--installed")}   List locally installed skills
+  ${cyan2("search")} ${dim2("<query>")}    Search skills by name, description, or tags
   ${cyan2("install")} ${dim2("<name>")}    Install a skill from the registry
   ${cyan2("remove")} ${dim2("<name>")}     Remove an installed skill (alias: ${cyan2("uninstall")})
   ${cyan2("update")} ${dim2("[name]")}     Update installed skill(s) from registry
@@ -3896,6 +4192,8 @@ ${bold2("Subcommands:")}
 ${bold2("Examples:")}
   locus skills list                   ${dim2("# Browse available skills")}
   locus skills list --installed       ${dim2("# Show installed skills")}
+  locus skills search "code review"   ${dim2("# Search by keyword")}
+  locus skills search --tag testing   ${dim2("# Search by tag")}
   locus skills install code-review    ${dim2("# Install a skill")}
   locus skills remove code-review     ${dim2("# Remove a skill")}
   locus skills update                 ${dim2("# Update all installed skills")}
@@ -3940,10 +4238,15 @@ async function skillsCommand(args, flags) {
       await infoSkill(skillName);
       break;
     }
+    case "search": {
+      const searchQuery = args.slice(1).join(" ");
+      await searchSkills(searchQuery, flags);
+      break;
+    }
     default:
       process.stderr.write(`${red2("✗")} Unknown subcommand: ${bold2(subcommand)}
 `);
-      process.stderr.write(`  Available: ${bold2("list")}, ${bold2("install")}, ${bold2("remove")} (${bold2("uninstall")}), ${bold2("update")}, ${bold2("info")}
+      process.stderr.write(`  Available: ${bold2("list")}, ${bold2("search")}, ${bold2("install")}, ${bold2("remove")} (${bold2("uninstall")}), ${bold2("update")}, ${bold2("info")}
 `);
       process.exit(1);
   }
@@ -4092,16 +4395,16 @@ __export(exports_logs, {
   logsCommand: () => logsCommand
 });
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   statSync as statSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function logsCommand(cwd, options) {
-  const logsDir = join12(cwd, ".locus", "logs");
-  if (!existsSync12(logsDir)) {
+  const logsDir = join13(cwd, ".locus", "logs");
+  if (!existsSync13(logsDir)) {
     process.stderr.write(`${dim2("No logs found.")}
 `);
     return;
@@ -4121,7 +4424,7 @@ async function logsCommand(cwd, options) {
   return viewLog(logFiles[0], options.level, options.lines ?? 50);
 }
 function viewLog(logFile, levelFilter, maxLines) {
-  const content = readFileSync9(logFile, "utf-8");
+  const content = readFileSync10(logFile, "utf-8");
   const lines = content.trim().split(`
 `).filter(Boolean);
   process.stderr.write(`
@@ -4156,9 +4459,9 @@ async function tailLog(logFile, levelFilter) {
   process.stderr.write(`${bold2("Tailing:")} ${dim2(logFile)} ${dim2("(Ctrl+C to stop)")}
 
 `);
-  let lastSize = existsSync12(logFile) ? statSync2(logFile).size : 0;
-  if (existsSync12(logFile)) {
-    const content = readFileSync9(logFile, "utf-8");
+  let lastSize = existsSync13(logFile) ? statSync2(logFile).size : 0;
+  if (existsSync13(logFile)) {
+    const content = readFileSync10(logFile, "utf-8");
     const lines = content.trim().split(`
 `).filter(Boolean);
     const recent = lines.slice(-10);
@@ -4176,12 +4479,12 @@ async function tailLog(logFile, levelFilter) {
   }
   return new Promise((resolve) => {
     const interval = setInterval(() => {
-      if (!existsSync12(logFile))
+      if (!existsSync13(logFile))
         return;
       const currentSize = statSync2(logFile).size;
       if (currentSize <= lastSize)
         return;
-      const content = readFileSync9(logFile, "utf-8");
+      const content = readFileSync10(logFile, "utf-8");
       const allLines = content.trim().split(`
 `).filter(Boolean);
       const oldContent = content.slice(0, lastSize);
@@ -4236,7 +4539,7 @@ function cleanLogs(logsDir) {
 `);
 }
 function getLogFiles(logsDir) {
-  return readdirSync2(logsDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => join12(logsDir, f)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
+  return readdirSync2(logsDir).filter((f) => f.startsWith("locus-") && f.endsWith(".log")).map((f) => join13(logsDir, f)).sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs);
 }
 function formatEntry(entry) {
   const time = dim2(new Date(entry.ts).toLocaleTimeString());
@@ -4546,9 +4849,9 @@ var init_stream_renderer = __esm(() => {
 
 // src/repl/clipboard.ts
 import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync9 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function readClipboardImage() {
   if (process.platform === "darwin") {
     return readMacOSClipboardImage();
@@ -4559,14 +4862,14 @@ function readClipboardImage() {
   return null;
 }
 function ensureStableDir() {
-  if (!existsSync13(STABLE_DIR)) {
+  if (!existsSync14(STABLE_DIR)) {
     mkdirSync9(STABLE_DIR, { recursive: true });
   }
 }
 function readMacOSClipboardImage() {
   try {
     ensureStableDir();
-    const destPath = join13(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    const destPath = join14(STABLE_DIR, `clipboard-${Date.now()}.png`);
     const script = [
       `set destPath to POSIX file "${destPath}"`,
       "try",
@@ -4590,7 +4893,7 @@ function readMacOSClipboardImage() {
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    if (result === "ok" && existsSync13(destPath)) {
+    if (result === "ok" && existsSync14(destPath)) {
       return destPath;
     }
   } catch {}
@@ -4603,9 +4906,9 @@ function readLinuxClipboardImage() {
       return null;
     }
     ensureStableDir();
-    const destPath = join13(STABLE_DIR, `clipboard-${Date.now()}.png`);
+    const destPath = join14(STABLE_DIR, `clipboard-${Date.now()}.png`);
     execSync6(`xclip -selection clipboard -t image/png -o > "${destPath}" 2>/dev/null`, { timeout: 5000 });
-    if (existsSync13(destPath)) {
+    if (existsSync14(destPath)) {
       return destPath;
     }
   } catch {}
@@ -4613,13 +4916,13 @@ function readLinuxClipboardImage() {
 }
 var STABLE_DIR;
 var init_clipboard = __esm(() => {
-  STABLE_DIR = join13(tmpdir2(), "locus-images");
+  STABLE_DIR = join14(tmpdir2(), "locus-images");
 });
 
 // src/repl/image-detect.ts
-import { copyFileSync, existsSync as existsSync14, mkdirSync as mkdirSync10 } from "node:fs";
+import { copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "node:fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
-import { basename, extname, join as join14, resolve } from "node:path";
+import { basename, extname, join as join15, resolve } from "node:path";
 function detectImages(input) {
   const detected = [];
   const byResolved = new Map;
@@ -4713,15 +5016,15 @@ function collectReferencedAttachments(input, attachments) {
   return dedupeByResolvedPath(selected);
 }
 function relocateImages(images, projectRoot) {
-  const targetDir = join14(projectRoot, ".locus", "tmp", "images");
+  const targetDir = join15(projectRoot, ".locus", "tmp", "images");
   for (const img of images) {
     if (!img.exists)
       continue;
     try {
-      if (!existsSync14(targetDir)) {
+      if (!existsSync15(targetDir)) {
         mkdirSync10(targetDir, { recursive: true });
       }
-      const dest = join14(targetDir, basename(img.stablePath));
+      const dest = join15(targetDir, basename(img.stablePath));
       copyFileSync(img.stablePath, dest);
       img.stablePath = dest;
     } catch {}
@@ -4733,7 +5036,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     return;
   let resolved = stripQuotes(rawPath).replace(/\\ /g, " ");
   if (resolved.startsWith("~/")) {
-    resolved = join14(homedir3(), resolved.slice(2));
+    resolved = join15(homedir3(), resolved.slice(2));
   }
   resolved = resolve(resolved);
   const existing = byResolved.get(resolved);
@@ -4746,7 +5049,7 @@ function addIfImage(rawPath, rawMatch, detected, byResolved) {
     ]);
     return;
   }
-  const exists = existsSync14(resolved);
+  const exists = existsSync15(resolved);
   let stablePath = resolved;
   if (exists) {
     stablePath = copyToStable(resolved);
@@ -4800,10 +5103,10 @@ function dedupeByResolvedPath(images) {
 }
 function copyToStable(sourcePath) {
   try {
-    if (!existsSync14(STABLE_DIR2)) {
+    if (!existsSync15(STABLE_DIR2)) {
       mkdirSync10(STABLE_DIR2, { recursive: true });
     }
-    const dest = join14(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
+    const dest = join15(STABLE_DIR2, `${Date.now()}-${basename(sourcePath)}`);
     copyFileSync(sourcePath, dest);
     return dest;
   } catch {
@@ -4823,7 +5126,7 @@ var init_image_detect = __esm(() => {
     ".tif",
     ".tiff"
   ]);
-  STABLE_DIR2 = join14(tmpdir3(), "locus-images");
+  STABLE_DIR2 = join15(tmpdir3(), "locus-images");
   PLACEHOLDER_ID_PATTERN = /\(locus:\/\/screenshot-(\d+)\)/g;
 });
 
@@ -5832,21 +6135,21 @@ var init_claude = __esm(() => {
 import { exec } from "node:child_process";
 import {
   cpSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync11,
   mkdtempSync,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   rmSync as rmSync2,
   statSync as statSync3
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname3, join as join15, relative } from "node:path";
+import { dirname as dirname3, join as join16, relative } from "node:path";
 import { promisify } from "node:util";
 function parseIgnoreFile(filePath) {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return [];
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync11(filePath, "utf-8");
   const rules = [];
   for (const rawLine of content.split(`
 `)) {
@@ -5914,14 +6217,14 @@ function findIgnoredPaths(projectRoot, rules) {
     for (const name of entries) {
       if (SKIP_DIRS.has(name))
         continue;
-      const fullPath = join15(dir, name);
-      let stat = null;
+      const fullPath = join16(dir, name);
+      let stat2 = null;
       try {
-        stat = statSync3(fullPath);
+        stat2 = statSync3(fullPath);
       } catch {
         continue;
       }
-      const isDir = stat.isDirectory();
+      const isDir = stat2.isDirectory();
       let matched = false;
       for (const m of positiveMatchers) {
         if (m.isDirectory && !isDir)
@@ -5948,7 +6251,7 @@ function findIgnoredPaths(projectRoot, rules) {
 }
 function backupIgnoredFiles(projectRoot) {
   const log = getLogger();
-  const ignorePath = join15(projectRoot, ".sandboxignore");
+  const ignorePath = join16(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return NOOP_BACKUP;
@@ -5957,7 +6260,7 @@ function backupIgnoredFiles(projectRoot) {
     return NOOP_BACKUP;
   let backupDir;
   try {
-    backupDir = mkdtempSync(join15(tmpdir4(), "locus-sandbox-backup-"));
+    backupDir = mkdtempSync(join16(tmpdir4(), "locus-sandbox-backup-"));
   } catch (err) {
     log.debug("Failed to create sandbox backup dir", {
       error: err instanceof Error ? err.message : String(err)
@@ -5967,7 +6270,7 @@ function backupIgnoredFiles(projectRoot) {
   const backed = [];
   for (const src of paths) {
     const rel = relative(projectRoot, src);
-    const dest = join15(backupDir, rel);
+    const dest = join16(backupDir, rel);
     try {
       mkdirSync11(dirname3(dest), { recursive: true });
       cpSync(src, dest, { recursive: true, preserveTimestamps: true });
@@ -6009,7 +6312,7 @@ function backupIgnoredFiles(projectRoot) {
 }
 async function enforceSandboxIgnore(sandboxName, projectRoot, containerWorkdir) {
   const log = getLogger();
-  const ignorePath = join15(projectRoot, ".sandboxignore");
+  const ignorePath = join16(projectRoot, ".sandboxignore");
   const rules = parseIgnoreFile(ignorePath);
   if (rules.length === 0)
     return;
@@ -8173,14 +8476,113 @@ var init_sprint = __esm(() => {
   init_terminal();
 });
 
+// src/skills/matcher.ts
+function matchRelevantSkills(issue, skills) {
+  if (skills.length <= MAX_SKILLS)
+    return skills;
+  const titleTokens = tokenize(issue.title);
+  const bodyTokens = tokenize(issue.body).slice(0, 200);
+  const labelTokens = issue.labels.flatMap((l) => tokenize(l));
+  const scored = skills.map((skill) => {
+    let score = 0;
+    const tagSet = new Set(skill.tags.map((t) => t.toLowerCase()));
+    const descTokens = new Set(tokenize(skill.description));
+    for (const lt of labelTokens) {
+      if (tagSet.has(lt))
+        score += 5;
+    }
+    for (const tw of titleTokens) {
+      if (tagSet.has(tw))
+        score += 3;
+    }
+    for (const bw of bodyTokens) {
+      if (tagSet.has(bw))
+        score += 2;
+    }
+    for (const tw of titleTokens) {
+      if (descTokens.has(tw))
+        score += 1;
+    }
+    for (const bw of bodyTokens) {
+      if (descTokens.has(bw))
+        score += 0.5;
+    }
+    return { skill, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const relevant = scored.filter((s) => s.score >= RELEVANCE_THRESHOLD);
+  if (relevant.length > 0) {
+    return relevant.slice(0, MAX_SKILLS).map((s) => s.skill);
+  }
+  return scored.slice(0, FALLBACK_COUNT).map((s) => s.skill);
+}
+function tokenize(text) {
+  if (!text)
+    return [];
+  return text.toLowerCase().replace(/[^a-z0-9\-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+}
+var RELEVANCE_THRESHOLD = 2, MAX_SKILLS = 5, FALLBACK_COUNT = 3, STOP_WORDS;
+var init_matcher = __esm(() => {
+  STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "it",
+    "to",
+    "in",
+    "on",
+    "of",
+    "for",
+    "and",
+    "or",
+    "not",
+    "with",
+    "this",
+    "that",
+    "from",
+    "by",
+    "as",
+    "at",
+    "be",
+    "we",
+    "i",
+    "you",
+    "my",
+    "our",
+    "do",
+    "if",
+    "no",
+    "so",
+    "up",
+    "can",
+    "all",
+    "but",
+    "has",
+    "had",
+    "have",
+    "will",
+    "should",
+    "would",
+    "could",
+    "need",
+    "want",
+    "also",
+    "new",
+    "use",
+    "add",
+    "make"
+  ]);
+});
+
 // src/core/prompt-builder.ts
 import { execSync as execSync9 } from "node:child_process";
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
+import { join as join17 } from "node:path";
 function buildExecutionPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
-  const skills = buildSkillsContext(ctx.projectRoot);
+  const skills = buildSkillsContext(ctx.projectRoot, ctx.issue);
   if (skills)
     sections.push(skills);
   sections.push(buildTaskContext(ctx.issue, ctx.issueComments));
@@ -8198,7 +8600,7 @@ function buildExecutionPrompt(ctx) {
 function buildFeedbackPrompt(ctx) {
   const sections = [];
   sections.push(buildSystemContext(ctx.projectRoot));
-  const skills = buildSkillsContext(ctx.projectRoot);
+  const skills = buildSkillsContext(ctx.projectRoot, ctx.issue);
   if (skills)
     sections.push(skills);
   sections.push(buildTaskContext(ctx.issue));
@@ -8212,15 +8614,22 @@ function buildFeedbackPrompt(ctx) {
 }
 function buildReplPrompt(userMessage, projectRoot, _config, previousMessages) {
   const sections = [];
-  const locusmd = readFileSafe(join16(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join17(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     sections.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  sections.push(`<past-learnings>
-Past learnings are located in \`.locus/LEARNINGS.md\`.</past-learnings>`);
-  sections.push(`<learnings-reminder>IMPORTANT: If during this interaction you discover reusable lessons (architectural patterns, non-obvious constraints, user corrections), you MUST append them to \`.locus/LEARNINGS.md\` before finishing. This is mandatory — see the "Continuous Learning" section in project instructions.</learnings-reminder>`);
+  const memory = loadMemoryContent(projectRoot);
+  if (memory) {
+    sections.push(`<past-learnings>
+${memory}
+</past-learnings>`);
+  } else {
+    sections.push(`<past-learnings>
+No past learnings recorded yet.</past-learnings>`);
+  }
+  sections.push(`<learnings-reminder>IMPORTANT: If during this interaction you discover reusable lessons (architectural patterns, non-obvious constraints, user corrections), record them in the appropriate category file in \`.locus/memory/\` before finishing. This is mandatory — see the "Continuous Learning" section in project instructions.</learnings-reminder>`);
   if (previousMessages && previousMessages.length > 0) {
     const recent = previousMessages.slice(-10);
     const historyLines = recent.map((msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`);
@@ -8239,22 +8648,41 @@ ${userMessage}
 
 `);
 }
+function loadMemoryContent(projectRoot) {
+  const memoryDir = getMemoryDir(projectRoot);
+  if (existsSync17(memoryDir)) {
+    const content = readAllMemorySync(projectRoot);
+    if (content.trim()) {
+      return content.length > MEMORY_MAX_CHARS ? `${content.slice(0, MEMORY_MAX_CHARS)}
+
+...(truncated)` : content;
+    }
+  }
+  return "";
+}
 function buildSystemContext(projectRoot) {
   const parts = [];
-  const locusmd = readFileSafe(join16(projectRoot, ".locus", "LOCUS.md"));
+  const locusmd = readFileSafe(join17(projectRoot, ".locus", "LOCUS.md"));
   if (locusmd) {
     parts.push(`<project-instructions>
 ${locusmd}
 </project-instructions>`);
   }
-  parts.push(`<past-learnings>
-Past learnings are located in \`.locus/LEARNINGS.md\`.</past-learnings>`);
-  const discussionsDir = join16(projectRoot, ".locus", "discussions");
-  if (existsSync16(discussionsDir)) {
+  const memory = loadMemoryContent(projectRoot);
+  if (memory) {
+    parts.push(`<past-learnings>
+${memory}
+</past-learnings>`);
+  } else {
+    parts.push(`<past-learnings>
+No past learnings recorded yet.</past-learnings>`);
+  }
+  const discussionsDir = join17(projectRoot, ".locus", "discussions");
+  if (existsSync17(discussionsDir)) {
     try {
       const files = readdirSync4(discussionsDir).filter((f) => f.endsWith(".md")).slice(0, 3);
       for (const file of files) {
-        const content = readFileSafe(join16(discussionsDir, file));
+        const content = readFileSafe(join17(discussionsDir, file));
         if (content) {
           const name = file.replace(".md", "");
           parts.push(`<discussion name="${name}">
@@ -8363,7 +8791,7 @@ function buildExecutionRules(config) {
 1. **Commit format:** Use conventional commits: \`feat: <title> (#<issue>)\`, \`fix: ...\`, \`chore: ...\`. Every commit message MUST be multi-line: the first line is the title, then a blank line, then \`Co-Authored-By: LocusAgent <agent@locusai.team>\` as a Git trailer. Use \`git commit -m "<title>" -m "Co-Authored-By: LocusAgent <agent@locusai.team>"\` (two separate -m flags) to ensure the trailer is on its own line.
 2. **Code quality:** Follow existing code style. Run linters/formatters if available.
 3. **Testing:** If test files exist for modified code, update them accordingly.
-4. **Update learnings:** Before finishing, if you discovered any reusable lessons (architectural patterns, non-obvious constraints, user corrections), append them to \`.locus/LEARNINGS.md\`. This is mandatory — see the "Continuous Learning" section in project instructions.
+4. **Update memory:** Before finishing, if you discovered any reusable lessons (architectural patterns, non-obvious constraints, user corrections), record them in the appropriate category file in \`.locus/memory/\` (architecture.md, conventions.md, decisions.md, preferences.md, debugging.md). This is mandatory — see the "Continuous Learning" section in project instructions.
 5. **Do NOT:**
    - Run \`git push\` (the orchestrator handles pushing)
    - Modify files outside the scope of this issue
@@ -8401,13 +8829,13 @@ function buildFeedbackInstructions() {
 2. Make targeted changes — do NOT rewrite code from scratch.
 3. If a reviewer comment is unclear, make your best judgment and note your interpretation.
 4. Push changes to the same branch — do NOT create a new PR.
-5. If you learned any reusable lessons from this feedback (non-obvious constraints, architectural patterns), append them to \`.locus/LEARNINGS.md\`.
+5. If you learned any reusable lessons from this feedback (non-obvious constraints, architectural patterns), record them in the appropriate category file in \`.locus/memory/\`.
 6. When done, summarize what you changed in response to each comment.
 </instructions>`;
 }
-function buildSkillsContext(projectRoot) {
-  const skillsDir = join16(projectRoot, CLAUDE_SKILLS_DIR);
-  if (!existsSync16(skillsDir))
+function buildSkillsContext(projectRoot, issue) {
+  const skillsDir = join17(projectRoot, CLAUDE_SKILLS_DIR);
+  if (!existsSync17(skillsDir))
     return null;
   let dirs;
   try {
@@ -8417,21 +8845,35 @@ function buildSkillsContext(projectRoot) {
   }
   if (dirs.length === 0)
     return null;
-  const entries = [];
+  let allSkills = [];
   for (const dir of dirs) {
-    const skillPath = join16(skillsDir, dir, "SKILL.md");
+    const skillPath = join17(skillsDir, dir, "SKILL.md");
     const content = readFileSafe(skillPath);
     if (!content)
       continue;
     const fm = parseFrontmatter(content);
-    const name = fm.name || dir;
-    const description = fm.description || "";
-    entries.push(`- **${name}**: ${description}`);
+    allSkills.push({
+      dir,
+      name: fm.name || dir,
+      description: fm.description || "",
+      tags: fm.tags ? fm.tags.split(",").map((t) => t.trim()) : []
+    });
   }
-  if (entries.length === 0)
+  if (allSkills.length === 0)
     return null;
+  let selectedSkills = allSkills;
+  if (issue) {
+    const issueCtx = {
+      title: issue.title,
+      body: issue.body || "",
+      labels: issue.labels
+    };
+    const relevant = matchRelevantSkills(issueCtx, allSkills);
+    selectedSkills = allSkills.filter((s) => relevant.some((r) => r.name === s.name));
+  }
+  const entries = selectedSkills.map((s) => `- **${s.name}**: ${s.description}`);
   return `<installed-skills>
-The following skills are installed in this project. If a skill is relevant to the current task, read its full instructions from \`.claude/skills/<name>/SKILL.md\` before starting work.
+The following skills are installed and relevant to this task. Read the full instructions from \`.claude/skills/<name>/SKILL.md\` before using a skill.
 
 ${entries.join(`
 `)}
@@ -8448,22 +8890,30 @@ function parseFrontmatter(content) {
     if (idx === -1)
       continue;
     const key = line.slice(0, idx).trim();
-    const val = line.slice(idx + 1).trim();
-    if (key && val)
-      result[key] = val;
+    let val = line.slice(idx + 1).trim();
+    if (!key || !val)
+      continue;
+    if (val.startsWith("[") && val.endsWith("]")) {
+      val = val.slice(1, -1);
+    }
+    result[key] = val;
   }
   return result;
 }
 function readFileSafe(path) {
   try {
-    if (!existsSync16(path))
+    if (!existsSync17(path))
       return null;
-    return readFileSync11(path, "utf-8");
+    return readFileSync12(path, "utf-8");
   } catch {
     return null;
   }
 }
-var init_prompt_builder = () => {};
+var MEMORY_MAX_CHARS = 4000;
+var init_prompt_builder = __esm(() => {
+  init_matcher();
+  init_memory();
+});
 
 // src/display/json-stream.ts
 class JsonStream {
@@ -8555,6 +9005,180 @@ class JsonStream {
   }
 }
 
+// src/core/memory-capture.ts
+import { spawn as spawn6 } from "node:child_process";
+function prepareTranscript(messages) {
+  if (!messages || messages.length === 0)
+    return "";
+  const lines = [];
+  for (const msg of messages) {
+    const label = msg.role === "user" ? "User" : "Assistant";
+    lines.push(`### ${label}
+${msg.content}`);
+  }
+  let transcript = lines.join(`
+
+`);
+  if (transcript.length > TRANSCRIPT_MAX_CHARS) {
+    transcript = `${transcript.slice(0, TRANSCRIPT_MAX_CHARS)}
+
+...(truncated)`;
+  }
+  return transcript;
+}
+function buildExtractionPrompt(transcript, existingMemory) {
+  const categoryList = Object.entries(MEMORY_CATEGORIES).map(([key, meta]) => `- "${key}": ${meta.title} — ${meta.description}`).join(`
+`);
+  return `You are a memory extraction assistant. Extract project-level reusable lessons from the following session transcript.
+
+## Valid Categories
+
+${categoryList}
+
+## Existing Memory (for deduplication)
+
+Do NOT extract entries that duplicate or closely overlap with these existing entries:
+
+<existing-memory>
+${existingMemory || "(none)"}
+</existing-memory>
+
+## Quality Bar
+
+Only extract entries that would help a new agent on a future task. Skip:
+- Session-specific details or in-progress work
+- One-time fixes or trivial observations
+- Speculative or unverified conclusions
+- Anything that duplicates existing memory entries above
+
+## Output Format
+
+Respond with ONLY a JSON array. No markdown fencing, no explanation. Example:
+[{"category": "architecture", "text": "SDK types are shared via @locusai/shared package"}]
+
+If there are no extractable lessons, respond with: []
+
+## Session Transcript
+
+${transcript}`;
+}
+function callExtractionAI(prompt, model) {
+  return new Promise((resolve2) => {
+    const args = [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--no-session-persistence"
+    ];
+    if (model) {
+      args.push("--model", model);
+    }
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE;
+    const proc = spawn6("claude", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    let output = "";
+    let errorOutput = "";
+    proc.stdout?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    proc.stderr?.on("data", (chunk) => {
+      errorOutput += chunk.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve2({ success: true, output });
+      } else {
+        resolve2({
+          success: false,
+          output,
+          error: errorOutput || `claude exited with code ${code}`
+        });
+      }
+    });
+    proc.on("error", (err) => {
+      resolve2({
+        success: false,
+        output: "",
+        error: `Failed to spawn claude: ${err.message}`
+      });
+    });
+    proc.stdin?.write(prompt);
+    proc.stdin?.end();
+  });
+}
+function parseExtractionResponse(raw) {
+  let text = raw.trim();
+  const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) {
+    text = fenceMatch[1].trim();
+  }
+  const arrayMatch = text.match(/\[[\s\S]*\]/);
+  if (!arrayMatch)
+    return [];
+  const parsed = JSON.parse(arrayMatch[0]);
+  if (!Array.isArray(parsed))
+    return [];
+  return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.category === "string" && typeof item.text === "string");
+}
+async function captureMemoryFromSession(projectRoot, transcript, config) {
+  const log = getLogger();
+  try {
+    if (!transcript.trim()) {
+      return { captured: 0 };
+    }
+    const existingMemory = await readAllMemory(projectRoot);
+    const prompt = buildExtractionPrompt(transcript, existingMemory);
+    const result = await callExtractionAI(prompt, config.model);
+    if (!result.success) {
+      log.warn("Memory capture: AI call failed", { error: result.error });
+      return { captured: 0 };
+    }
+    let entries;
+    try {
+      entries = parseExtractionResponse(result.output);
+    } catch (e) {
+      log.warn("Memory capture: failed to parse AI response", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      return { captured: 0 };
+    }
+    if (entries.length === 0) {
+      return { captured: 0 };
+    }
+    const validEntries = entries.filter((entry) => {
+      if (!VALID_CATEGORIES.has(entry.category)) {
+        log.debug("Memory capture: skipping invalid category", {
+          category: entry.category
+        });
+        return false;
+      }
+      return true;
+    });
+    if (validEntries.length === 0) {
+      return { captured: 0 };
+    }
+    await appendMemoryEntries(projectRoot, validEntries);
+    log.debug("Memory capture: extracted entries", {
+      count: validEntries.length
+    });
+    return { captured: validEntries.length };
+  } catch (e) {
+    log.warn("Memory capture: unexpected error", {
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return { captured: 0 };
+  }
+}
+var TRANSCRIPT_MAX_CHARS = 32000, VALID_CATEGORIES;
+var init_memory_capture = __esm(() => {
+  init_logger();
+  init_memory();
+  VALID_CATEGORIES = new Set(Object.keys(MEMORY_CATEGORIES));
+});
+
 // src/display/diff-renderer.ts
 function renderDiff(diff, options = {}) {
   const { maxLines, lineNumbers = true } = options;
@@ -8936,7 +9560,7 @@ var init_commands = __esm(() => {
 
 // src/repl/completions.ts
 import { readdirSync as readdirSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname4, join as join17 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join18 } from "node:path";
 
 class SlashCommandCompletion {
   commands;
@@ -8991,7 +9615,7 @@ class FilePathCompletion {
   }
   findMatches(partial) {
     try {
-      const dir = partial.includes("/") ? join17(this.projectRoot, dirname4(partial)) : this.projectRoot;
+      const dir = partial.includes("/") ? join18(this.projectRoot, dirname4(partial)) : this.projectRoot;
       const prefix = basename2(partial);
       const entries = readdirSync5(dir, { withFileTypes: true });
       return entries.filter((e) => {
@@ -9027,14 +9651,14 @@ class CombinedCompletion {
 var init_completions = () => {};
 
 // src/repl/input-history.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname5, join as join18 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname5, join as join19 } from "node:path";
 
 class InputHistory {
   entries = [];
   filePath;
   constructor(projectRoot) {
-    this.filePath = join18(projectRoot, ".locus", "sessions", ".input-history");
+    this.filePath = join19(projectRoot, ".locus", "sessions", ".input-history");
     this.load();
   }
   add(text) {
@@ -9073,9 +9697,9 @@ class InputHistory {
   }
   load() {
     try {
-      if (!existsSync17(this.filePath))
+      if (!existsSync18(this.filePath))
         return;
-      const content = readFileSync12(this.filePath, "utf-8");
+      const content = readFileSync13(this.filePath, "utf-8");
       this.entries = content.split(`
 `).map((line) => this.unescape(line)).filter(Boolean);
     } catch {}
@@ -9083,7 +9707,7 @@ class InputHistory {
   save() {
     try {
       const dir = dirname5(this.filePath);
-      if (!existsSync17(dir)) {
+      if (!existsSync18(dir)) {
         mkdirSync12(dir, { recursive: true });
       }
       const content = this.entries.map((e) => this.escape(e)).join(`
@@ -9114,20 +9738,20 @@ var init_model_config = __esm(() => {
 
 // src/repl/session-manager.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync13,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { basename as basename3, join as join19 } from "node:path";
+import { basename as basename3, join as join20 } from "node:path";
 
 class SessionManager {
   sessionsDir;
   constructor(projectRoot) {
-    this.sessionsDir = join19(projectRoot, ".locus", "sessions");
-    if (!existsSync18(this.sessionsDir)) {
+    this.sessionsDir = join20(projectRoot, ".locus", "sessions");
+    if (!existsSync19(this.sessionsDir)) {
       mkdirSync13(this.sessionsDir, { recursive: true });
     }
   }
@@ -9153,14 +9777,14 @@ class SessionManager {
   }
   isPersisted(sessionOrId) {
     const sessionId = typeof sessionOrId === "string" ? sessionOrId : sessionOrId.id;
-    return existsSync18(this.getSessionPath(sessionId));
+    return existsSync19(this.getSessionPath(sessionId));
   }
   load(idOrPrefix) {
     const files = this.listSessionFiles();
     const exactPath = this.getSessionPath(idOrPrefix);
-    if (existsSync18(exactPath)) {
+    if (existsSync19(exactPath)) {
       try {
-        return JSON.parse(readFileSync13(exactPath, "utf-8"));
+        return JSON.parse(readFileSync14(exactPath, "utf-8"));
       } catch {
         return null;
       }
@@ -9168,7 +9792,7 @@ class SessionManager {
     const matches = files.filter((f) => basename3(f, ".json").startsWith(idOrPrefix));
     if (matches.length === 1) {
       try {
-        return JSON.parse(readFileSync13(matches[0], "utf-8"));
+        return JSON.parse(readFileSync14(matches[0], "utf-8"));
       } catch {
         return null;
       }
@@ -9193,7 +9817,7 @@ class SessionManager {
     const sessions = [];
     for (const file of files) {
       try {
-        const session = JSON.parse(readFileSync13(file, "utf-8"));
+        const session = JSON.parse(readFileSync14(file, "utf-8"));
         sessions.push({
           id: session.id,
           created: session.created,
@@ -9208,7 +9832,7 @@ class SessionManager {
   }
   delete(sessionId) {
     const path = this.getSessionPath(sessionId);
-    if (existsSync18(path)) {
+    if (existsSync19(path)) {
       unlinkSync3(path);
       return true;
     }
@@ -9220,7 +9844,7 @@ class SessionManager {
     let pruned = 0;
     const withStats = files.map((f) => {
       try {
-        const session = JSON.parse(readFileSync13(f, "utf-8"));
+        const session = JSON.parse(readFileSync14(f, "utf-8"));
         return { path: f, updated: new Date(session.updated).getTime() };
       } catch {
         return { path: f, updated: 0 };
@@ -9238,7 +9862,7 @@ class SessionManager {
     const remaining = withStats.length - pruned;
     if (remaining > MAX_SESSIONS) {
       const toRemove = remaining - MAX_SESSIONS;
-      const alive = withStats.filter((e) => existsSync18(e.path));
+      const alive = withStats.filter((e) => existsSync19(e.path));
       for (let i = 0;i < toRemove && i < alive.length; i++) {
         try {
           unlinkSync3(alive[i].path);
@@ -9253,7 +9877,7 @@ class SessionManager {
   }
   listSessionFiles() {
     try {
-      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join19(this.sessionsDir, f));
+      return readdirSync6(this.sessionsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((f) => join20(this.sessionsDir, f));
     } catch {
       return [];
     }
@@ -9262,7 +9886,7 @@ class SessionManager {
     return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   getSessionPath(sessionId) {
-    return join19(this.sessionsDir, `${sessionId}.json`);
+    return join20(this.sessionsDir, `${sessionId}.json`);
   }
 }
 var MAX_SESSIONS = 50, SESSION_MAX_AGE_MS;
@@ -9272,12 +9896,12 @@ var init_session_manager = __esm(() => {
 });
 
 // src/repl/voice.ts
-import { execSync as execSync11, spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, unlinkSync as unlinkSync4 } from "node:fs";
+import { execSync as execSync11, spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, unlinkSync as unlinkSync4 } from "node:fs";
 import { cpus, homedir as homedir4, platform, tmpdir as tmpdir5 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function getWhisperModelPath() {
-  return join20(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
+  return join21(WHISPER_MODELS_DIR, `ggml-${WHISPER_MODEL}.bin`);
 }
 function commandExists(cmd) {
   try {
@@ -9295,16 +9919,16 @@ function findWhisperBinary() {
       return name;
   }
   for (const name of candidates) {
-    const fullPath = join20(LOCUS_BIN_DIR, name);
-    if (existsSync19(fullPath))
+    const fullPath = join21(LOCUS_BIN_DIR, name);
+    if (existsSync20(fullPath))
       return fullPath;
   }
   if (platform() === "darwin") {
     const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
     for (const dir of brewDirs) {
       for (const name of candidates) {
-        const fullPath = join20(dir, name);
-        if (existsSync19(fullPath))
+        const fullPath = join21(dir, name);
+        if (existsSync20(fullPath))
           return fullPath;
       }
     }
@@ -9319,11 +9943,11 @@ function findSoxRecBinary() {
   if (platform() === "darwin") {
     const brewDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
     for (const dir of brewDirs) {
-      const recPath = join20(dir, "rec");
-      if (existsSync19(recPath))
+      const recPath = join21(dir, "rec");
+      if (existsSync20(recPath))
         return recPath;
-      const soxPath = join20(dir, "sox");
-      if (existsSync19(soxPath))
+      const soxPath = join21(dir, "sox");
+      if (existsSync20(soxPath))
         return soxPath;
     }
   }
@@ -9332,7 +9956,7 @@ function findSoxRecBinary() {
 function checkDependencies() {
   const soxBinary = findSoxRecBinary();
   const whisperBinary = findWhisperBinary();
-  const modelDownloaded = existsSync19(getWhisperModelPath());
+  const modelDownloaded = existsSync20(getWhisperModelPath());
   return {
     sox: soxBinary !== null,
     whisper: whisperBinary !== null,
@@ -9486,7 +10110,7 @@ function ensureBuildDeps(pm) {
 }
 function buildWhisperFromSource(pm) {
   const out = process.stderr;
-  const buildDir = join20(tmpdir5(), `locus-whisper-build-${process.pid}`);
+  const buildDir = join21(tmpdir5(), `locus-whisper-build-${process.pid}`);
   if (!ensureBuildDeps(pm)) {
     out.write(`  ${red2("✗")} Could not install build tools (cmake, g++, git).
 `);
@@ -9497,8 +10121,8 @@ function buildWhisperFromSource(pm) {
     mkdirSync14(LOCUS_BIN_DIR, { recursive: true });
     out.write(`  ${dim2("Cloning whisper.cpp...")}
 `);
-    execSync11(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join20(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
-    const srcDir = join20(buildDir, "whisper.cpp");
+    execSync11(`git clone --depth 1 https://github.com/ggerganov/whisper.cpp.git "${join21(buildDir, "whisper.cpp")}"`, { stdio: ["pipe", "pipe", "pipe"], timeout: 120000 });
+    const srcDir = join21(buildDir, "whisper.cpp");
     const numCpus = cpus().length || 2;
     out.write(`  ${dim2("Building whisper.cpp (this may take a few minutes)...")}
 `);
@@ -9512,13 +10136,13 @@ function buildWhisperFromSource(pm) {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 600000
     });
-    const destPath = join20(LOCUS_BIN_DIR, "whisper-cli");
+    const destPath = join21(LOCUS_BIN_DIR, "whisper-cli");
     const binaryCandidates = [
-      join20(srcDir, "build", "bin", "whisper-cli"),
-      join20(srcDir, "build", "bin", "main")
+      join21(srcDir, "build", "bin", "whisper-cli"),
+      join21(srcDir, "build", "bin", "main")
     ];
     for (const candidate of binaryCandidates) {
-      if (existsSync19(candidate)) {
+      if (existsSync20(candidate)) {
         execSync11(`cp "${candidate}" "${destPath}" && chmod +x "${destPath}"`, {
           stdio: "pipe"
         });
@@ -9597,7 +10221,7 @@ ${bold2("Installing voice dependencies...")}
 }
 function downloadModel() {
   const modelPath = getWhisperModelPath();
-  if (existsSync19(modelPath))
+  if (existsSync20(modelPath))
     return true;
   mkdirSync14(WHISPER_MODELS_DIR, { recursive: true });
   const url = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${WHISPER_MODEL === "base.en" ? "ggml-base.en.bin" : `ggml-${WHISPER_MODEL}.bin`}`;
@@ -9644,7 +10268,7 @@ class VoiceController {
   onStateChange;
   constructor(options) {
     this.onStateChange = options.onStateChange;
-    this.tempFile = join20(tmpdir5(), `locus-voice-${process.pid}.wav`);
+    this.tempFile = join21(tmpdir5(), `locus-voice-${process.pid}.wav`);
     this.deps = checkDependencies();
   }
   getState() {
@@ -9680,7 +10304,7 @@ class VoiceController {
       return false;
     }
     const spawnArgs = binary === "rec" ? args : ["-d", ...args];
-    this.recordProcess = spawn6(binary, spawnArgs, {
+    this.recordProcess = spawn7(binary, spawnArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.recordProcess.on("error", (err) => {
@@ -9712,7 +10336,7 @@ ${red2("✗")} Recording failed: ${err.message}\r
     this.recordProcess = null;
     this.setState("idle");
     await sleep2(200);
-    if (!existsSync19(this.tempFile)) {
+    if (!existsSync20(this.tempFile)) {
       return null;
     }
     try {
@@ -9747,7 +10371,7 @@ ${red2("✗")} Recording failed: ${err.message}\r
         "--language",
         WHISPER_MODEL.endsWith(".en") ? "en" : "auto"
       ];
-      const proc = spawn6(binary, args, {
+      const proc = spawn7(binary, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       let stdout = "";
@@ -9803,8 +10427,8 @@ function sleep2(ms) {
 var WHISPER_MODEL = "base.en", WHISPER_MODELS_DIR, LOCUS_BIN_DIR;
 var init_voice = __esm(() => {
   init_terminal();
-  WHISPER_MODELS_DIR = join20(homedir4(), ".locus", "whisper-models");
-  LOCUS_BIN_DIR = join20(homedir4(), ".locus", "bin");
+  WHISPER_MODELS_DIR = join21(homedir4(), ".locus", "whisper-models");
+  LOCUS_BIN_DIR = join21(homedir4(), ".locus", "bin");
 });
 
 // src/repl/repl.ts
@@ -9842,6 +10466,16 @@ async function startRepl(options) {
   }
   if (options.prompt) {
     await executeOneShotPrompt(options.prompt, session, sessionManager, options);
+    if (session.messages.length >= 2) {
+      const log = getLogger();
+      const transcript = prepareTranscript(session.messages);
+      captureMemoryFromSession(projectRoot, transcript, {
+        model: config.ai?.model
+      }).then((result) => {
+        if (result.captured > 0)
+          log.info(`Captured ${result.captured} memory entries`);
+      }).catch(() => {});
+    }
     return;
   }
   if (!process.stdin.isTTY) {
@@ -9906,6 +10540,7 @@ async function runInteractiveRepl(session, sessionManager, options) {
   });
   printWelcome(session);
   let shouldExit = false;
+  let wasInterrupted = false;
   let currentProvider = inferProviderFromModel(config.ai.model) || config.ai.provider;
   let currentModel = config.ai.model;
   let verbose = true;
@@ -10021,6 +10656,7 @@ ${red2("✗")} ${msg}
         break;
       }
       case "interrupt":
+        wasInterrupted = true;
         shouldExit = true;
         break;
       case "exit":
@@ -10031,6 +10667,16 @@ ${red2("✗")} ${msg}
     }
   }
   voice.cancel();
+  if (!wasInterrupted && session.messages.length >= 2) {
+    const log = getLogger();
+    const transcript = prepareTranscript(session.messages);
+    captureMemoryFromSession(projectRoot, transcript, {
+      model: config.ai?.model
+    }).then((result) => {
+      if (result.captured > 0)
+        log.info(`Captured ${result.captured} memory entries`);
+    }).catch(() => {});
+  }
   const shouldPersistOnExit = session.messages.length > 0 || sessionManager.isPersisted(session);
   if (shouldPersistOnExit) {
     sessionManager.save(session);
@@ -10107,6 +10753,8 @@ var init_repl = __esm(() => {
   init_run_ai();
   init_runner();
   init_ai_models();
+  init_logger();
+  init_memory_capture();
   init_prompt_builder();
   init_sandbox();
   init_terminal();
@@ -10316,8 +10964,8 @@ var init_exec = __esm(() => {
 
 // src/core/submodule.ts
 import { execSync as execSync13 } from "node:child_process";
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join22 } from "node:path";
 function git2(args, cwd) {
   return execSync13(`git ${args}`, {
     cwd,
@@ -10333,7 +10981,7 @@ function gitSafe(args, cwd) {
   }
 }
 function hasSubmodules(cwd) {
-  return existsSync20(join21(cwd, ".gitmodules"));
+  return existsSync21(join22(cwd, ".gitmodules"));
 }
 function listSubmodules(cwd) {
   if (!hasSubmodules(cwd))
@@ -10353,7 +11001,7 @@ function listSubmodules(cwd) {
         continue;
       submodules.push({
         path,
-        absolutePath: join21(cwd, path),
+        absolutePath: join22(cwd, path),
         dirty
       });
     }
@@ -10366,7 +11014,7 @@ function getDirtySubmodules(cwd) {
   const submodules = listSubmodules(cwd);
   const dirty = [];
   for (const sub of submodules) {
-    if (!existsSync20(sub.absolutePath))
+    if (!existsSync21(sub.absolutePath))
       continue;
     const status = gitSafe("status --porcelain", sub.absolutePath);
     if (status && status.trim().length > 0) {
@@ -10453,7 +11101,7 @@ function pushSubmoduleBranches(cwd) {
   const log = getLogger();
   const submodules = listSubmodules(cwd);
   for (const sub of submodules) {
-    if (!existsSync20(sub.absolutePath))
+    if (!existsSync21(sub.absolutePath))
       continue;
     const branch = gitSafe("rev-parse --abbrev-ref HEAD", sub.absolutePath)?.trim();
     if (!branch || branch === "HEAD")
@@ -10605,6 +11253,19 @@ ${summary}
 Duration: ${timer.formatted()}${prNumber ? `
 PR: #${prNumber}` : ""}`, { cwd: projectRoot });
   } catch {}
+  const transcript = prepareTranscript([
+    {
+      role: "user",
+      content: `Issue #${issueNumber}: ${issue.title}
+
+${issue.body}`
+    },
+    { role: "assistant", content: output }
+  ]);
+  captureMemoryFromSession(projectRoot, transcript, { model: config.ai?.model }).then((result) => {
+    if (result.captured > 0)
+      log.info(`Captured ${result.captured} memory entries`);
+  }).catch(() => {});
   return {
     issueNumber,
     success: true,
@@ -10786,6 +11447,7 @@ var init_agent = __esm(() => {
   init_config();
   init_github();
   init_logger();
+  init_memory_capture();
   init_prompt_builder();
   init_sandbox();
   init_submodule();
@@ -10923,15 +11585,15 @@ var init_conflict = __esm(() => {
 
 // src/core/run-state.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync15,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { dirname as dirname6, join as join22 } from "node:path";
+import { dirname as dirname6, join as join23 } from "node:path";
 function getRunStateDir(projectRoot) {
-  return join22(projectRoot, ".locus", "run-state");
+  return join23(projectRoot, ".locus", "run-state");
 }
 function sprintSlug(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -10939,16 +11601,16 @@ function sprintSlug(name) {
 function getRunStatePath(projectRoot, sprintName) {
   const dir = getRunStateDir(projectRoot);
   if (sprintName) {
-    return join22(dir, `${sprintSlug(sprintName)}.json`);
+    return join23(dir, `${sprintSlug(sprintName)}.json`);
   }
-  return join22(dir, "_parallel.json");
+  return join23(dir, "_parallel.json");
 }
 function loadRunState(projectRoot, sprintName) {
   const path = getRunStatePath(projectRoot, sprintName);
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return null;
   try {
-    return JSON.parse(readFileSync14(path, "utf-8"));
+    return JSON.parse(readFileSync15(path, "utf-8"));
   } catch {
     getLogger().warn("Corrupted run state file, ignoring");
     return null;
@@ -10957,7 +11619,7 @@ function loadRunState(projectRoot, sprintName) {
 function saveRunState(projectRoot, state) {
   const path = getRunStatePath(projectRoot, state.sprint);
   const dir = dirname6(path);
-  if (!existsSync21(dir)) {
+  if (!existsSync22(dir)) {
     mkdirSync15(dir, { recursive: true });
   }
   writeFileSync11(path, `${JSON.stringify(state, null, 2)}
@@ -10965,7 +11627,7 @@ function saveRunState(projectRoot, state) {
 }
 function clearRunState(projectRoot, sprintName) {
   const path = getRunStatePath(projectRoot, sprintName);
-  if (existsSync21(path)) {
+  if (existsSync22(path)) {
     unlinkSync5(path);
   }
 }
@@ -11123,23 +11785,23 @@ __export(exports_worktree, {
 import { execSync as execSync16 } from "node:child_process";
 import {
   cpSync as cpSync2,
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync16,
   readdirSync as readdirSync7,
   realpathSync,
   statSync as statSync4
 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function copyLocusDir(projectRoot, worktreePath) {
-  const srcLocus = join23(projectRoot, ".locus");
-  if (!existsSync22(srcLocus))
+  const srcLocus = join24(projectRoot, ".locus");
+  if (!existsSync23(srcLocus))
     return;
-  const destLocus = join23(worktreePath, ".locus");
+  const destLocus = join24(worktreePath, ".locus");
   mkdirSync16(destLocus, { recursive: true });
   for (const entry of readdirSync7(srcLocus)) {
     if (entry === "worktrees")
       continue;
-    cpSync2(join23(srcLocus, entry), join23(destLocus, entry), { recursive: true });
+    cpSync2(join24(srcLocus, entry), join24(destLocus, entry), { recursive: true });
   }
 }
 function git4(args, cwd) {
@@ -11157,13 +11819,13 @@ function gitSafe3(args, cwd) {
   }
 }
 function getWorktreeDir(projectRoot) {
-  return join23(projectRoot, ".locus", "worktrees");
+  return join24(projectRoot, ".locus", "worktrees");
 }
 function getWorktreePath(projectRoot, issueNumber) {
-  return join23(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
+  return join24(getWorktreeDir(projectRoot), `issue-${issueNumber}`);
 }
 function getSprintWorktreePath(projectRoot, sprintSlug2) {
-  return join23(getWorktreeDir(projectRoot), `sprint-${sprintSlug2}`);
+  return join24(getWorktreeDir(projectRoot), `sprint-${sprintSlug2}`);
 }
 function generateBranchName(issueNumber) {
   const randomSuffix = Math.random().toString(36).slice(2, 8);
@@ -11176,7 +11838,7 @@ function createSprintWorktree(projectRoot, sprintName, baseBranch) {
   const log = getLogger();
   const slug = sprintSlug2(sprintName);
   const worktreePath = getSprintWorktreePath(projectRoot, slug);
-  if (existsSync22(worktreePath)) {
+  if (existsSync23(worktreePath)) {
     log.verbose(`Sprint worktree already exists for "${sprintName}"`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/sprint-${slug}`;
     return { path: worktreePath, branch: existingBranch };
@@ -11197,7 +11859,7 @@ function removeSprintWorktree(projectRoot, sprintName) {
   const log = getLogger();
   const slug = sprintSlug2(sprintName);
   const worktreePath = getSprintWorktreePath(projectRoot, slug);
-  if (!existsSync22(worktreePath)) {
+  if (!existsSync23(worktreePath)) {
     log.verbose(`Sprint worktree for "${sprintName}" does not exist`);
     return;
   }
@@ -11227,7 +11889,7 @@ function getWorktreeBranch(worktreePath) {
 function createWorktree(projectRoot, issueNumber, baseBranch) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (existsSync22(worktreePath)) {
+  if (existsSync23(worktreePath)) {
     log.verbose(`Worktree already exists for issue #${issueNumber}`);
     const existingBranch = getWorktreeBranch(worktreePath) ?? `locus/issue-${issueNumber}`;
     return {
@@ -11256,7 +11918,7 @@ function createWorktree(projectRoot, issueNumber, baseBranch) {
 function removeWorktree(projectRoot, issueNumber) {
   const log = getLogger();
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync22(worktreePath)) {
+  if (!existsSync23(worktreePath)) {
     log.verbose(`Worktree for issue #${issueNumber} does not exist`);
     return;
   }
@@ -11275,7 +11937,7 @@ function removeWorktree(projectRoot, issueNumber) {
 function listWorktrees(projectRoot) {
   const log = getLogger();
   const worktreeDir = getWorktreeDir(projectRoot);
-  if (!existsSync22(worktreeDir)) {
+  if (!existsSync23(worktreeDir)) {
     return [];
   }
   const entries = readdirSync7(worktreeDir).filter((entry) => entry.startsWith("issue-"));
@@ -11295,7 +11957,7 @@ function listWorktrees(projectRoot) {
     if (!match)
       continue;
     const issueNumber = Number.parseInt(match[1], 10);
-    const path = join23(worktreeDir, entry);
+    const path = join24(worktreeDir, entry);
     const branch = getWorktreeBranch(path) ?? `locus/issue-${issueNumber}`;
     let resolvedPath;
     try {
@@ -11335,7 +11997,7 @@ function cleanupStaleWorktrees(projectRoot) {
 }
 function pushWorktreeBranch(projectRoot, issueNumber) {
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync22(worktreePath)) {
+  if (!existsSync23(worktreePath)) {
     throw new Error(`Worktree for issue #${issueNumber} does not exist`);
   }
   const branch = getWorktreeBranch(worktreePath);
@@ -11347,18 +12009,18 @@ function pushWorktreeBranch(projectRoot, issueNumber) {
 }
 function hasWorktreeChanges(projectRoot, issueNumber) {
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync22(worktreePath))
+  if (!existsSync23(worktreePath))
     return false;
   const status = gitSafe3("status --porcelain", worktreePath);
   return status !== null && status.trim().length > 0;
 }
 function getWorktreeAge(projectRoot, issueNumber) {
   const worktreePath = getWorktreePath(projectRoot, issueNumber);
-  if (!existsSync22(worktreePath))
+  if (!existsSync23(worktreePath))
     return 0;
   try {
-    const stat = statSync4(worktreePath);
-    return Date.now() - stat.ctimeMs;
+    const stat2 = statSync4(worktreePath);
+    return Date.now() - stat2.ctimeMs;
   } catch {
     return 0;
   }
@@ -11374,8 +12036,8 @@ __export(exports_run, {
   runCommand: () => runCommand
 });
 import { execSync as execSync17 } from "node:child_process";
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import { join as join25 } from "node:path";
 function resolveExecutionContext(config, modelOverride) {
   const model = modelOverride ?? config.ai.model;
   const provider = inferProviderFromModel(model) ?? config.ai.provider;
@@ -11933,8 +12595,8 @@ async function handleResume(projectRoot, config, sandboxed, flags) {
   const sprintsToResume = [];
   try {
     const { readdirSync: readdirSync8 } = await import("node:fs");
-    const runStateDir = join24(projectRoot, ".locus", "run-state");
-    if (existsSync23(runStateDir)) {
+    const runStateDir = join25(projectRoot, ".locus", "run-state");
+    if (existsSync24(runStateDir)) {
       const files = readdirSync8(runStateDir).filter((f) => f.endsWith(".json"));
       for (const file of files) {
         const sprintName = file === "_parallel.json" ? undefined : file.replace(/\.json$/, "");
@@ -11978,9 +12640,9 @@ ${bold2("Resuming")} ${state.type} run ${dim2(state.runId)}${state.sprint ? ` ($
   let workDir = projectRoot;
   if (state.type === "sprint" && state.sprint) {
     const { getSprintWorktreePath: getSprintWorktreePath2, sprintSlug: sprintSlug3 } = await Promise.resolve().then(() => (init_worktree(), exports_worktree));
-    const { existsSync: existsSync24 } = await import("node:fs");
+    const { existsSync: existsSync25 } = await import("node:fs");
     const wtPath = getSprintWorktreePath2(projectRoot, sprintSlug3(state.sprint));
-    if (existsSync24(wtPath)) {
+    if (existsSync25(wtPath)) {
       workDir = wtPath;
     } else if (state.branch) {
       try {
@@ -12210,8 +12872,8 @@ __export(exports_status, {
   statusCommand: () => statusCommand
 });
 import { execSync as execSync18 } from "node:child_process";
-import { existsSync as existsSync24 } from "node:fs";
-import { dirname as dirname7, join as join25 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { dirname as dirname7, join as join26 } from "node:path";
 async function statusCommand(projectRoot) {
   const config = loadConfig(projectRoot);
   const spinner = new Spinner;
@@ -12343,13 +13005,13 @@ ${drawBox(lines, { title: "Locus Status" })}
 `);
 }
 function getPm2Bin() {
-  const pkgsBin = join25(getPackagesDir(), "node_modules", ".bin", "pm2");
-  if (existsSync24(pkgsBin))
+  const pkgsBin = join26(getPackagesDir(), "node_modules", ".bin", "pm2");
+  if (existsSync25(pkgsBin))
     return pkgsBin;
   let dir = process.cwd();
   while (dir !== dirname7(dir)) {
-    const candidate = join25(dir, "node_modules", ".bin", "pm2");
-    if (existsSync24(candidate))
+    const candidate = join26(dir, "node_modules", ".bin", "pm2");
+    if (existsSync25(candidate))
       return candidate;
     dir = dirname7(dir);
   }
@@ -12545,13 +13207,13 @@ __export(exports_plan, {
   parsePlanArgs: () => parsePlanArgs
 });
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   mkdirSync as mkdirSync17,
   readdirSync as readdirSync8,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   writeFileSync as writeFileSync12
 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function printHelp2() {
   process.stderr.write(`
 ${bold2("locus plan")} — AI-powered sprint planning
@@ -12583,11 +13245,11 @@ function normalizeSprintName(name) {
   return name.trim().toLowerCase();
 }
 function getPlansDir(projectRoot) {
-  return join26(projectRoot, ".locus", "plans");
+  return join27(projectRoot, ".locus", "plans");
 }
 function ensurePlansDir(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     mkdirSync17(dir, { recursive: true });
   }
   return dir;
@@ -12597,14 +13259,14 @@ function generateId() {
 }
 function loadPlanFile(projectRoot, id) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync25(dir))
+  if (!existsSync26(dir))
     return null;
   const files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
   const match = files.find((f) => f.startsWith(id));
   if (!match)
     return null;
   try {
-    const content = readFileSync15(join26(dir, match), "utf-8");
+    const content = readFileSync16(join27(dir, match), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -12671,7 +13333,7 @@ async function planCommand(projectRoot, args, flags = {}) {
 }
 function handleListPlans(projectRoot) {
   const dir = getPlansDir(projectRoot);
-  if (!existsSync25(dir)) {
+  if (!existsSync26(dir)) {
     process.stderr.write(`${dim2("No saved plans yet.")}
 `);
     return;
@@ -12689,7 +13351,7 @@ ${bold2("Saved Plans:")}
   for (const file of files) {
     const id = file.replace(".json", "");
     try {
-      const content = readFileSync15(join26(dir, file), "utf-8");
+      const content = readFileSync16(join27(dir, file), "utf-8");
       const plan = JSON.parse(content);
       const date = plan.createdAt ? plan.createdAt.slice(0, 10) : "";
       const issueCount = Array.isArray(plan.issues) ? plan.issues.length : 0;
@@ -12757,7 +13419,7 @@ async function handleRefinePlan(projectRoot, id, feedback, flags) {
     return;
   }
   const config = loadConfig(projectRoot);
-  const planPath = join26(getPlansDir(projectRoot), `${plan.id}.json`);
+  const planPath = join27(getPlansDir(projectRoot), `${plan.id}.json`);
   const planPathRelative = `.locus/plans/${plan.id}.json`;
   process.stderr.write(`
 ${bold2("Refining plan:")} ${cyan2(plan.directive)}
@@ -12796,7 +13458,7 @@ ${red2("✗")} Refinement failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync25(planPath)) {
+  if (!existsSync26(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
 `);
@@ -12804,7 +13466,7 @@ ${yellow2("⚠")} Plan file was not found at ${bold2(planPathRelative)}.
   }
   let updatedPlan;
   try {
-    const content = readFileSync15(planPath, "utf-8");
+    const content = readFileSync16(planPath, "utf-8");
     updatedPlan = JSON.parse(content);
   } catch {
     process.stderr.write(`
@@ -12894,7 +13556,7 @@ ${bold2("Approving plan:")}
 async function handleAIPlan(projectRoot, config, directive, sprintName, flags) {
   const id = generateId();
   const plansDir = ensurePlansDir(projectRoot);
-  const planPath = join26(plansDir, `${id}.json`);
+  const planPath = join27(plansDir, `${id}.json`);
   const planPathRelative = `.locus/plans/${id}.json`;
   const displayDirective = directive;
   process.stderr.write(`
@@ -12937,7 +13599,7 @@ ${red2("✗")} Planning failed: ${aiResult.error}
 `);
     return;
   }
-  if (!existsSync25(planPath)) {
+  if (!existsSync26(planPath)) {
     process.stderr.write(`
 ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
 `);
@@ -12947,7 +13609,7 @@ ${yellow2("⚠")} Plan file was not created at ${bold2(planPathRelative)}.
   }
   let plan;
   try {
-    const content = readFileSync15(planPath, "utf-8");
+    const content = readFileSync16(planPath, "utf-8");
     plan = JSON.parse(content);
   } catch {
     process.stderr.write(`
@@ -13109,6 +13771,18 @@ ${bold2("Suggested Order:")}
 `);
   }
 }
+function loadPastMemory(projectRoot) {
+  const memoryDir = getMemoryDir(projectRoot);
+  if (existsSync26(memoryDir)) {
+    const content = readAllMemorySync(projectRoot);
+    if (content.trim()) {
+      return content.length > MEMORY_MAX_CHARS2 ? `${content.slice(0, MEMORY_MAX_CHARS2)}
+
+...(truncated)` : content;
+    }
+  }
+  return "";
+}
 function buildPlanningPrompt(projectRoot, config, directive, sprintName, id, planPathRelative) {
   const parts = [];
   parts.push(`<role>
@@ -13119,18 +13793,17 @@ ${directive}${sprintName ? `
 
 **Sprint:** ${sprintName}` : ""}
 </directive>`);
-  const locusPath = join26(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync25(locusPath)) {
-    const content = readFileSync15(locusPath, "utf-8");
+  const locusPath = join27(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync26(locusPath)) {
+    const content = readFileSync16(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join26(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync25(learningsPath)) {
-    const content = readFileSync15(learningsPath, "utf-8");
+  const memoryContent = loadPastMemory(projectRoot);
+  if (memoryContent) {
     parts.push(`<past-learnings>
-${content.slice(0, 2000)}
+${memoryContent}
 </past-learnings>`);
   }
   parts.push(`<task>
@@ -13180,9 +13853,9 @@ ${JSON.stringify(plan, null, 2)}
   parts.push(`<feedback>
 ${feedback}
 </feedback>`);
-  const locusPath = join26(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync25(locusPath)) {
-    const content = readFileSync15(locusPath, "utf-8");
+  const locusPath = join27(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync26(locusPath)) {
+    const content = readFileSync16(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
@@ -13350,10 +14023,12 @@ ${green("✓")} Created ${planned.length} issues.${milestoneTitle ? ` Sprint: ${
 
 `);
 }
+var MEMORY_MAX_CHARS2 = 2000;
 var init_plan = __esm(() => {
   init_run_ai();
   init_config();
   init_github();
+  init_memory();
   init_sandbox();
   init_terminal();
 });
@@ -13364,8 +14039,8 @@ __export(exports_review, {
   reviewCommand: () => reviewCommand
 });
 import { execFileSync as execFileSync2, execSync as execSync19 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync16 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync17 } from "node:fs";
+import { join as join28 } from "node:path";
 function printHelp3() {
   process.stderr.write(`
 ${bold2("locus review")} — AI-powered code review
@@ -13534,9 +14209,9 @@ function buildReviewPrompt(projectRoot, config, pr, diff, focus) {
   parts.push(`<role>
 You are an expert code reviewer for the ${config.github.owner}/${config.github.repo} repository.
 </role>`);
-  const locusPath = join27(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync26(locusPath)) {
-    const content = readFileSync16(locusPath, "utf-8");
+  const locusPath = join28(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync27(locusPath)) {
+    const content = readFileSync17(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 2000)}
 </project-context>`);
@@ -13851,14 +14526,14 @@ __export(exports_discuss, {
   discussCommand: () => discussCommand
 });
 import {
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync18,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function printHelp5() {
   process.stderr.write(`
 ${bold2("locus discuss")} — AI-powered architectural discussions
@@ -13880,11 +14555,11 @@ ${bold2("Examples:")}
 `);
 }
 function getDiscussionsDir(projectRoot) {
-  return join28(projectRoot, ".locus", "discussions");
+  return join29(projectRoot, ".locus", "discussions");
 }
 function ensureDiscussionsDir(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync27(dir)) {
+  if (!existsSync28(dir)) {
     mkdirSync18(dir, { recursive: true });
   }
   return dir;
@@ -13919,7 +14594,7 @@ async function discussCommand(projectRoot, args, flags = {}) {
 }
 function listDiscussions(projectRoot) {
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync27(dir)) {
+  if (!existsSync28(dir)) {
     process.stderr.write(`${dim2("No discussions yet.")}
 `);
     return;
@@ -13936,7 +14611,7 @@ ${bold2("Discussions:")}
 `);
   for (const file of files) {
     const id = file.replace(".md", "");
-    const content = readFileSync17(join28(dir, file), "utf-8");
+    const content = readFileSync18(join29(dir, file), "utf-8");
     const titleMatch = content.match(/^#\s+(.+)/m);
     const title = titleMatch ? titleMatch[1] : id;
     const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/);
@@ -13954,7 +14629,7 @@ function showDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync27(dir)) {
+  if (!existsSync28(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13966,7 +14641,7 @@ function showDiscussion(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync17(join28(dir, match), "utf-8");
+  const content = readFileSync18(join29(dir, match), "utf-8");
   process.stdout.write(`${content}
 `);
 }
@@ -13977,7 +14652,7 @@ function deleteDiscussion(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync27(dir)) {
+  if (!existsSync28(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -13989,7 +14664,7 @@ function deleteDiscussion(projectRoot, id) {
 `);
     return;
   }
-  unlinkSync6(join28(dir, match));
+  unlinkSync6(join29(dir, match));
   process.stderr.write(`${green("✓")} Deleted discussion: ${match.replace(".md", "")}
 `);
 }
@@ -14002,7 +14677,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
     return;
   }
   const dir = getDiscussionsDir(projectRoot);
-  if (!existsSync27(dir)) {
+  if (!existsSync28(dir)) {
     process.stderr.write(`${red2("✗")} No discussions found.
 `);
     return;
@@ -14014,7 +14689,7 @@ async function convertDiscussionToPlan(projectRoot, id) {
 `);
     return;
   }
-  const content = readFileSync17(join28(dir, match), "utf-8");
+  const content = readFileSync18(join29(dir, match), "utf-8");
   const titleMatch = content.match(/^#\s+(.+)/m);
   const discussionTitle = titleMatch ? titleMatch[1].trim() : id;
   await planCommand(projectRoot, [
@@ -14140,7 +14815,7 @@ ${turn.content}`;
     ...conversation.length > 1 ? [`---`, ``, `## Discussion Transcript`, ``, transcript, ``] : []
   ].join(`
 `);
-  writeFileSync13(join28(dir, `${id}.md`), markdown, "utf-8");
+  writeFileSync13(join29(dir, `${id}.md`), markdown, "utf-8");
   process.stderr.write(`
 ${green("✓")} Discussion saved: ${cyan2(id)} ${dim2(`(${timer.formatted()})`)}
 `);
@@ -14150,23 +14825,34 @@ ${green("✓")} Discussion saved: ${cyan2(id)} ${dim2(`(${timer.formatted()})`)}
 
 `);
 }
+function loadPastMemory2(projectRoot) {
+  const memoryDir = getMemoryDir(projectRoot);
+  if (existsSync28(memoryDir)) {
+    const content = readAllMemorySync(projectRoot);
+    if (content.trim()) {
+      return content.length > MEMORY_MAX_CHARS3 ? `${content.slice(0, MEMORY_MAX_CHARS3)}
+
+...(truncated)` : content;
+    }
+  }
+  return "";
+}
 function buildDiscussionPrompt(projectRoot, config, topic, conversation, forceFinal) {
   const parts = [];
   parts.push(`<role>
 You are a senior software architect and consultant for the ${config.github.owner}/${config.github.repo} project.
 </role>`);
-  const locusPath = join28(projectRoot, ".locus", "LOCUS.md");
-  if (existsSync27(locusPath)) {
-    const content = readFileSync17(locusPath, "utf-8");
+  const locusPath = join29(projectRoot, ".locus", "LOCUS.md");
+  if (existsSync28(locusPath)) {
+    const content = readFileSync18(locusPath, "utf-8");
     parts.push(`<project-context>
 ${content.slice(0, 3000)}
 </project-context>`);
   }
-  const learningsPath = join28(projectRoot, ".locus", "LEARNINGS.md");
-  if (existsSync27(learningsPath)) {
-    const content = readFileSync17(learningsPath, "utf-8");
+  const memoryContent = loadPastMemory2(projectRoot);
+  if (memoryContent) {
     parts.push(`<past-learnings>
-${content.slice(0, 2000)}
+${memoryContent}
 </past-learnings>`);
   }
   parts.push(`<discussion-topic>
@@ -14215,10 +14901,11 @@ If you still need key information to give a good answer:
 
 `);
 }
-var MAX_DISCUSSION_ROUNDS = 5;
+var MAX_DISCUSSION_ROUNDS = 5, MEMORY_MAX_CHARS3 = 2000;
 var init_discuss = __esm(() => {
   init_run_ai();
   init_config();
+  init_memory();
   init_sandbox();
   init_progress();
   init_terminal();
@@ -14235,8 +14922,8 @@ __export(exports_artifacts, {
   formatDate: () => formatDate2,
   artifactsCommand: () => artifactsCommand
 });
-import { existsSync as existsSync28, readdirSync as readdirSync10, readFileSync as readFileSync18, statSync as statSync5 } from "node:fs";
-import { join as join29 } from "node:path";
+import { existsSync as existsSync29, readdirSync as readdirSync10, readFileSync as readFileSync19, statSync as statSync5 } from "node:fs";
+import { join as join30 } from "node:path";
 function printHelp6() {
   process.stderr.write(`
 ${bold2("locus artifacts")} — View and manage AI-generated artifacts
@@ -14256,37 +14943,37 @@ ${dim2("Artifact names support partial matching.")}
 `);
 }
 function getArtifactsDir(projectRoot) {
-  return join29(projectRoot, ".locus", "artifacts");
+  return join30(projectRoot, ".locus", "artifacts");
 }
 function listArtifacts(projectRoot) {
   const dir = getArtifactsDir(projectRoot);
-  if (!existsSync28(dir))
+  if (!existsSync29(dir))
     return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".md")).map((fileName) => {
-    const filePath = join29(dir, fileName);
-    const stat = statSync5(filePath);
+    const filePath = join30(dir, fileName);
+    const stat2 = statSync5(filePath);
     return {
       name: fileName.replace(/\.md$/, ""),
       fileName,
-      createdAt: stat.birthtime,
-      size: stat.size
+      createdAt: stat2.birthtime,
+      size: stat2.size
     };
   }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
 }
 function readArtifact(projectRoot, name) {
   const dir = getArtifactsDir(projectRoot);
   const fileName = name.endsWith(".md") ? name : `${name}.md`;
-  const filePath = join29(dir, fileName);
-  if (!existsSync28(filePath))
+  const filePath = join30(dir, fileName);
+  if (!existsSync29(filePath))
     return null;
-  const stat = statSync5(filePath);
+  const stat2 = statSync5(filePath);
   return {
-    content: readFileSync18(filePath, "utf-8"),
+    content: readFileSync19(filePath, "utf-8"),
     info: {
       name: fileName.replace(/\.md$/, ""),
       fileName,
-      createdAt: stat.birthtime,
-      size: stat.size
+      createdAt: stat2.birthtime,
+      size: stat2.size
     }
   };
 }
@@ -14581,7 +15268,7 @@ Co-Authored-By: LocusAgent <agent@locusai.team>`;
 `);
   }
 }
-function buildCommitPrompt(diff, stat, recentCommits) {
+function buildCommitPrompt(diff, stat2, recentCommits) {
   const maxDiffLength = 15000;
   const truncatedDiff = diff.length > maxDiffLength ? `${diff.slice(0, maxDiffLength)}
 
@@ -14604,7 +15291,7 @@ ${recentCommits}
 `;
   }
   prompt += `File summary:
-${stat}
+${stat2}
 
 Diff:
 ${truncatedDiff}`;
@@ -14638,10 +15325,10 @@ __export(exports_sandbox2, {
   parseSandboxLogsArgs: () => parseSandboxLogsArgs,
   parseSandboxInstallArgs: () => parseSandboxInstallArgs
 });
-import { execSync as execSync22, spawn as spawn7 } from "node:child_process";
+import { execSync as execSync22, spawn as spawn8 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync29, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename4, join as join30 } from "node:path";
+import { existsSync as existsSync30, readFileSync as readFileSync20 } from "node:fs";
+import { basename as basename4, join as join31 } from "node:path";
 import { createInterface as createInterface3 } from "node:readline";
 function printSandboxHelp() {
   process.stderr.write(`
@@ -14830,7 +15517,7 @@ async function handleAgentLogin(projectRoot, agent) {
   process.stderr.write(`${dim2("Login and then exit when ready.")}
 
 `);
-  const child = spawn7("docker", [
+  const child = spawn8("docker", [
     "sandbox",
     "exec",
     "--privileged",
@@ -15171,7 +15858,7 @@ async function handleLogs(projectRoot, args) {
 }
 function detectPackageManager2(projectRoot) {
   try {
-    const raw = readFileSync19(join30(projectRoot, "package.json"), "utf-8");
+    const raw = readFileSync20(join31(projectRoot, "package.json"), "utf-8");
     const pkgJson = JSON.parse(raw);
     if (typeof pkgJson.packageManager === "string") {
       const name = pkgJson.packageManager.split("@")[0];
@@ -15180,13 +15867,13 @@ function detectPackageManager2(projectRoot) {
       }
     }
   } catch {}
-  if (existsSync29(join30(projectRoot, "bun.lock")) || existsSync29(join30(projectRoot, "bun.lockb"))) {
+  if (existsSync30(join31(projectRoot, "bun.lock")) || existsSync30(join31(projectRoot, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync29(join30(projectRoot, "yarn.lock"))) {
+  if (existsSync30(join31(projectRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync29(join30(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync30(join31(projectRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
   return "npm";
@@ -15289,9 +15976,9 @@ Installing sandbox dependencies (${bold2(installCmd.join(" "))}) to container fi
 ${dim2(`Detected ${ecosystem} project — skipping JS package install.`)}
 `);
   }
-  const setupScript = join30(projectRoot, ".locus", "sandbox-setup.sh");
-  const containerSetupScript = containerWorkdir ? join30(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
-  if (existsSync29(setupScript)) {
+  const setupScript = join31(projectRoot, ".locus", "sandbox-setup.sh");
+  const containerSetupScript = containerWorkdir ? join31(containerWorkdir, ".locus", "sandbox-setup.sh") : setupScript;
+  if (existsSync30(setupScript)) {
     process.stderr.write(`Running ${bold2(".locus/sandbox-setup.sh")} in sandbox ${dim2(sandboxName)}...
 `);
     const hookOk = await runInteractiveCommand("docker", [
@@ -15373,7 +16060,7 @@ function getActiveProviderSandbox(projectRoot, provider) {
 }
 function runInteractiveCommand(command, args) {
   return new Promise((resolve2) => {
-    const child = spawn7(command, args, { stdio: "inherit" });
+    const child = spawn8(command, args, { stdio: "inherit" });
     child.on("close", (code) => resolve2(code === 0));
     child.on("error", () => resolve2(false));
   });
@@ -15458,23 +16145,295 @@ var init_sandbox2 = __esm(() => {
   PROVIDERS = ["claude", "codex"];
 });
 
+// src/commands/memory.ts
+var exports_memory = {};
+__export(exports_memory, {
+  memoryCommand: () => memoryCommand
+});
+import { existsSync as existsSync31 } from "node:fs";
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { join as join32 } from "node:path";
+import { createInterface as createInterface4 } from "node:readline";
+function printHelp7() {
+  process.stderr.write(`
+${bold2("locus memory")} — Inspect, search, and manage structured memory
+
+${bold2("Usage:")}
+  locus memory list [--category <name>]   List all memory entries
+  locus memory search <query>             Search entries by keyword
+  locus memory stats                      Show per-category statistics
+  locus memory reset [--confirm]          Clear all entries (preserve headers)
+  locus memory migrate                    Migrate legacy LEARNINGS.md → memory/
+
+${bold2("Categories:")}
+  architecture, conventions, decisions, preferences, debugging
+
+${bold2("Examples:")}
+  locus memory list                       ${dim2("# Show all entries")}
+  locus memory list --category debugging  ${dim2("# Show only debugging entries")}
+  locus memory search "sandbox"           ${dim2("# Search for 'sandbox'")}
+  locus memory stats                      ${dim2("# Show entry counts and sizes")}
+  locus memory reset --confirm            ${dim2("# Clear all entries")}
+  locus memory migrate                    ${dim2("# Migrate legacy LEARNINGS.md")}
+`);
+}
+async function memoryCommand(projectRoot, args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help") {
+    printHelp7();
+    return;
+  }
+  const memoryDir = getMemoryDir(projectRoot);
+  if (!existsSync31(memoryDir) && subcommand !== "migrate") {
+    process.stderr.write(`${red2("✗")} Memory directory not found at ${dim2(".locus/memory/")}
+`);
+    process.stderr.write(`  Run ${bold2("locus init")} to create the memory directory.
+`);
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "list":
+      await handleList(projectRoot, args.slice(1));
+      break;
+    case "search":
+      await handleSearch(projectRoot, args.slice(1));
+      break;
+    case "stats":
+      await handleStats(projectRoot);
+      break;
+    case "reset":
+      await handleReset(projectRoot, args.slice(1));
+      break;
+    case "migrate":
+      await handleMigrate(projectRoot);
+      break;
+    default:
+      process.stderr.write(`${red2("✗")} Unknown subcommand: ${bold2(subcommand)}
+`);
+      process.stderr.write(`  Run ${bold2("locus memory help")} for available subcommands.
+`);
+      process.exit(1);
+  }
+}
+async function handleList(projectRoot, args) {
+  let categoryFilter;
+  const catIdx = args.indexOf("--category");
+  if (catIdx !== -1) {
+    categoryFilter = args[catIdx + 1];
+    if (!categoryFilter || !MEMORY_CATEGORIES[categoryFilter]) {
+      const valid = Object.keys(MEMORY_CATEGORIES).join(", ");
+      process.stderr.write(`${red2("✗")} Invalid category. Valid categories: ${valid}
+`);
+      process.exit(1);
+    }
+  }
+  const categories = categoryFilter ? [categoryFilter] : Object.keys(MEMORY_CATEGORIES);
+  let totalEntries = 0;
+  for (const category of categories) {
+    const content = await readMemoryFile(projectRoot, category);
+    const entries = parseEntries(content);
+    if (entries.length === 0)
+      continue;
+    const meta = MEMORY_CATEGORIES[category];
+    process.stderr.write(`
+${bold2(cyan2(meta.title))} ${dim2(`(${meta.description})`)}
+`);
+    for (const entry of entries) {
+      process.stderr.write(`  ${entry}
+`);
+    }
+    totalEntries += entries.length;
+  }
+  if (totalEntries === 0) {
+    process.stderr.write(`
+${dim2("No memory entries found.")}
+`);
+  } else {
+    process.stderr.write(`
+${dim2(`${totalEntries} entries total`)}
+`);
+  }
+}
+async function handleSearch(projectRoot, args) {
+  const query = args.join(" ").trim();
+  if (!query) {
+    process.stderr.write(`${red2("✗")} Usage: locus memory search <query>
+`);
+    process.exit(1);
+  }
+  const queryLower = query.toLowerCase();
+  let matchCount = 0;
+  for (const [category, meta] of Object.entries(MEMORY_CATEGORIES)) {
+    const content = await readMemoryFile(projectRoot, category);
+    const entries = parseEntries(content);
+    const matches = entries.filter((entry) => entry.toLowerCase().includes(queryLower));
+    if (matches.length === 0)
+      continue;
+    process.stderr.write(`
+${bold2(cyan2(meta.title))}
+`);
+    for (const entry of matches) {
+      const highlighted = highlightMatch(entry, query);
+      process.stderr.write(`  ${highlighted}
+`);
+    }
+    matchCount += matches.length;
+  }
+  if (matchCount === 0) {
+    process.stderr.write(`
+${dim2("No matches found for")} "${query}"
+`);
+  } else {
+    process.stderr.write(`
+${green(`${matchCount} match${matchCount === 1 ? "" : "es"}`)} found for "${query}"
+`);
+  }
+}
+async function handleStats(projectRoot) {
+  const stats = await getMemoryStats(projectRoot);
+  process.stderr.write(`
+${bold2("Memory Statistics")}
+
+`);
+  let totalEntries = 0;
+  let totalSize = 0;
+  for (const [key, meta] of Object.entries(MEMORY_CATEGORIES)) {
+    const s = stats[key];
+    const countStr = String(s.count).padStart(3);
+    const sizeStr = formatSize2(s.size).padStart(8);
+    const dateStr = s.size > 0 ? dim2(s.lastModified.toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric",
+      year: "numeric"
+    })) : dim2("—");
+    const icon = s.count > 0 ? green("●") : dim2("○");
+    process.stderr.write(`  ${icon} ${cyan2(meta.title.padEnd(14))} ${countStr} entries  ${sizeStr}  ${dateStr}
+`);
+    totalEntries += s.count;
+    totalSize += s.size;
+  }
+  process.stderr.write(`
+  ${bold2("Total:")} ${totalEntries} entries, ${formatSize2(totalSize)}
+`);
+  process.stderr.write(`
+`);
+}
+async function handleReset(projectRoot, args) {
+  const confirmed = args.includes("--confirm");
+  if (!confirmed) {
+    const rl = createInterface4({
+      input: process.stdin,
+      output: process.stderr
+    });
+    const answer = await new Promise((resolve2) => {
+      rl.question(`${yellow2("⚠")} This will clear all memory entries. Continue? (y/N) `, (ans) => {
+        rl.close();
+        resolve2(ans.trim().toLowerCase());
+      });
+    });
+    if (answer !== "y" && answer !== "yes") {
+      process.stderr.write(`${dim2("Cancelled.")}
+`);
+      return;
+    }
+  }
+  const stats = await getMemoryStats(projectRoot);
+  const memoryDir = getMemoryDir(projectRoot);
+  let totalCleared = 0;
+  for (const [key, meta] of Object.entries(MEMORY_CATEGORIES)) {
+    const count = stats[key].count;
+    const filePath = join32(memoryDir, meta.file);
+    const header = `# ${meta.title}
+
+${meta.description}
+
+`;
+    await writeFile2(filePath, header, "utf-8");
+    if (count > 0) {
+      process.stderr.write(`  ${dim2("○")} ${meta.title}: cleared ${count} entries
+`);
+      totalCleared += count;
+    }
+  }
+  if (totalCleared > 0) {
+    process.stderr.write(`
+${green("✓")} Cleared ${totalCleared} entries (file headers preserved)
+`);
+  } else {
+    process.stderr.write(`${dim2("No entries to clear.")}
+`);
+  }
+}
+async function handleMigrate(projectRoot) {
+  const learningsPath = join32(projectRoot, ".locus", "LEARNINGS.md");
+  if (!existsSync31(learningsPath)) {
+    process.stderr.write(`${dim2("○")} No LEARNINGS.md found — nothing to migrate.
+`);
+    return;
+  }
+  process.stderr.write(`Migrating entries from LEARNINGS.md...
+`);
+  const result = await migrateFromLearnings(projectRoot);
+  if (result.migrated > 0) {
+    process.stderr.write(`${green("✓")} Migrated ${result.migrated} entries to .locus/memory/
+`);
+  }
+  if (result.skipped > 0) {
+    process.stderr.write(`${dim2("○")} Skipped ${result.skipped} duplicate entries
+`);
+  }
+  if (result.migrated > 0 || result.skipped > 0) {
+    process.stderr.write(`${green("✓")} Removed legacy LEARNINGS.md
+`);
+  }
+  if (result.migrated === 0 && result.skipped === 0) {
+    process.stderr.write(`${dim2("○")} No entries found in LEARNINGS.md to migrate.
+`);
+  }
+}
+function parseEntries(content) {
+  if (!content)
+    return [];
+  return content.split(`
+`).filter((line) => line.startsWith("- "));
+}
+function highlightMatch(text, query) {
+  const regex = new RegExp(`(${escapeRegex(query)})`, "gi");
+  return text.replace(regex, (match) => bold2(match));
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatSize2(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const kb = bytes / 1024;
+  return `${kb.toFixed(1)} KB`;
+}
+var init_memory2 = __esm(() => {
+  init_memory();
+  init_terminal();
+});
+
 // src/cli.ts
 init_config();
 init_context();
 init_logger();
 init_rate_limiter();
 init_terminal();
-import { existsSync as existsSync30, readFileSync as readFileSync20 } from "node:fs";
-import { join as join31 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync21 } from "node:fs";
+import { join as join33 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getCliVersion() {
   const fallbackVersion = "0.0.0";
-  const packageJsonPath = join31(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
-  if (!existsSync30(packageJsonPath)) {
+  const packageJsonPath = join33(fileURLToPath(new URL(".", import.meta.url)), "..", "package.json");
+  if (!existsSync32(packageJsonPath)) {
     return fallbackVersion;
   }
   try {
-    const parsed = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync21(packageJsonPath, "utf-8"));
     return parsed.version ?? fallbackVersion;
   } catch {
     return fallbackVersion;
@@ -15636,7 +16595,7 @@ function printLogo() {
 `);
   }
 }
-function printHelp7() {
+function printHelp8() {
   printLogo();
   process.stderr.write(`
 
@@ -15664,6 +16623,7 @@ ${bold2("Commands:")}
   ${cyan2("packages")}          Manage installed packages (list, outdated)
   ${cyan2("pkg")} ${dim2("<name> [cmd]")}   Run a command from an installed package
   ${cyan2("skills")}            Discover and manage agent skills
+  ${cyan2("memory")}            Inspect, search, and manage memory
   ${cyan2("sandbox")}           Manage Docker sandbox lifecycle
   ${cyan2("upgrade")}           Check for and install updates
 
@@ -15746,7 +16706,7 @@ async function main() {
     process.exit(0);
   }
   if (parsed.flags.help && !parsed.command) {
-    printHelp7();
+    printHelp8();
     process.exit(0);
   }
   const command = resolveAlias(parsed.command);
@@ -15757,7 +16717,7 @@ async function main() {
     try {
       const root = getGitRoot(cwd);
       if (isInitialized(root)) {
-        logDir = join31(root, ".locus", "logs");
+        logDir = join33(root, ".locus", "logs");
         getRateLimiter(root);
       }
     } catch {}
@@ -15778,7 +16738,7 @@ async function main() {
     printVersionNotice = startVersionCheck2(VERSION);
   }
   if (!command) {
-    printHelp7();
+    printHelp8();
     process.exit(0);
   }
   if (command === "init") {
@@ -15974,6 +16934,12 @@ async function main() {
       await sandboxCommand2(projectRoot, sandboxArgs);
       break;
     }
+    case "memory": {
+      const { memoryCommand: memoryCommand2 } = await Promise.resolve().then(() => (init_memory2(), exports_memory));
+      const memoryArgs = parsed.flags.help ? ["help"] : parsed.args;
+      await memoryCommand2(projectRoot, memoryArgs);
+      break;
+    }
     case "upgrade": {
       const { upgradeCommand: upgradeCommand2 } = await Promise.resolve().then(() => (init_upgrade(), exports_upgrade));
       await upgradeCommand2(projectRoot, parsed.args, {