@stitchdb/cli 0.7.2 → 0.7.3

package/dist/cli.js

@@ -502,6 +502,10 @@ async function cmdHook(args) {
     // Stitch hook entries — never touching non-Stitch ones.
     if (eventName === 'SessionStart') {
         ensureHooksUpToDate();
+        // Catch-up distillation: if a previous session ended with undistilled
+        // turns (user exited under threshold), distill them now in the
+        // background so they surface in this session's context very soon.
+        maybeAutoDistill(threadName, { force: true }).catch(() => { });
     }
     // Strategy: prefer distilled memories (dense facts) over raw turns. Only
     // include raw turns for the last 5 to give the agent immediate continuation.
@@ -964,9 +968,13 @@ async function cmdLink(args) {
 // Triggered manually (`stitch distill`), and automatically by the Stop hook
 // when conditions are met (cooldown + new-turn threshold).
 const DISTILL_STATE_FILE = path.join(CONFIG_DIR, 'distill-state.json');
-const DISTILL_COOLDOWN_MS = 10 * 60 * 1000; // distill at most once per 10 min per thread
-const DISTILL_MIN_NEW_TURNS = 5; // need 5 new turns before bothering
+// No time-based cooldown — purely turn-count driven. The previous time gate
+// could leave turns undistilled if the user exited Claude before the next
+// firing window. Now: every Stop checks the pending-turn count, and if the
+// user exits below threshold, the next SessionStart catches up.
+const DISTILL_MIN_NEW_TURNS = 5; // distill once 5+ new turns are pending
 const DISTILL_BATCH_SIZE = 30; // turns per distillation pass
+const DISTILL_DEBOUNCE_MS = 90 * 1000; // small in-flight guard so a flurry of Stops doesn't fire N spawns
 function loadDistillState() {
     try {
         return JSON.parse(fs.readFileSync(DISTILL_STATE_FILE, 'utf8'));
@@ -1203,14 +1211,24 @@ async function distillClear(args) {
     }
     console.log(`Cleared ${deleted} memories.`);
 }
-// Triggered from the Stop hook (fire-and-forget, never blocks the user).
-async function maybeAutoDistill(thread) {
+// Triggered from Stop hook AND SessionStart catch-up. Fire-and-forget.
+//
+// Decision logic:
+//   - If `pending = currentTurns - lastDistilledTurns` >= DISTILL_MIN_NEW_TURNS,
+//     spawn a distill pass. No time-based cooldown — leaving turns undistilled
+//     because the user happened to exit before the next firing window is the
+//     wrong behaviour.
+//   - SessionStart calls this with `force = true` when ANY pending turns exist
+//     so a session that ended mid-batch (e.g. 3 pending) still gets caught up.
+//   - DISTILL_DEBOUNCE_MS is a tiny in-process guard so a flurry of Stop
+//     events from a single agent run doesn't trigger N parallel claude -p
+//     spawns; once one is in flight, others within the window become no-ops.
+async function maybeAutoDistill(thread, opts = {}) {
     const state = loadDistillState();
     const meta = state.threads[thread] || { lastDistilledAt: 0, lastTurnAt: 0, lastTurnCount: 0 };
-    // Cool-down: don't distill more than once per 30 min per thread.
-    if (Date.now() - meta.lastDistilledAt < DISTILL_COOLDOWN_MS)
+    // In-flight debounce: if we just spawned one, skip.
+    if (Date.now() - meta.lastDistilledAt < DISTILL_DEBOUNCE_MS)
         return;
-    // Need at least N new turns since last pass.
     const cfg = loadConfig();
     const stitch = client(cfg);
     let recallSize = 0;
@@ -1221,17 +1239,21 @@ async function maybeAutoDistill(thread) {
     catch {
         return;
     }
-    if (recallSize - meta.lastTurnCount < DISTILL_MIN_NEW_TURNS)
+    const pending = recallSize - meta.lastTurnCount;
+    // Default path: only distill once enough turns have piled up.
+    // SessionStart catch-up: distill if there's ANY pending turn.
+    const threshold = opts.force ? 1 : DISTILL_MIN_NEW_TURNS;
+    if (pending < threshold)
         return;
     // Mark BEFORE running so we don't double-fire on overlapping Stop events.
     state.threads[thread] = { lastDistilledAt: Date.now(), lastTurnAt: Date.now(), lastTurnCount: recallSize };
     saveDistillState(state);
-    // Detach: spawn a background process so the Stop hook returns immediately.
-    // The detached child runs `stitch distill` for this thread.
+    // Detach: spawn a background process so the hook returns immediately.
     try {
         const child = spawn(process.argv[0], [process.argv[1] || (await import('node:url')).fileURLToPath(import.meta.url), 'distill', '--thread', thread, '--n', String(DISTILL_BATCH_SIZE)], {
             detached: true,
             stdio: 'ignore',
+            env: { ...process.env, STITCH_HOOKS_DISABLED: '1' },
         });
         child.unref();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stitchdb/cli",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {