@stitchdb/cli 0.7.1 → 0.7.3

package/dist/cli.js

@@ -495,7 +495,18 @@ async function cmdHook(args) {
         await handlePostReadHook(cfg, event, cwd || process.cwd()).catch(() => { });
         return;
     }
-    // ── SessionStart: inject prior context (token-efficient) ─────────────
+    // ── SessionStart: self-heal hook config + inject prior context ─────────
+    // Self-heal: a CLI upgrade often introduces new hooks (e.g. PreToolUse on
+    // Read in 0.7.0). Without re-running `stitch install`, the old settings.json
+    // would silently miss them. Each SessionStart we (re)wire any missing
+    // 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.
     if (eventName === 'SessionStart') {
@@ -957,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 = 30 * 60 * 1000; // don't distill more than once per 30 min
-const DISTILL_MIN_NEW_TURNS = 10; // need 10 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'));
@@ -1196,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;
@@ -1214,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();
     }
@@ -1676,6 +1705,46 @@ function mergeHook(existing, entry) {
     filtered.push(entry);
     return filtered;
 }
+/**
+ * Idempotent re-wiring of every Stitch hook into ~/.claude/settings.json.
+ * Called on every SessionStart so a CLI upgrade auto-installs any new hooks
+ * (e.g. PreToolUse:Read added in 0.7.0) without the user re-running
+ * `stitch install`. Never touches non-Stitch hook entries.
+ */
+function ensureHooksUpToDate() {
+    try {
+        const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+        if (!fs.existsSync(path.dirname(settingsPath)))
+            return;
+        let existing = {};
+        try {
+            existing = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        }
+        catch { /* corrupt — skip */
+            return;
+        }
+        existing.hooks = existing.hooks || {};
+        const expected = [
+            ['SessionStart', STITCH_SESSION_START_HOOK],
+            ['UserPromptSubmit', STITCH_USER_HOOK],
+            ['Stop', STITCH_STOP_HOOK],
+            ['PreToolUse', STITCH_PRE_READ_HOOK],
+            ['PostToolUse', STITCH_POST_READ_HOOK],
+        ];
+        let changed = false;
+        for (const [key, entry] of expected) {
+            const next = mergeHook(existing.hooks[key], entry);
+            if (JSON.stringify(next) !== JSON.stringify(existing.hooks[key])) {
+                existing.hooks[key] = next;
+                changed = true;
+            }
+        }
+        if (changed) {
+            fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+        }
+    }
+    catch { /* never break a session start */ }
+}
 const STITCH_CLAUDE_MD_BLOCK = `<!-- stitch:auto -->
 ## Stitch memory
 

package/package.json

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