@stitchdb/cli 0.9.0 → 0.10.1

package/dist/cli.js

@@ -629,13 +629,28 @@ async function cmdHook(args) {
             const stitch = client(cfg);
             const projectTag = (threadName.split('/')[0] || threadName).toLowerCase();
             const baseUrl = cfg.baseUrl || 'https://db.stitchdb.com';
-            const [thread, memHits, workspaces, fileSummaries, aboutMems] = await Promise.all([
+            // Adaptive sizing — scale what we inject by how much the project
+            // actually has. A 5k-memory pool surfacing 8 random memories is
+            // noise; better to inject 0 and tell Claude to `recall` on demand.
+            const [thread, allProjectMems, workspaces, fileSummaries, aboutMems] = await Promise.all([
                 stitch.thread(threadName).recall({ last: 5 }).catch(() => ({ thread_id: '', recent: [], semantic: [] })),
-                stitch.recall(projectTag, { k: 8 }).catch(() => []),
+                stitch.list({ limit: 1 }).catch(() => []), // probe the pool size cheaply
                 stitch.workspaces.list().catch(() => []),
                 stitch.list({ limit: 12 }).then((all) => all.filter((m) => m.tags.some((t) => t.startsWith('file:')))).catch(() => []),
                 stitch.list({ tag: 'workspace:about', limit: 1 }).catch(() => []),
             ]);
+            // Estimate the workspace's total memory count from a single page
+            // header. We just need to know "small / medium / huge" — exact
+            // count is overkill. (D1 doesn't expose count in list — approximate
+            // by listing 200 once and capping.)
+            const sample = await stitch.list({ limit: 200 }).catch(() => []);
+            const poolSize = Array.isArray(sample) ? sample.length : 0;
+            // Tier the injection: tiny / small / medium / huge.
+            const memSliceK = poolSize <= 50 ? 8 : poolSize < 500 ? 8 : 0;
+            const turnSliceK = (thread.recent?.length ?? 0) < 5 ? 5 : (thread.recent?.length ?? 0) < 100 ? 5 : 2;
+            const memHits = memSliceK > 0
+                ? await stitch.recall(projectTag, { k: memSliceK }).catch(() => [])
+                : [];
             // Look up the current workspace using the client's resolved id; fall
             // back to first if resolveWorkspace failed (shouldn't normally).
             const currentWsId = await stitch.resolveWorkspace().catch(() => null);
@@ -655,8 +670,15 @@ async function cmdHook(args) {
             catch { /* ignore */ }
             const lines = [];
             lines.push('<stitch-context>');
-            lines.push(`Project: ${threadName} · Workspace: ${currentWs?.name || '(unknown)'} · Stitch MCP tools: recall, remember, recall_global, remember_global, thread_recall, thread_append, workspace_setup, file_summary, file_summary_save.`);
+            lines.push(`Project: ${threadName} · Workspace: ${currentWs?.name || '(unknown)'} · ${poolSize} memories indexed · Stitch MCP tools: recall, remember, recall_global, remember_global, thread_recall, thread_append, workspace_setup, file_summary, file_summary_save.`);
             lines.push('');
+            // Huge-pool mode: don't pre-load any memories. Tell Claude what's
+            // available and that it should pull what's relevant on demand.
+            if (poolSize >= 200 && memHits.length === 0) {
+                lines.push('### Memory pool');
+                lines.push(`This project has ${poolSize}+ memories. Don't try to load them all — call \`recall(query)\` whenever the user references prior decisions, code patterns, or preferences. Cheaper and more relevant than reading them upfront.`);
+                lines.push('');
+            }
             // Nudge the AI to set a meaningful workspace name once.
             if (currentWs?.name === 'default') {
                 lines.push('### ⚠ Workspace is still named "default"');
@@ -683,7 +705,13 @@ async function cmdHook(args) {
                 for (const m of sortedMems) {
                     const isAuto = Array.isArray(m.tags) && m.tags.includes('auto');
                     const txt = String(m.content || '').replace(/\n+/g, ' ').slice(0, 350);
-                    lines.push(`- **[${m.kind}${isAuto ? '·auto' : ''}]** ${txt}`);
+                    // Source receipt: when this memory came from a distilled thread,
+                    // mark the source so the agent knows it can call thread_recall on
+                    // that thread for verbatim context behind the fact.
+                    const src = m.source_thread_id
+                        ? ` _(from thread, ${m.source_turn_ids?.length || 0} turns)_`
+                        : '';
+                    lines.push(`- **[${m.kind}${isAuto ? '·auto' : ''}]** ${txt}${src}`);
                 }
                 lines.push('');
             }
@@ -699,13 +727,17 @@ async function cmdHook(args) {
             }
             if (thread.recent && thread.recent.length > 0) {
                 lines.push('### Most recent turns (continue from here)');
-                for (const t of thread.recent.slice(-5)) {
+                for (const t of thread.recent.slice(-turnSliceK)) {
                     const txt = String(t.content || '').replace(/\n+/g, ' ').slice(0, 300);
                     lines.push(`- **${t.role}**: ${txt}`);
                 }
                 lines.push('');
             }
-            lines.push('Call `recall` for project memory, `recall_global` for cross-project user prefs, `thread_recall` for older turns, `file_summary` BEFORE reading any non-trivial file. Save user-level habits/preferences with `remember_global`; project facts with `remember`.');
+            lines.push('## How to use this memory layer');
+            lines.push('- The user mentions prior work, decisions, or "what we discussed" → call `recall(query)` (or `thread_recall(thread, semantic: ...)` for verbatim turns) BEFORE answering. Don\'t guess from the snippets above; they\'re a teaser, not the truth.');
+            lines.push('- About to open a non-trivial file → call `file_summary(path)` first. If hash matches the cached summary, you can skip the full read entirely.');
+            lines.push('- Learn a durable user-level habit ("I always use Postgres", "commit before reverting") → save with `remember_global` so it surfaces across every project. Project-specific facts → `remember`.');
+            lines.push('- A surfaced memory has `_(from thread, N turns)_` next to it → those turns are queryable via `thread_recall`. Reach for them when challenged on a fact.');
             lines.push('</stitch-context>');
             process.stdout.write(lines.join('\n'));
         }
@@ -1238,13 +1270,25 @@ async function cmdDistill(args) {
         bumpDistillCooldown(thread);
         return;
     }
-    // Push each to Stitch as a memory with auto:true tag. No project:* tag —
-    // the workspace itself is the project identity.
+    // Push each to Stitch as a memory with auto:true tag, plus receipts:
+    // the source thread + the IDs of the turns this distill batch covered,
+    // and a short excerpt from the most recent user turn so the dashboard /
+    // recall surface can preview the conversational context behind the fact
+    // without an extra round-trip.
+    const sourceTurnIds = recall.recent.map((t) => t.id);
+    const lastUserTurn = [...recall.recent].reverse().find((t) => t.role === 'user');
+    const sourceExcerpt = lastUserTurn ? String(lastUserTurn.content || '').slice(0, 300) : undefined;
     let saved = 0;
     for (const m of memories) {
         try {
             const tags = ['auto', 'auto:distill', `thread:${thread}`, ...(m.tags || [])];
-            await stitch.remember(m.content, { kind: m.kind, tags });
+            await stitch.remember(m.content, {
+                kind: m.kind,
+                tags,
+                source_thread_id: recall.thread_id,
+                source_turn_ids: sourceTurnIds,
+                source_excerpt: sourceExcerpt,
+            });
             saved++;
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stitchdb/cli",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Stitch CLI — manage memory + run agents from your terminal",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
   "license": "MIT",
   "engines": { "node": ">=20" },
   "dependencies": {
-    "@stitchdb/agent": "^0.2.0"
+    "@stitchdb/agent": "^0.3.0"
   },
   "devDependencies": {
     "typescript": "^5.4.0",