@stitchdb/cli 0.10.1 → 0.11.0

package/dist/cli.js

@@ -761,19 +761,97 @@ async function cmdHook(args) {
     content = content.trim();
     if (!content)
         return;
+    // For UserPromptSubmit: log the turn AND fetch task-relevant memory in
+    // parallel, so the model sees only what's actually relevant to *this*
+    // prompt — not 8 random preloaded memories from session start. Task
+    // changes self-surface because the recall hits change with the prompt.
+    if (eventName === 'UserPromptSubmit') {
+        await Promise.all([
+            (async () => {
+                try {
+                    const stitch = client(cfg);
+                    await stitch.thread(threadName).append({ role: role, content });
+                }
+                catch { /* silent */ }
+            })(),
+            handleUserPromptInjection(cfg, content),
+        ]);
+        return;
+    }
+    // Stop: log the assistant turn, then maybe-distill.
     try {
         const stitch = client(cfg);
-        await stitch.thread(threadName).append({ role, content });
+        await stitch.thread(threadName).append({ role: role, content });
     }
-    catch {
-        /* silent */
-    }
-    // After Stop, opportunistically kick off a distillation pass in the
-    // background (fire-and-forget). Won't block the session; debouncing
-    // (cooldown + min-new-turns) is enforced inside maybeAutoDistill.
-    if (eventName === 'Stop') {
-        maybeAutoDistill(threadName).catch(() => { });
+    catch { /* silent */ }
+    maybeAutoDistill(threadName).catch(() => { });
+}
+/**
+ * Per-prompt smart context injection. Runs `recall(prompt)` against the
+ * project workspace + the user's `_global` workspace, score-gates the hits,
+ * and writes a Claude-Code-flavoured `additionalContext` JSON object to
+ * stdout. Time-bounded so a slow proxy doesn't delay the user's prompt.
+ *
+ * Why per-prompt: a static SessionStart block must guess what'll matter
+ * across the whole session. A per-prompt recall sees the actual question
+ * and pulls memory tailored to *that* — much higher signal per token.
+ * A task switch ("now let's do the dashboard") naturally surfaces the
+ * dashboard memories; an unrelated follow-up ("ok run the tests") returns
+ * low scores and we inject nothing — no noise.
+ */
+const PROMPT_INJECTION_TIMEOUT_MS = 2000;
+const PROMPT_INJECTION_MIN_SCORE = 0.4;
+async function handleUserPromptInjection(cfg, prompt) {
+    if (!prompt || prompt.length < 10)
+        return;
+    try {
+        const baseUrl = cfg.baseUrl || 'https://db.stitchdb.com';
+        const stitch = client(cfg);
+        const tOut = new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), PROMPT_INJECTION_TIMEOUT_MS));
+        // Project recall + global recall in parallel; tolerate either failing.
+        const projectHitsP = stitch.recall(prompt, { k: 3 }).catch(() => []);
+        const globalHitsP = (async () => {
+            try {
+                const ws = await stitch.workspaces.list();
+                const g = ws.find((w) => w.name === '_global');
+                if (!g)
+                    return [];
+                const gc = new Stitch({ apiKey: cfg.apiKey, baseUrl, workspace: g.id });
+                return gc.recall(prompt, { k: 2 }).catch(() => []);
+            }
+            catch {
+                return [];
+            }
+        })();
+        const [projectHits, globalHits] = await Promise.race([
+            Promise.all([projectHitsP, globalHitsP]),
+            tOut,
+        ]);
+        const project = projectHits.filter((h) => h.score >= PROMPT_INJECTION_MIN_SCORE).slice(0, 2);
+        const global = globalHits.filter((h) => h.score >= PROMPT_INJECTION_MIN_SCORE).slice(0, 1);
+        if (project.length === 0 && global.length === 0)
+            return;
+        const lines = ['<stitch-recall>'];
+        if (global.length > 0) {
+            lines.push('User-level rules relevant here:');
+            for (const h of global) {
+                const txt = String(h.content || '').replace(/\n+/g, ' ').slice(0, 250);
+                lines.push(`- [${h.kind}] ${txt}`);
+            }
+        }
+        if (project.length > 0) {
+            lines.push('Project memory relevant to this prompt:');
+            for (const h of project) {
+                const txt = String(h.content || '').replace(/\n+/g, ' ').slice(0, 300);
+                const src = h.source_thread_id ? ' _(thread receipt available — call thread_recall to dig)_' : '';
+                lines.push(`- [${h.kind}] (score ${Number(h.score).toFixed(2)}) ${txt}${src}`);
+            }
+        }
+        lines.push('</stitch-recall>');
+        const payload = { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: lines.join('\n') } };
+        process.stdout.write(JSON.stringify(payload));
     }
+    catch { /* silent — never break a prompt */ }
 }
 /**
  * Derive a thread name for the project at `cwd`. Strategy:

package/package.json

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