@snoai/mem-claude 1.2.8 → 1.2.10

package/README.md

@@ -14,7 +14,7 @@ start of every session.
   the old one as retired history. Automatic recall only shows what is current.
 - **Scoped to your work.** Memory belongs to the git repository you are in, plus a global scope
   you can read everywhere. Other agents that use the same setup (Codex, OpenClaw, Hermes Agent)
-  share it.
+  use the same global scope.
 - **Yours, and it stays yours.** The store is encrypted from first use with a key made once on
   your machine. Sno never receives your database or your key. There is no daemon to babysit:
   the memory service starts when Claude Code needs it.
@@ -24,7 +24,7 @@ start of every session.
 
 ## Get started
 
-1. Follow the [shared memory setup](https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md).
+1. Follow the [memory service setup](https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md).
    It takes a few minutes and runs once for every agent on the machine.
 2. Install the plugin (Node.js 22.22.3+, 24.15.0+ or 25.9.0+, and `git`):
 
@@ -40,7 +40,7 @@ start of every session.
    sno memory recall --harness claude "indentation"
    ```
 
-   `doctor` should report `sidecar: healthy`. To fix a wrong entry:
+   `doctor` should report the memory service as healthy (the line reads `sidecar: healthy`). To fix a wrong entry:
    `sno memory correct --harness claude <id> "correct text"`. Subagents and sessions outside a git
    repository read and write nothing.
 
@@ -49,10 +49,9 @@ Daily use and troubleshooting: [usage guide](https://github.com/sno-ai/sno-stati
 
 ## Modes
 
-**Local First** (what the shared setup selects) needs no model and no API key: capture is
+**Local First** (what the memory service setup selects) needs no model and no API key: capture is
 verbatim and everything stays on your machine. **Agent Native** lets Claude Code itself do the
-memory work on your existing subscription, and **REM Enhanced** also uses Sno's memory models
-for extraction and conflict checks, which needs a Sno key in `settings.json`. Change the mode in
+memory work on your existing subscription, and **REM Enhanced** adds Sno's own memory models to REM, the overnight step where your agents dream: it strengthens their memory and settles what they learned. It runs at most once a day for each part of your memory: usually overnight, or earlier the same day once about 100 new memories have piled up. Sno's models also write down what matters from each conversation when the session ends. It needs a Sno key in `settings.json`. In that mode your memory text and lessons go to your own space in Sno's cloud, which works like your own cloud drive: a Sno program processes it for you alone, and you can delete or keep it as you like. Change the mode in
 `~/.sno/settings.json`, and keep the existing encryption key.
 
 ## Under the hood

package/dist/cli.js

@@ -7,7 +7,7 @@ import { postToolUse, preToolUse, sessionEnd, sessionStart, stop, userPromptSubm
 import { installClaude, uninstallClaude } from "./install.js";
 import { importRepository } from "./import.js";
 import { MESSAGES } from "./messages.js";
-import { workspaceRoot } from "./scope.js";
+import { isTemporaryDirectory, workspaceRoot } from "./scope.js";
 import { runWorker } from "./worker.js";
 async function readStdin() {
     const chunks = [];
@@ -27,6 +27,17 @@ async function main() {
     // The Cursor IDE runs Claude Code hooks with Cursor-shaped input; Sno's Cursor hooks own Cursor, so these do nothing there.
     if (input && typeof input === "object" && "cursor_version" in input)
         return 0;
+    // Scripted runs (a temporary directory, `claude -p`) and background-task notices are not conversations; the
+    // real-agent release journeys set SNO_CAPTURE_SCRIPTED=1 to be recorded anyway. Measured 2026-10-13: 616 of 785 queued turns.
+    if (input && process.env["SNO_CAPTURE_SCRIPTED"] !== "1" && typeof input === "object") {
+        const { cwd, prompt } = input;
+        if (typeof cwd === "string" && isTemporaryDirectory(cwd))
+            return 0;
+        if (process.env["CLAUDE_CODE_ENTRYPOINT"]?.startsWith("sdk-"))
+            return 0;
+        if (typeof prompt === "string" && prompt.trimStart().startsWith("<task-notification>"))
+            return 0;
+    }
     if (command === "session-start") {
         process.stdout.write(`${await sessionStart(input)}\n`);
         return 0;

package/dist/scope.d.ts

@@ -1,4 +1,6 @@
 import type { ScopeCtx } from "@snoai/memory/client";
+/** A session under the system temporary directory is a throwaway run (a script's or test's agent call); it is never memory. */
+export declare function isTemporaryDirectory(dir: string): boolean;
 /** One workspace is the git repository root when `cwd` is inside one, else `cwd` itself. */
 export declare function workspaceRoot(cwd: string): Promise<string>;
 export declare function hookScope(project: string, sessionId: string): ScopeCtx;

package/dist/scope.js

@@ -1,8 +1,26 @@
 import { execFile } from "node:child_process";
-import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { CODING_SKIN_MANUAL_SESSION_ID } from "@snoai/memory/coding-skin";
 const execFileAsync = promisify(execFile);
+/** A session under the system temporary directory is a throwaway run (a script's or test's agent call); it is never memory. */
+export function isTemporaryDirectory(dir) {
+    const real = (path) => {
+        try {
+            return realpathSync(path);
+        }
+        catch {
+            return resolve(path);
+        }
+    };
+    const target = real(dir);
+    return [tmpdir(), "/tmp", "/var/tmp"].some((root) => {
+        const base = real(root);
+        return target === base || target.startsWith(base.endsWith(sep) ? base : `${base}${sep}`);
+    });
+}
 /** One workspace is the git repository root when `cwd` is inside one, else `cwd` itself. */
 export async function workspaceRoot(cwd) {
     try {

package/dist/worker.js

@@ -3,9 +3,9 @@ import { spawn, spawnSync } from "node:child_process";
 import { closeSync, mkdirSync, openSync } from "node:fs";
 import { createServer } from "node:http";
 import { userInfo } from "node:os";
-import { readFile, readdir, unlink } from "node:fs/promises";
+import { readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_CHILD_MAX_BUFFER_BYTES, CODING_SKIN_IMPORT_INTERVAL_MS, CODING_SKIN_MAX_ATTEMPTS, CODING_SKIN_RETRY_DELAYS_MS, CODING_SKIN_WORKER_LIFETIME_MS, HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, HOST_MODEL_DEADLINE_HEADER, } from "@snoai/memory/coding-skin";
+import { CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_CHILD_MAX_BUFFER_BYTES, CODING_SKIN_IMPORT_INTERVAL_MS, CODING_SKIN_MAX_ATTEMPTS, CODING_SKIN_MAX_PENDING_CAPTURES, CODING_SKIN_RETRY_DELAYS_MS, CODING_SKIN_WORKER_LIFETIME_MS, HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, HOST_MODEL_DEADLINE_HEADER, } from "@snoai/memory/coding-skin";
 import { z } from "zod";
 import { MODEL_ID, SKIN_ID } from "./constants.js";
 import { acquirePidFileLock, writeJsonAtomic } from "./files.js";
@@ -183,18 +183,44 @@ async function updateImportReceipt(reference, field) {
         console.log(JSON.stringify({ event: "import-receipt-failed", path: reference.path, file: reference.file, field, error: String(error) }));
     }
 }
+async function readSpool(path) {
+    const contents = await readFile(path, "utf8").catch(error => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (contents === undefined)
+        return undefined;
+    let record;
+    try {
+        record = spoolSchema.parse(JSON.parse(contents));
+    }
+    catch (error) {
+        await rm(path, { force: true });
+        console.log(JSON.stringify({ event: "spool-discarded", path, reason: "invalid-record", error: String(error) }));
+        return undefined;
+    }
+    if (record.attempts >= CODING_SKIN_MAX_ATTEMPTS) {
+        await rm(path, { force: true });
+        console.log(JSON.stringify({ event: "spool-discarded", path, turnId: record.turnId, reason: "attempts-exhausted" }));
+        return undefined;
+    }
+    return record;
+}
+async function readSpoolNames() {
+    const names = (await readdir(spoolDirectory()).catch(() => [])).filter(name => name.endsWith(".json")).sort();
+    const removed = names.splice(0, Math.max(0, names.length - CODING_SKIN_MAX_PENDING_CAPTURES));
+    for (const name of removed)
+        await rm(join(spoolDirectory(), name), { force: true });
+    if (removed.length > 0)
+        console.log(JSON.stringify({ event: "spool-pruned", removed: removed.length,
+            remaining: names.length, reason: "capacity" }));
+    return names;
+}
 export async function hasActionableSpool() {
-    const names = (await readdir(spoolDirectory()).catch(() => [])).filter(name => name.endsWith(".json"));
+    const names = await readSpoolNames();
     for (const name of names) {
-        const contents = await readFile(join(spoolDirectory(), name), "utf8").catch(error => {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT")
-                return undefined;
-            throw error;
-        });
-        if (!contents)
-            continue;
-        const record = spoolSchema.parse(JSON.parse(contents));
-        if (record.attempts < CODING_SKIN_MAX_ATTEMPTS)
+        if (await readSpool(join(spoolDirectory(), name)))
             return true;
     }
     return false;
@@ -218,6 +244,7 @@ export async function runWorker(dependencies = productionDependencies()) {
         mkdirSync(childCwd, { recursive: true, mode: 0o700 });
         const callback = await callbackServer(credential, () => currentCwd ?? childCwd, () => currentImport, () => { lastCallbackAt = now(); }, (prompt, cwd, requesterMs) => dependencies.runChild(prompt, cwd, Math.min(CODING_SKIN_CHILD_DEADLINE_MS, CODING_SKIN_WORKER_LIFETIME_MS - (now() - workerStartedAt), requesterMs ?? Infinity)));
         server = callback.server;
+        await readSpoolNames();
         const client = await dependencies.connect();
         const principal = client.principal || userInfo().username;
         await client.init({ principal, project: "global", session: "claude-worker", host: { sessionId: "claude-worker" } }, {
@@ -225,14 +252,25 @@ export async function runWorker(dependencies = productionDependencies()) {
         });
         console.log(JSON.stringify({ event: "worker-registered" }));
         while (true) {
-            const spoolNames = (await readdir(spoolDirectory()).catch(() => [])).filter(name => name.endsWith(".json")).sort();
+            const spoolNames = await readSpoolNames();
             console.log(JSON.stringify({ event: "spool-scan", count: spoolNames.length }));
             let actionable = 0;
-            for (const name of spoolNames) {
+            for (const name of spoolNames.slice(0, 1)) {
                 const path = join(spoolDirectory(), name);
-                let record = spoolSchema.parse(JSON.parse(await readFile(path, "utf8")));
-                if (record.attempts >= CODING_SKIN_MAX_ATTEMPTS)
+                let record = await readSpool(path);
+                if (!record)
                     continue;
+                const batch = [{ path, record }];
+                if (record.kind !== "import")
+                    for (const pendingName of spoolNames.slice(1)) {
+                        const pendingPath = join(spoolDirectory(), pendingName);
+                        const pending = await readSpool(pendingPath);
+                        if (pending && pending.sessionId === record.sessionId && pending.project === record.project
+                            && pending.childCwd === record.childCwd && pending.attempts === record.attempts
+                            && pending.retryAt === record.retryAt && pending.kind !== "import")
+                            batch.push({ path: pendingPath, record: pending });
+                    }
+                batch.sort((left, right) => left.record.at - right.record.at);
                 actionable += 1;
                 drainedAt = undefined;
                 while (record.attempts < CODING_SKIN_MAX_ATTEMPTS) {
@@ -255,41 +293,52 @@ export async function runWorker(dependencies = productionDependencies()) {
                     currentCwd = childCwd;
                     currentImport = record.kind === "import";
                     try {
-                        const messages = record.kind === "import"
-                            ? [{ role: "user", content: record.user, at: record.at }]
+                        const messages = batch.flatMap(({ record: turn }) => turn.kind === "import"
+                            ? [{ role: "user", content: turn.user, at: turn.at }]
                             : [
-                                { role: "user", content: record.user, at: record.at },
-                                { role: "assistant", content: record.assistant ?? "", at: record.at },
-                            ];
+                                { role: "user", content: turn.user, at: turn.at },
+                                { role: "assistant", content: turn.assistant ?? "", at: turn.at },
+                            ]);
                         const result = await withinDeadline(client.capture({ turnId: record.turnId, rewindEpoch: 0, messages }, { principal, project: record.project, session: record.sessionId, host: { sessionId: record.sessionId, workspace: record.project } }), CODING_SKIN_WORKER_LIFETIME_MS - (now() - workerStartedAt));
                         if (result.degraded)
                             throw new Error(result.reason);
                         if (!result.committed && !result.accepted && !result.skipped && !result.partial)
                             throw new Error("capture not committed");
                         await updateImportReceipt(record.importReceipt, result.committed || result.accepted || result.partial ? "committed" : "skipped");
-                        console.log(JSON.stringify({ event: result.partial ? "capture-partial" : result.committed ? "capture-committed" : result.accepted ? "capture-accepted" : "capture-skipped", turnId: record.turnId, committed: result.committed }));
-                        await unlink(path);
+                        for (const entry of batch) {
+                            console.log(JSON.stringify({ event: result.partial ? "capture-partial" : result.committed ? "capture-committed" : result.accepted ? "capture-accepted" : "capture-skipped", turnId: entry.record.turnId, committed: result.committed }));
+                            await rm(entry.path, { force: true });
+                        }
                         break;
                     }
                     catch (error) {
                         await updateImportReceipt(record.importReceipt, "failures");
                         const attempts = record.attempts + 1;
-                        console.log(JSON.stringify({ event: "capture-failed", turnId: record.turnId, attempt: attempts,
-                            final: attempts >= CODING_SKIN_MAX_ATTEMPTS, error: error instanceof Error ? error.message : String(error) }));
+                        for (const entry of batch)
+                            console.log(JSON.stringify({ event: "capture-failed", turnId: entry.record.turnId, attempt: attempts,
+                                final: attempts >= CODING_SKIN_MAX_ATTEMPTS, error: error instanceof Error ? error.message : String(error) }));
+                        // A batch shares its tries, so only its first turn is given up; the rest keep their own counts on disk.
+                        if (attempts >= CODING_SKIN_MAX_ATTEMPTS) {
+                            const [first] = batch;
+                            if (first)
+                                await rm(first.path, { force: true });
+                            break;
+                        }
                         const retryDelay = CODING_SKIN_RETRY_DELAYS_MS[attempts - 1];
                         record = {
                             ...record,
                             attempts,
-                            state: attempts >= CODING_SKIN_MAX_ATTEMPTS ? "failed" : "pending",
-                            ...(attempts < CODING_SKIN_MAX_ATTEMPTS && retryDelay !== undefined ? { retryAt: now() + retryDelay } : {}),
+                            state: "pending",
+                            ...(retryDelay !== undefined ? { retryAt: now() + retryDelay } : {}),
                         };
-                        await writeJsonAtomic(path, record);
+                        for (const entry of batch) {
+                            entry.record = { ...entry.record, attempts, state: "pending", retryAt: record.retryAt };
+                            await writeJsonAtomic(entry.path, entry.record);
+                        }
                         if (now() - workerStartedAt >= CODING_SKIN_WORKER_LIFETIME_MS) {
                             handoff = true;
                             return "drained";
                         }
-                        if (record.attempts >= CODING_SKIN_MAX_ATTEMPTS)
-                            break;
                     }
                     finally {
                         currentCwd = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snoai/mem-claude",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "license": "Apache-2.0",
   "publishConfig": { "access": "public" },
   "repository": {