open-think 0.3.3 → 0.3.5

package/dist/{chunk-ZKUJ5M2W.js → chunk-BBCWF24H.js}

@@ -2,7 +2,7 @@
 import {
   getRepoPath,
   getThinkConfigDir
-} from "./chunk-DCTG6IK4.js";
+} from "./chunk-HUBRLTY3.js";
 
 // src/lib/git.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-DCTG6IK4.js → chunk-HUBRLTY3.js}

@@ -60,6 +60,7 @@ function ensureThinkDirs() {
 }
 
 export {
+  getThinkDir,
   getThinkConfigDir,
   getThinkDataDir,
   getEngramsDir,

package/dist/{chunk-OFGWR45G.js → chunk-LN2TIS5R.js}

@@ -2,7 +2,7 @@
 import {
   ensureThinkDirs,
   getEngramDbPath
-} from "./chunk-DCTG6IK4.js";
+} from "./chunk-HUBRLTY3.js";
 
 // src/db/memory-queries.ts
 import { v7 as uuidv7 } from "uuid";

package/dist/{git-TG6OJFBT.js → git-CMDUX3KB.js}

@@ -11,8 +11,8 @@ import {
   listRemoteBranches,
   migrateToBuckets,
   readFileFromBranch
-} from "./chunk-ZKUJ5M2W.js";
-import "./chunk-DCTG6IK4.js";
+} from "./chunk-BBCWF24H.js";
+import "./chunk-HUBRLTY3.js";
 export {
   appendAndCommit,
   branchExists,

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   setLongtermSummary,
   setSyncCursor,
   tombstoneMemory
-} from "./chunk-OFGWR45G.js";
+} from "./chunk-LN2TIS5R.js";
 import {
   appendAndCommit,
   countBranchFileLines,
@@ -28,18 +28,19 @@ import {
   migrateToBuckets,
   readFileFromBranch,
   saveConfig
-} from "./chunk-ZKUJ5M2W.js";
+} from "./chunk-BBCWF24H.js";
 import {
   ensureThinkDirs,
   getCuratorMdPath,
   getEngramsDir,
   getLongtermPath,
-  getThinkDataDir
-} from "./chunk-DCTG6IK4.js";
+  getThinkDataDir,
+  getThinkDir
+} from "./chunk-HUBRLTY3.js";
 
 // src/index.ts
-import fs11 from "fs";
-import path5 from "path";
+import fs13 from "fs";
+import path7 from "path";
 import { Command as Command20 } from "commander";
 
 // src/commands/log.ts
@@ -1010,7 +1011,7 @@ ${shown.length} events` + (entries.length > limit ? ` (showing last ${limit} of
 });
 
 // src/commands/cortex.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import { Command as Command9 } from "commander";
 import chalk9 from "chalk";
 import readline2 from "readline";
@@ -1555,6 +1556,146 @@ function getSyncAdapter() {
   return null;
 }
 
+// src/lib/auto-curate.ts
+import fs8 from "fs";
+import path5 from "path";
+import crypto2 from "crypto";
+import { execFileSync } from "child_process";
+var DEFAULT_INTERVAL_SECONDS = 300;
+function getHome() {
+  const home = process.env.HOME;
+  if (!home) throw new Error("HOME environment variable is not set");
+  return home;
+}
+function getLaunchAgentsDir() {
+  return path5.join(getHome(), "Library", "LaunchAgents");
+}
+function getAgentLabel() {
+  const thinkHome = process.env.THINK_HOME;
+  if (!thinkHome) return "ai.openthink.curate.default";
+  const hash = crypto2.createHash("sha1").update(thinkHome).digest("hex").slice(0, 8);
+  return `ai.openthink.curate.${hash}`;
+}
+function getPlistPath(label = getAgentLabel()) {
+  return path5.join(getLaunchAgentsDir(), `${label}.plist`);
+}
+function getLogPath() {
+  return path5.join(getThinkDir(), "auto-curate.log");
+}
+function resolveThinkBinary() {
+  const arg1 = process.argv[1];
+  if (arg1 && fs8.existsSync(arg1)) return arg1;
+  throw new Error("Could not resolve think binary path");
+}
+function resolveNodeBinary() {
+  return process.execPath;
+}
+function renderPlist(opts) {
+  const envBlock = opts.thinkHome ? `    <key>EnvironmentVariables</key>
+    <dict>
+      <key>THINK_HOME</key>
+      <string>${escapeXml(opts.thinkHome)}</string>
+    </dict>
+` : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${escapeXml(opts.label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+      <string>${escapeXml(opts.nodePath)}</string>
+      <string>${escapeXml(opts.thinkPath)}</string>
+      <string>curate</string>
+      <string>--if-idle</string>
+    </array>
+    <key>StartInterval</key>
+    <integer>${opts.intervalSeconds}</integer>
+    <key>RunAtLoad</key>
+    <false/>
+${envBlock}    <key>StandardOutPath</key>
+    <string>${escapeXml(opts.logPath)}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(opts.logPath)}</string>
+  </dict>
+</plist>
+`;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function installAgent(opts = {}) {
+  if (process.platform !== "darwin") {
+    throw new Error("auto-curate install currently supports macOS only. For Linux, run `think curate --if-idle` from cron or systemd.");
+  }
+  const label = getAgentLabel();
+  const plistPath = getPlistPath(label);
+  const agentsDir = getLaunchAgentsDir();
+  fs8.mkdirSync(agentsDir, { recursive: true });
+  fs8.mkdirSync(getThinkDir(), { recursive: true });
+  const plist = renderPlist({
+    label,
+    nodePath: resolveNodeBinary(),
+    thinkPath: resolveThinkBinary(),
+    thinkHome: process.env.THINK_HOME,
+    intervalSeconds: opts.intervalSeconds ?? DEFAULT_INTERVAL_SECONDS,
+    logPath: getLogPath()
+  });
+  fs8.writeFileSync(plistPath, plist, { mode: 420 });
+  try {
+    execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+  } catch {
+  }
+  execFileSync("launchctl", ["load", plistPath], { stdio: "ignore" });
+  return { label, plistPath };
+}
+function uninstallAgent() {
+  const plistPath = getPlistPath();
+  if (!fs8.existsSync(plistPath)) {
+    return { removed: false, plistPath };
+  }
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("launchctl", ["unload", plistPath], { stdio: "ignore" });
+    } catch {
+    }
+  }
+  fs8.unlinkSync(plistPath);
+  return { removed: true, plistPath };
+}
+function getAgentStatus() {
+  const label = getAgentLabel();
+  const plistPath = getPlistPath(label);
+  const installed = fs8.existsSync(plistPath);
+  let loaded = false;
+  let intervalSeconds = null;
+  if (installed && process.platform === "darwin") {
+    try {
+      const out = execFileSync("launchctl", ["list", label], { stdio: ["ignore", "pipe", "ignore"] }).toString();
+      loaded = out.trim().length > 0;
+    } catch {
+      loaded = false;
+    }
+    try {
+      const plist = fs8.readFileSync(plistPath, "utf-8");
+      const match = plist.match(/<key>StartInterval<\/key>\s*<integer>(\d+)<\/integer>/);
+      if (match) intervalSeconds = parseInt(match[1], 10);
+    } catch {
+    }
+  }
+  let lastRunAt = null;
+  const logPath = getLogPath();
+  if (fs8.existsSync(logPath)) {
+    try {
+      const stat = fs8.statSync(logPath);
+      lastRunAt = stat.mtime;
+    } catch {
+    }
+  }
+  return { installed, label, plistPath, loaded, lastRunAt, intervalSeconds };
+}
+
 // src/commands/cortex.ts
 function prompt2(question, defaultValue) {
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
@@ -1595,7 +1736,7 @@ cortexCommand.addCommand(new Command9("setup").description("Configure a sync bac
     const adapter = getSyncAdapter();
     if (adapter) {
       try {
-        const { ensureRepoCloned: ensureRepoCloned2 } = await import("./git-TG6OJFBT.js");
+        const { ensureRepoCloned: ensureRepoCloned2 } = await import("./git-CMDUX3KB.js");
         ensureRepoCloned2();
         console.log(chalk9.green("\u2713") + " Repo cloned");
       } catch (err) {
@@ -1636,8 +1777,8 @@ cortexCommand.addCommand(new Command9("list").description("Show all cortexes").a
   const config = getConfig();
   const engramsDir = getEngramsDir();
   const localCortexes = [];
-  if (fs8.existsSync(engramsDir)) {
-    for (const file of fs8.readdirSync(engramsDir)) {
+  if (fs9.existsSync(engramsDir)) {
+    for (const file of fs9.readdirSync(engramsDir)) {
       if (file.endsWith(".db") && !file.endsWith("-shm") && !file.endsWith("-wal")) {
         localCortexes.push(file.replace(".db", ""));
       }
@@ -1678,7 +1819,7 @@ cortexCommand.addCommand(new Command9("switch").argument("<name>", "Cortex name"
   }
   const engramsDir = getEngramsDir();
   const dbPath = `${engramsDir}/${name}.db`;
-  if (!fs8.existsSync(dbPath)) {
+  if (!fs9.existsSync(dbPath)) {
     const adapter = getSyncAdapter();
     if (adapter?.isAvailable()) {
       try {
@@ -1792,272 +1933,467 @@ cortexCommand.addCommand(new Command9("status").description("Show sync status fo
   }
   closeCortexDb(cortex);
 }));
+var autoCurateCommand = new Command9("auto-curate").description("Manage scheduled background curation (macOS LaunchAgent)");
+autoCurateCommand.addCommand(new Command9("enable").description("Install a LaunchAgent that runs `think curate --if-idle` every 5 minutes").option("--interval <seconds>", "Scheduler cadence in seconds (default 300)", (v) => parseInt(v, 10)).action((opts) => {
+  try {
+    const { label, plistPath } = installAgent({ intervalSeconds: opts.interval });
+    console.log(chalk9.green("\u2713") + ` Auto-curation enabled`);
+    console.log(chalk9.dim(`  Label: ${label}`));
+    console.log(chalk9.dim(`  Plist: ${plistPath}`));
+    if (process.env.THINK_HOME) {
+      console.log(chalk9.dim(`  THINK_HOME: ${process.env.THINK_HOME}`));
+    }
+  } catch (err) {
+    console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}));
+autoCurateCommand.addCommand(new Command9("disable").description("Remove the auto-curation LaunchAgent for this workspace").action(() => {
+  const { removed, plistPath } = uninstallAgent();
+  if (removed) {
+    console.log(chalk9.green("\u2713") + ` Auto-curation disabled (${plistPath})`);
+  } else {
+    console.log(chalk9.dim(`No auto-curation agent installed (${plistPath})`));
+  }
+}));
+autoCurateCommand.addCommand(new Command9("status").description("Show auto-curation scheduler status").action(() => {
+  const s = getAgentStatus();
+  console.log(`Label:     ${chalk9.cyan(s.label)}`);
+  console.log(`Installed: ${s.installed ? chalk9.green("yes") : chalk9.dim("no")}`);
+  console.log(`Loaded:    ${s.loaded ? chalk9.green("yes") : chalk9.dim("no")}`);
+  if (s.intervalSeconds) {
+    console.log(`Interval:  ${s.intervalSeconds}s`);
+  }
+  console.log(`Plist:     ${s.plistPath}`);
+  if (s.lastRunAt) {
+    console.log(`Last log:  ${s.lastRunAt.toISOString()}`);
+  } else {
+    console.log(`Last log:  ${chalk9.dim("(no log file yet)")}`);
+  }
+}));
+cortexCommand.addCommand(autoCurateCommand);
 
 // src/commands/curate.ts
 import { Command as Command10 } from "commander";
 import readline3 from "readline";
 import chalk10 from "chalk";
-var curateCommand = new Command10("curate").description("Run curation: evaluate pending engrams and promote to memories").option("--dry-run", "Preview what would be committed without saving").option("--consolidate", "Run long-term memory consolidation only (no curation)").option("--episode <key>", "Curate a specific episode into a narrative memory").action(async (opts) => {
+
+// src/lib/curate-lock.ts
+import fs10 from "fs";
+import path6 from "path";
+function getLockPath(cortex) {
+  return path6.join(getThinkDir(), `curate-${cortex}.lock`);
+}
+function isProcessAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+function acquireCurateLock(cortex) {
+  const lockPath = getLockPath(cortex);
+  fs10.mkdirSync(path6.dirname(lockPath), { recursive: true });
+  try {
+    fs10.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    return makeAcquired(lockPath);
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  let heldByPid = null;
+  try {
+    const raw = fs10.readFileSync(lockPath, "utf-8").trim();
+    const parsed = parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0) heldByPid = parsed;
+  } catch {
+  }
+  if (heldByPid && isProcessAlive(heldByPid)) {
+    return { acquired: false, heldByPid };
+  }
+  try {
+    fs10.unlinkSync(lockPath);
+  } catch {
+  }
+  try {
+    fs10.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    return makeAcquired(lockPath);
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      let nowHeldBy = null;
+      try {
+        const raw = fs10.readFileSync(lockPath, "utf-8").trim();
+        const parsed = parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed > 0) nowHeldBy = parsed;
+      } catch {
+      }
+      return { acquired: false, heldByPid: nowHeldBy };
+    }
+    throw err;
+  }
+}
+function makeAcquired(lockPath) {
+  let released = false;
+  const unlinkIfHeld = () => {
+    if (released) return;
+    released = true;
+    try {
+      fs10.unlinkSync(lockPath);
+    } catch {
+    }
+  };
+  const exitHandler = () => {
+    unlinkIfHeld();
+  };
+  const sigintHandler = () => {
+    unlinkIfHeld();
+    process.exit(130);
+  };
+  const sigtermHandler = () => {
+    unlinkIfHeld();
+    process.exit(143);
+  };
+  process.on("exit", exitHandler);
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  const release = () => {
+    if (released) {
+      process.removeListener("exit", exitHandler);
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+      return;
+    }
+    unlinkIfHeld();
+    process.removeListener("exit", exitHandler);
+    process.removeListener("SIGINT", sigintHandler);
+    process.removeListener("SIGTERM", sigtermHandler);
+  };
+  return { acquired: true, release };
+}
+
+// src/commands/curate.ts
+var curateCommand = new Command10("curate").description("Run curation: evaluate pending engrams and promote to memories").option("--dry-run", "Preview what would be committed without saving").option("--consolidate", "Run long-term memory consolidation only (no curation)").option("--episode <key>", "Curate a specific episode into a narrative memory").option("--if-idle", "Only curate if the user appears idle (used by auto-curation scheduler)").action(async (opts) => {
   const config = getConfig();
   const cortex = config.cortex?.active;
   if (!cortex) {
+    if (opts.ifIdle) {
+      return;
+    }
     console.error(chalk10.red("No active cortex. Run: think cortex switch <name>"));
     process.exit(1);
   }
   const author = config.cortex.author;
-  const adapter = getSyncAdapter();
-  if (adapter?.isAvailable()) {
-    try {
-      const pullResult = await adapter.pull(cortex);
-      if (pullResult.pulled > 0) {
-        console.log(chalk10.dim(`  Pulled ${pullResult.pulled} memories from ${adapter.name}`));
+  let releaseLock = () => {
+  };
+  if (!opts.dryRun) {
+    const lock = acquireCurateLock(cortex);
+    if (!lock.acquired) {
+      if (opts.ifIdle) {
+        if (process.env.THINK_IDLE_DEBUG) {
+          console.log(chalk10.dim(`[auto-curate] skipped: another curation is running (pid ${lock.heldByPid ?? "?"})`));
+        }
+      } else {
+        console.log(chalk10.yellow(`Another curation is already running (pid ${lock.heldByPid ?? "?"}). Skipping.`));
       }
-    } catch {
-      console.log(chalk10.dim("  Sync pull skipped (remote unavailable)"));
-    }
-  }
-  if (opts.episode) {
-    const episodeEngrams = getPendingEpisodeEngrams(cortex, opts.episode);
-    if (episodeEngrams.length === 0) {
-      console.log(chalk10.dim(`No pending engrams for episode: ${opts.episode}`));
       closeCortexDb(cortex);
       return;
     }
-    const existingMemoryRow = getMemoryByEpisodeKey(cortex, opts.episode);
-    const existingMemory = existingMemoryRow ? {
-      ts: existingMemoryRow.ts,
-      author: existingMemoryRow.author,
-      content: existingMemoryRow.content,
-      source_ids: JSON.parse(existingMemoryRow.source_ids)
-    } : null;
-    console.log(chalk10.cyan(`Curating episode: ${opts.episode} (${episodeEngrams.length} engrams${existingMemory ? ", updating existing narrative" : ""})...`));
-    const prompt3 = assembleEpisodeCurationPrompt({
-      episodeKey: opts.episode,
-      pendingEngrams: episodeEngrams,
-      existingMemory,
-      author
-    });
-    if (opts.dryRun) {
-      console.log();
-      console.log(chalk10.cyan("Episode prompt would be sent to LLM:"));
-      console.log(chalk10.dim(`  ${episodeEngrams.length} engrams, ${existingMemory ? "updating" : "creating"} narrative`));
-      for (const e of episodeEngrams) {
-        const ts = e.created_at.slice(0, 16).replace("T", " ");
-        console.log(chalk10.dim(`  ${ts}: ${e.content.slice(0, 100)}${e.content.length > 100 ? "..." : ""}`));
+    releaseLock = lock.release;
+  }
+  try {
+    if (opts.ifIdle && !opts.episode && !opts.consolidate) {
+      const shouldRun = shouldRunIdleCuration(cortex, config.cortex);
+      if (!shouldRun.run) {
+        if (process.env.THINK_IDLE_DEBUG) {
+          console.log(chalk10.dim(`[auto-curate] skipped: ${shouldRun.reason}`));
+        }
+        closeCortexDb(cortex);
+        return;
+      }
+      if (process.env.THINK_IDLE_DEBUG) {
+        console.log(chalk10.dim(`[auto-curate] running: ${shouldRun.reason}`));
       }
-      closeCortexDb(cortex);
-      return;
-    }
-    let narrative;
-    try {
-      narrative = await runEpisodeCuration(prompt3);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(chalk10.red(`Episode curation failed: ${message}`));
-      closeCortexDb(cortex);
-      process.exit(1);
-    }
-    if (existingMemoryRow) {
-      tombstoneMemory(cortex, existingMemoryRow.id);
     }
-    const allSourceIds = [
-      ...existingMemory?.source_ids ?? [],
-      ...episodeEngrams.map((e) => e.id)
-    ];
-    insertMemory(cortex, {
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      author,
-      content: narrative,
-      source_ids: allSourceIds,
-      episode_key: opts.episode
-    });
-    markPromoted(cortex, episodeEngrams.map((e) => e.id));
+    const adapter = getSyncAdapter();
     if (adapter?.isAvailable()) {
       try {
-        const pushResult = await adapter.push(cortex);
-        if (pushResult.pushed > 0) {
-          console.log(chalk10.dim(`  Pushed ${pushResult.pushed} memories to ${adapter.name}`));
+        const pullResult = await adapter.pull(cortex);
+        if (pullResult.pulled > 0) {
+          console.log(chalk10.dim(`  Pulled ${pullResult.pulled} memories from ${adapter.name}`));
         }
       } catch {
-        console.log(chalk10.dim("  Sync push skipped (remote unavailable)"));
+        console.log(chalk10.dim("  Sync pull skipped (remote unavailable)"));
       }
     }
-    console.log();
-    console.log(`${chalk10.green("\u2713")} Episode curated: ${opts.episode}`);
-    console.log(`  ${episodeEngrams.length} engrams synthesized into narrative`);
-    closeCortexDb(cortex);
-    return;
-  }
-  const allMemories = getMemories(cortex);
-  const memoryEntries = allMemories.map((m) => ({
-    ts: m.ts,
-    author: m.author,
-    content: m.content,
-    source_ids: JSON.parse(m.source_ids)
-  }));
-  const { recent, older } = filterRecentMemories(memoryEntries);
-  const longtermSummary = getLongtermSummary(cortex);
-  if (opts.consolidate) {
-    if (older.length === 0) {
-      console.log(chalk10.dim("No memories older than 2 weeks to consolidate."));
-      return;
-    }
-    console.log(chalk10.cyan(`Consolidating ${older.length} older memories into long-term summary...`));
-    try {
-      const newSummary = await runConsolidation(longtermSummary, older);
+    if (opts.episode) {
+      const episodeEngrams = getPendingEpisodeEngrams(cortex, opts.episode);
+      if (episodeEngrams.length === 0) {
+        console.log(chalk10.dim(`No pending engrams for episode: ${opts.episode}`));
+        closeCortexDb(cortex);
+        return;
+      }
+      const existingMemoryRow = getMemoryByEpisodeKey(cortex, opts.episode);
+      const existingMemory = existingMemoryRow ? {
+        ts: existingMemoryRow.ts,
+        author: existingMemoryRow.author,
+        content: existingMemoryRow.content,
+        source_ids: JSON.parse(existingMemoryRow.source_ids)
+      } : null;
+      console.log(chalk10.cyan(`Curating episode: ${opts.episode} (${episodeEngrams.length} engrams${existingMemory ? ", updating existing narrative" : ""})...`));
+      const prompt3 = assembleEpisodeCurationPrompt({
+        episodeKey: opts.episode,
+        pendingEngrams: episodeEngrams,
+        existingMemory,
+        author
+      });
       if (opts.dryRun) {
         console.log();
-        console.log(chalk10.cyan("Proposed long-term summary:"));
-        console.log(newSummary);
+        console.log(chalk10.cyan("Episode prompt would be sent to LLM:"));
+        console.log(chalk10.dim(`  ${episodeEngrams.length} engrams, ${existingMemory ? "updating" : "creating"} narrative`));
+        for (const e of episodeEngrams) {
+          const ts = e.created_at.slice(0, 16).replace("T", " ");
+          console.log(chalk10.dim(`  ${ts}: ${e.content.slice(0, 100)}${e.content.length > 100 ? "..." : ""}`));
+        }
+        closeCortexDb(cortex);
+        return;
+      }
+      let narrative;
+      try {
+        narrative = await runEpisodeCuration(prompt3);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk10.red(`Episode curation failed: ${message}`));
+        closeCortexDb(cortex);
+        process.exit(1);
+      }
+      if (existingMemoryRow) {
+        tombstoneMemory(cortex, existingMemoryRow.id);
+      }
+      const allSourceIds = [
+        ...existingMemory?.source_ids ?? [],
+        ...episodeEngrams.map((e) => e.id)
+      ];
+      insertMemory(cortex, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        author,
+        content: narrative,
+        source_ids: allSourceIds,
+        episode_key: opts.episode
+      });
+      markPromoted(cortex, episodeEngrams.map((e) => e.id));
+      if (adapter?.isAvailable()) {
+        try {
+          const pushResult = await adapter.push(cortex);
+          if (pushResult.pushed > 0) {
+            console.log(chalk10.dim(`  Pushed ${pushResult.pushed} memories to ${adapter.name}`));
+          }
+        } catch {
+          console.log(chalk10.dim("  Sync push skipped (remote unavailable)"));
+        }
+      }
+      console.log();
+      console.log(`${chalk10.green("\u2713")} Episode curated: ${opts.episode}`);
+      console.log(`  ${episodeEngrams.length} engrams synthesized into narrative`);
+      closeCortexDb(cortex);
+      return;
+    }
+    const allMemories = getMemories(cortex);
+    const memoryEntries = allMemories.map((m) => ({
+      ts: m.ts,
+      author: m.author,
+      content: m.content,
+      source_ids: JSON.parse(m.source_ids)
+    }));
+    const { recent, older } = filterRecentMemories(memoryEntries);
+    const longtermSummary = getLongtermSummary(cortex);
+    if (opts.consolidate) {
+      if (older.length === 0) {
+        console.log(chalk10.dim("No memories older than 2 weeks to consolidate."));
         return;
       }
-      setLongtermSummary(cortex, newSummary);
-      console.log(chalk10.green("\u2713") + ` Long-term summary updated (${older.length} memories consolidated)`);
+      console.log(chalk10.cyan(`Consolidating ${older.length} older memories into long-term summary...`));
+      try {
+        const newSummary = await runConsolidation(longtermSummary, older);
+        if (opts.dryRun) {
+          console.log();
+          console.log(chalk10.cyan("Proposed long-term summary:"));
+          console.log(newSummary);
+          return;
+        }
+        setLongtermSummary(cortex, newSummary);
+        console.log(chalk10.green("\u2713") + ` Long-term summary updated (${older.length} memories consolidated)`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk10.red(`Consolidation failed: ${message}`));
+        process.exit(1);
+      }
+      return;
+    }
+    const pending = getPendingEngrams(cortex);
+    if (pending.length === 0) {
+      console.log(chalk10.dim("No pending engrams to evaluate."));
+      closeCortexDb(cortex);
+      return;
+    }
+    console.log(chalk10.cyan(`Evaluating ${pending.length} engrams (${recent.length} recent memories, long-term summary ${longtermSummary ? "loaded" : "absent"})...`));
+    const curatorMd = readCuratorMd();
+    const curationPrompt = assembleCurationPrompt({
+      recentMemories: recent,
+      longtermSummary,
+      curatorMd,
+      pendingEngrams: pending,
+      author,
+      selectivity: config.cortex?.selectivity,
+      granularity: config.cortex?.granularity,
+      maxMemoriesPerRun: config.cortex?.maxMemoriesPerRun
+    });
+    let curationResult;
+    try {
+      curationResult = await runCuration(curationPrompt);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(chalk10.red(`Consolidation failed: ${message}`));
+      console.error(chalk10.red(`Curation failed: ${message}`));
+      closeCortexDb(cortex);
       process.exit(1);
     }
-    return;
-  }
-  const pending = getPendingEngrams(cortex);
-  if (pending.length === 0) {
-    console.log(chalk10.dim("No pending engrams to evaluate."));
-    closeCortexDb(cortex);
-    return;
-  }
-  console.log(chalk10.cyan(`Evaluating ${pending.length} engrams (${recent.length} recent memories, long-term summary ${longtermSummary ? "loaded" : "absent"})...`));
-  const curatorMd = readCuratorMd();
-  const curationPrompt = assembleCurationPrompt({
-    recentMemories: recent,
-    longtermSummary,
-    curatorMd,
-    pendingEngrams: pending,
-    author,
-    selectivity: config.cortex?.selectivity,
-    granularity: config.cortex?.granularity,
-    maxMemoriesPerRun: config.cortex?.maxMemoriesPerRun
-  });
-  let curationResult;
-  try {
-    curationResult = await runCuration(curationPrompt);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk10.red(`Curation failed: ${message}`));
-    closeCortexDb(cortex);
-    process.exit(1);
-  }
-  const newEntries = curationResult.memories;
-  for (const entry of newEntries) {
-    entry.author = author;
-    if (!entry.ts) entry.ts = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  const promotedIds = /* @__PURE__ */ new Set();
-  for (const entry of newEntries) {
-    for (const id of entry.source_ids) {
-      promotedIds.add(id);
+    const newEntries = curationResult.memories;
+    for (const entry of newEntries) {
+      entry.author = author;
+      if (!entry.ts) entry.ts = (/* @__PURE__ */ new Date()).toISOString();
     }
-  }
-  const pendingIdSet = new Set(pending.map((e) => e.id));
-  const purgedIds = curationResult.purgeIds.filter((id) => pendingIdSet.has(id) && !promotedIds.has(id));
-  const heldCount = pending.length - promotedIds.size - purgedIds.length;
-  if (opts.dryRun) {
-    console.log();
-    if (newEntries.length === 0) {
-      console.log(chalk10.dim("Curator would produce no new memories."));
-    } else {
-      console.log(chalk10.cyan("Would append:"));
-      for (const entry of newEntries) {
-        console.log(chalk10.green(`  + `) + `[${entry.ts}] ${entry.content}`);
+    const promotedIds = /* @__PURE__ */ new Set();
+    for (const entry of newEntries) {
+      for (const id of entry.source_ids) {
+        promotedIds.add(id);
       }
     }
-    console.log();
-    console.log(`${pending.length} evaluated, ${newEntries.length} would promote, ${purgedIds.length} would purge, ${heldCount} would stay pending`);
-    closeCortexDb(cortex);
-    return;
-  }
-  if (config.cortex?.confirmBeforeCommit && newEntries.length > 0) {
-    console.log();
-    console.log(chalk10.cyan("Proposed memories:"));
-    for (let i = 0; i < newEntries.length; i++) {
-      console.log(chalk10.green(`  ${i + 1}. `) + newEntries[i].content);
-    }
-    console.log();
-    const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise((resolve) => {
-      rl.question("  Save these memories? [Y/n/edit] ", (ans) => {
-        rl.close();
-        resolve(ans.trim().toLowerCase());
-      });
-    });
-    if (answer === "n" || answer === "no") {
-      console.log(chalk10.dim("  Aborted. Engrams left as pending."));
+    const pendingIdSet = new Set(pending.map((e) => e.id));
+    const purgedIds = curationResult.purgeIds.filter((id) => pendingIdSet.has(id) && !promotedIds.has(id));
+    const heldCount = pending.length - promotedIds.size - purgedIds.length;
+    if (opts.dryRun) {
+      console.log();
+      if (newEntries.length === 0) {
+        console.log(chalk10.dim("Curator would produce no new memories."));
+      } else {
+        console.log(chalk10.cyan("Would append:"));
+        for (const entry of newEntries) {
+          console.log(chalk10.green(`  + `) + `[${entry.ts}] ${entry.content}`);
+        }
+      }
+      console.log();
+      console.log(`${pending.length} evaluated, ${newEntries.length} would promote, ${purgedIds.length} would purge, ${heldCount} would stay pending`);
       closeCortexDb(cortex);
       return;
     }
-    if (answer === "e" || answer === "edit") {
+    if (config.cortex?.confirmBeforeCommit && newEntries.length > 0) {
+      console.log();
+      console.log(chalk10.cyan("Proposed memories:"));
       for (let i = 0; i < newEntries.length; i++) {
-        const editRl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-        const edited = await new Promise((resolve) => {
-          editRl.question(`  ${i + 1}. ${chalk10.dim("(enter to keep, or type replacement)")}
+        console.log(chalk10.green(`  ${i + 1}. `) + newEntries[i].content);
+      }
+      console.log();
+      const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question("  Save these memories? [Y/n/edit] ", (ans) => {
+          rl.close();
+          resolve(ans.trim().toLowerCase());
+        });
+      });
+      if (answer === "n" || answer === "no") {
+        console.log(chalk10.dim("  Aborted. Engrams left as pending."));
+        closeCortexDb(cortex);
+        return;
+      }
+      if (answer === "e" || answer === "edit") {
+        for (let i = 0; i < newEntries.length; i++) {
+          const editRl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+          const edited = await new Promise((resolve) => {
+            editRl.question(`  ${i + 1}. ${chalk10.dim("(enter to keep, or type replacement)")}
      ${newEntries[i].content}
      > `, (ans) => {
-            editRl.close();
-            resolve(ans.trim());
+              editRl.close();
+              resolve(ans.trim());
+            });
           });
-        });
-        if (edited) {
-          newEntries[i].content = edited;
+          if (edited) {
+            newEntries[i].content = edited;
+          }
         }
       }
     }
-  }
-  if (newEntries.length > 0) {
-    for (const entry of newEntries) {
-      insertMemory(cortex, {
-        ts: entry.ts,
-        author: entry.author,
-        content: entry.content,
-        source_ids: entry.source_ids,
-        decisions: entry.decisions
-      });
+    if (newEntries.length > 0) {
+      for (const entry of newEntries) {
+        insertMemory(cortex, {
+          ts: entry.ts,
+          author: entry.author,
+          content: entry.content,
+          source_ids: entry.source_ids,
+          decisions: entry.decisions
+        });
+      }
     }
-  }
-  if (promotedIds.size > 0) {
-    markPromoted(cortex, [...promotedIds]);
-  }
-  if (purgedIds.length > 0) {
-    markPurged(cortex, purgedIds);
-  }
-  const pruned = pruneExpiredEngrams(cortex);
-  if (older.length > 0 && !longtermSummary) {
-    console.log(chalk10.dim(`  Consolidating ${older.length} older memories into long-term summary...`));
-    try {
-      const newSummary = await runConsolidation(null, older);
-      setLongtermSummary(cortex, newSummary);
-      console.log(chalk10.dim(`  Long-term summary created`));
-    } catch {
-      console.log(chalk10.dim(`  Long-term consolidation skipped (will retry next run)`));
+    if (promotedIds.size > 0) {
+      markPromoted(cortex, [...promotedIds]);
     }
-  }
-  if (adapter?.isAvailable() && newEntries.length > 0) {
-    try {
-      const pushResult = await adapter.push(cortex);
-      if (pushResult.pushed > 0) {
-        console.log(chalk10.dim(`  Pushed ${pushResult.pushed} memories to ${adapter.name}`));
+    if (purgedIds.length > 0) {
+      markPurged(cortex, purgedIds);
+    }
+    const pruned = pruneExpiredEngrams(cortex);
+    if (older.length > 0 && !longtermSummary) {
+      console.log(chalk10.dim(`  Consolidating ${older.length} older memories into long-term summary...`));
+      try {
+        const newSummary = await runConsolidation(null, older);
+        setLongtermSummary(cortex, newSummary);
+        console.log(chalk10.dim(`  Long-term summary created`));
+      } catch {
+        console.log(chalk10.dim(`  Long-term consolidation skipped (will retry next run)`));
       }
-    } catch {
-      console.log(chalk10.dim("  Sync push skipped (remote unavailable) \u2014 will push on next sync"));
     }
+    if (adapter?.isAvailable() && newEntries.length > 0) {
+      try {
+        const pushResult = await adapter.push(cortex);
+        if (pushResult.pushed > 0) {
+          console.log(chalk10.dim(`  Pushed ${pushResult.pushed} memories to ${adapter.name}`));
+        }
+      } catch {
+        console.log(chalk10.dim("  Sync push skipped (remote unavailable) \u2014 will push on next sync"));
+      }
+    }
+    console.log();
+    console.log(`${chalk10.green("\u2713")} Curation complete`);
+    console.log(`  ${pending.length} evaluated, ${newEntries.length} promoted, ${purgedIds.length} purged, ${heldCount} still pending`);
+    if (pruned > 0) {
+      console.log(`  ${pruned} expired engrams pruned`);
+    }
+    closeCortexDb(cortex);
+  } finally {
+    releaseLock();
   }
-  console.log();
-  console.log(`${chalk10.green("\u2713")} Curation complete`);
-  console.log(`  ${pending.length} evaluated, ${newEntries.length} promoted, ${purgedIds.length} purged, ${heldCount} still pending`);
-  if (pruned > 0) {
-    console.log(`  ${pruned} expired engrams pruned`);
-  }
-  closeCortexDb(cortex);
 });
+var DEFAULT_IDLE_WINDOW_MINUTES = 3;
+var DEFAULT_STALE_WINDOW_MINUTES = 60;
+function shouldRunIdleCuration(cortex, cortexConfig) {
+  const pending = getPendingEngrams(cortex);
+  if (pending.length === 0) {
+    return { run: false, reason: "no pending engrams" };
+  }
+  const idleMinutes = cortexConfig?.idleWindowMinutes ?? DEFAULT_IDLE_WINDOW_MINUTES;
+  const staleMinutes = cortexConfig?.staleWindowMinutes ?? DEFAULT_STALE_WINDOW_MINUTES;
+  const now = Date.now();
+  const oldest = pending[0];
+  const newest = pending[pending.length - 1];
+  const oldestAgeMin = (now - new Date(oldest.created_at).getTime()) / 6e4;
+  const newestAgeMin = (now - new Date(newest.created_at).getTime()) / 6e4;
+  if (oldestAgeMin >= staleMinutes) {
+    return { run: true, reason: `staleness cap hit (oldest pending ${oldestAgeMin.toFixed(1)}min old)` };
+  }
+  if (newestAgeMin < idleMinutes) {
+    return { run: false, reason: `still active (newest engram ${newestAgeMin.toFixed(1)}min old, idle threshold ${idleMinutes}min)` };
+  }
+  return { run: true, reason: `idle (${pending.length} pending, newest ${newestAgeMin.toFixed(1)}min old)` };
+}
 
 // src/commands/monitor.ts
 import { Command as Command11 } from "commander";
@@ -2122,7 +2458,7 @@ var recallCommand = new Command12("recall").argument("<query>", "What to recall"
   }
   const limit = parseInt(opts.limit, 10);
   if (opts.all) {
-    const { getMemories: getMemories2 } = await import("./memory-queries-N4VT5G2E.js");
+    const { getMemories: getMemories2 } = await import("./memory-queries-QKGOKRFR.js");
     const days = parseInt(opts.days, 10);
     const cutoff = new Date(Date.now() - days * 864e5).toISOString();
     const recentMemories = getMemories2(cortex, { since: cutoff });
@@ -2278,7 +2614,7 @@ memoryCommand.addCommand(addCommand);
 // src/commands/curator-cmd.ts
 import { Command as Command14 } from "commander";
 import { spawnSync } from "child_process";
-import fs9 from "fs";
+import fs11 from "fs";
 import chalk14 from "chalk";
 var CURATOR_TEMPLATE = `# Curator Guidance
 
@@ -2297,8 +2633,8 @@ var curatorCommand = new Command14("curator").description("Manage personal curat
 curatorCommand.addCommand(new Command14("edit").description("Edit your curator guidance in $EDITOR").action(() => {
   ensureThinkDirs();
   const mdPath = getCuratorMdPath();
-  if (!fs9.existsSync(mdPath)) {
-    fs9.writeFileSync(mdPath, CURATOR_TEMPLATE, "utf-8");
+  if (!fs11.existsSync(mdPath)) {
+    fs11.writeFileSync(mdPath, CURATOR_TEMPLATE, "utf-8");
   }
   const editor = process.env.EDITOR || "vi";
   const result = spawnSync(editor, [mdPath], { stdio: "inherit" });
@@ -2310,8 +2646,8 @@ curatorCommand.addCommand(new Command14("edit").description("Edit your curator g
 }));
 curatorCommand.addCommand(new Command14("show").description("Print your current curator guidance").action(() => {
   const mdPath = getCuratorMdPath();
-  if (fs9.existsSync(mdPath)) {
-    console.log(fs9.readFileSync(mdPath, "utf-8"));
+  if (fs11.existsSync(mdPath)) {
+    console.log(fs11.readFileSync(mdPath, "utf-8"));
   } else {
     console.log(chalk14.dim("No curator guidance configured. Run: think curator edit"));
   }
@@ -2375,6 +2711,8 @@ var ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "cortex.repo",
   "cortex.active",
   "cortex.engramTTLDays",
+  "cortex.idleWindowMinutes",
+  "cortex.staleWindowMinutes",
   "paused"
 ]);
 var configCommand = new Command17("config").description("View or update think configuration");
@@ -2408,12 +2746,12 @@ configCommand.addCommand(new Command17("set").argument("<key>", "Config key (e.g
 
 // src/commands/update.ts
 import { Command as Command18 } from "commander";
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import chalk18 from "chalk";
 var updateCommand = new Command18("update").description("Update think to the latest version").action(() => {
   console.log(chalk18.cyan("Checking for updates..."));
   try {
-    const result = execFileSync("npm", ["install", "-g", "open-think@latest"], {
+    const result = execFileSync2("npm", ["install", "-g", "open-think@latest"], {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -2431,7 +2769,7 @@ var updateCommand = new Command18("update").description("Update think to the lat
 
 // src/commands/migrate-data.ts
 import { Command as Command19 } from "commander";
-import fs10 from "fs";
+import fs12 from "fs";
 import chalk19 from "chalk";
 var migrateDataCommand = new Command19("migrate-data").description("Import existing memories from git into local SQLite (one-time migration)").action(async () => {
   const config = getConfig();
@@ -2469,8 +2807,8 @@ var migrateDataCommand = new Command19("migrate-data").description("Import exist
     if (wasInserted) inserted++;
   }
   const ltPath = getLongtermPath(cortex);
-  if (fs10.existsSync(ltPath)) {
-    const ltContent = fs10.readFileSync(ltPath, "utf-8").trim();
+  if (fs12.existsSync(ltPath)) {
+    const ltContent = fs12.readFileSync(ltPath, "utf-8").trim();
     if (ltContent) {
       setLongtermSummary(cortex, ltContent);
       console.log(chalk19.green("  \u2713") + " Long-term summary migrated");
@@ -2489,8 +2827,8 @@ var migrateDataCommand = new Command19("migrate-data").description("Import exist
 // src/index.ts
 function readPackageVersion() {
   try {
-    const pkgPath = path5.join(import.meta.dirname, "..", "package.json");
-    return JSON.parse(fs11.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0";
+    const pkgPath = path7.join(import.meta.dirname, "..", "package.json");
+    return JSON.parse(fs13.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }

package/dist/{memory-queries-N4VT5G2E.js → memory-queries-QKGOKRFR.js}

@@ -12,8 +12,8 @@ import {
   setLongtermSummary,
   setSyncCursor,
   tombstoneMemory
-} from "./chunk-OFGWR45G.js";
-import "./chunk-DCTG6IK4.js";
+} from "./chunk-LN2TIS5R.js";
+import "./chunk-HUBRLTY3.js";
 export {
   getLongtermSummary,
   getMemories,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-think",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "description": "Local-first CLI that gives AI agents persistent, curated memory",
   "bin": {