gnosys 5.13.0 → 5.14.0

package/dist/cli.js

@@ -1173,9 +1173,16 @@ dreamCmd
     .option("--force", "Run even if this machine is not the designated dream node")
     .option("--scheduled", "Run as the machine-level scheduler (applies night/idle/cooldown gates)")
     .option("--json", "Output raw JSON report")
-    .action(async (opts) => {
+    .action(async function (opts) {
+    // v5.13.1: the bare `gnosys dream` parent declares the same flags, and
+    // commander resolves parent-declared options onto the PARENT during
+    // `dream run --scheduled` — so run's opts arrived empty and every
+    // scheduled invocation (the launchd agent's exact command line) ran as
+    // a MANUAL dream, bypassing the night/idle/dreamworthiness gates.
+    // Merge parent opts (same pattern as `dream log` below).
+    const merged = { ...(this.parent?.opts() ?? {}), ...opts };
     const { runDreamCommand } = await import("./lib/dreamCommand.js");
-    await runDreamCommand(opts);
+    await runDreamCommand(merged);
 });
 // `gnosys dream log` — view recent dream runs from audit_log
 dreamCmd
@@ -1300,6 +1307,15 @@ program
     const { runRecallCommand } = await import("./lib/recallCommand.js");
     await runRecallCommand(query, opts);
 });
+// ─── gnosys recall-hook ──────────────────────────────────────────────────
+program
+    .command("recall-hook")
+    .description("Claude Code hook entry — reads the hook event JSON from stdin and prints a <gnosys-recall> context block. Wired automatically by gnosys init into UserPromptSubmit + SessionStart.")
+    .option("--limit <n>", "Max memories to inject (default from config)")
+    .action(async (opts) => {
+    const { runRecallHookCommand } = await import("./lib/recallHookCommand.js");
+    await runRecallHookCommand(opts);
+});
 // ─── gnosys audit ────────────────────────────────────────────────────────
 program
     .command("audit")
@@ -1848,10 +1864,13 @@ if (!isTestEnv()) {
             // console.log during boot corrupts the protocol and the host (Grok, Codex,
             // etc.) sees the server as [unavailable]. Suppress the nag in serve mode.
             const isServeCmd = process.argv.slice(2).some(a => a === "serve");
+            // v5.14.0: recall-hook runs on every Claude Code prompt — keep its
+            // stderr quiet too so hook error logs stay clean.
+            const isHookCmd = process.argv.slice(2).some(a => a === "recall-hook");
             // v5.9.3 Phase H: fire on any mismatch (upgrade OR downgrade).
             const mismatch = lastVersion !== null && lastVersion !== undefined &&
                 compareSemver(currentVersion, lastVersion) !== 0;
-            if (mismatch && !isUpgradeCmd && !isSetupSyncCmd && !isServeCmd) {
+            if (mismatch && !isUpgradeCmd && !isSetupSyncCmd && !isServeCmd && !isHookCmd) {
                 // v5.9.3 Phase H: emit on STDERR (was stdout). Safer invariant per
                 // deci-045 — stdout is reserved for command output.
                 const isMajorOrMinor = (() => {

package/dist/index.js

@@ -2246,7 +2246,7 @@ async function reindexAllStores() {
 //
 // Priority 1 + audience: assistant = hosts inject this before every message.
 regResource("gnosys_recall", "gnosys://recall", {
-    description: "Automatic memory injection. Hosts read this resource on every turn to inject the most relevant memories as context. Returns a <gnosys-recall> block with [[wikilinks]] and relevance scores. Priority 1 (highest) — designed for always-on context injection without any tool call. Configure aggressiveness in gnosys.json: recall.aggressive (default: true).",
+    description: "Top-memory injection block for hosts that read MCP resources. Returns a <gnosys-recall> block with [[wikilinks]] and relevance scores. NOTE: most hosts (Claude Code, Cursor) do NOT auto-read MCP resources per turn — for true automatic injection use the hooks `gnosys init` installs (UserPromptSubmit/SessionStart → `gnosys recall-hook`). Configure aggressiveness in gnosys.json: recall.aggressive (default: true).",
     mimeType: "text/markdown",
     annotations: {
         audience: ["assistant"],
@@ -2294,7 +2294,7 @@ regResource("gnosys_recall", "gnosys://recall", {
 // ─── Tool: gnosys_recall (query-specific fallback) ──────────────────────
 // For hosts that don't support MCP Resources, or when the agent wants to
 // recall memories for a specific query. The resource above is preferred.
-regTool("gnosys_recall", "Fast memory recall — inject relevant memories as context. Returns <gnosys-recall> block. In aggressive mode (default), always returns top memories even at medium relevance. Prefer the gnosys://recall MCP Resource for automatic injection (no tool call needed).", {
+regTool("gnosys_recall", "Fast memory recall — inject relevant memories as context. Returns <gnosys-recall> block. In aggressive mode (default), always returns top memories even at medium relevance. A wildcard query ('*') returns the top memories by reinforcement/confidence/recency. Hosts with gnosys hooks installed (via gnosys init) already get this automatically per prompt.", {
     query: z
         .string()
         .describe("What the agent is currently working on. Use keywords. Example: 'auth JWT middleware' or 'database migration schema'"),

package/dist/lib/db.d.ts

@@ -330,6 +330,12 @@ export declare class GnosysDB {
         tags: string;
         content: string;
     }>;
+    /**
+     * v5.13.1: top active memories for wildcard recall. The gnosys://recall
+     * resource asks for "the best memories, no query" — rank by how often a
+     * memory proved useful (reinforcement), then confidence, then recency.
+     */
+    getTopActiveMemories(limit?: number): DbMemory[];
     /** v5.13.0: memories whose embedding column is NULL (embedding-health check). */
     countMemoriesMissingEmbedding(): number;
     updateEmbedding(id: string, embedding: Buffer): void;

package/dist/lib/db.js

@@ -1264,6 +1264,15 @@ export class GnosysDB {
         const lim = limit && limit > 0 ? ` LIMIT ${Math.floor(limit)}` : "";
         return this.withRecovery(() => this.prep(`SELECT id, title, relevance, tags, content FROM memories ${where} ORDER BY modified DESC${lim}`).all());
     }
+    /**
+     * v5.13.1: top active memories for wildcard recall. The gnosys://recall
+     * resource asks for "the best memories, no query" — rank by how often a
+     * memory proved useful (reinforcement), then confidence, then recency.
+     */
+    getTopActiveMemories(limit = 15) {
+        return this.withRecovery(() => this.prep(`SELECT ${LEAN_MEMORY_PROJECTION} FROM memories WHERE tier = 'active' AND status = 'active'
+         ORDER BY reinforcement_count DESC, confidence DESC, modified DESC LIMIT ?`).all(limit));
+    }
     /** v5.13.0: memories whose embedding column is NULL (embedding-health check). */
     countMemoriesMissingEmbedding() {
         return this.withRecovery(() => {

package/dist/lib/dreamCommand.js

@@ -1,7 +1,7 @@
 import { GnosysResolver } from "./resolver.js";
 import { GnosysDB } from "./db.js";
 import { loadConfig } from "./config.js";
-import { acquireDreamLock, appendDreamRun, countChangedMemoriesSince, createSkipRunRecord, getSystemIdleMinutes, isInsideNightWindow, readDreamState, } from "./dreamRunLog.js";
+import { acquireDreamLock, appendDreamRun, countDreamworthyChanges, createSkipRunRecord, getSystemIdleMinutes, isInsideNightWindow, readDreamState, } from "./dreamRunLog.js";
 export async function runDreamCommand(opts) {
     const resolver = new GnosysResolver();
     await resolver.resolve();
@@ -15,7 +15,14 @@ export async function runDreamCommand(opts) {
     const { getMachineId } = await import("./remote.js");
     const storePath = stores[0].path;
     const cfg = await loadConfig(storePath);
-    const db = new DbClass(storePath);
+    // v5.13.1: Dream operates on the brain — the central DB — not the
+    // project store the command happened to be run from. Opening
+    // stores[0].path meant `gnosys dream run` failed with "run gnosys
+    // migrate" from any project directory whose local .gnosys has no
+    // migrated DB, even though the central DB was fine (and the designation
+    // check below already used openCentral). DbClass alias keeps the lazy
+    // import pattern.
+    const db = DbClass.openCentral();
     if (!db.isAvailable() || !db.isMigrated()) {
         console.error("Dream Mode requires gnosys.db (v2.0). Run 'gnosys migrate' first.");
         process.exit(1);
@@ -114,7 +121,9 @@ export async function runDreamCommand(opts) {
             gates.push({ name: "system-idle", passed: true, details: { idleMinutes } });
             const state = readDreamState();
             const memories = db.getActiveMemories();
-            const changed = countChangedMemoriesSince(memories, state.lastMemoryMaxModified);
+            // v5.13.1: max(date-watermark changes, count delta) — self-heals
+            // stale/polluted state files and catches bulk imports/deletions.
+            const changed = countDreamworthyChanges(memories, state);
             const lastRunMs = state.lastSuccessfulRunAt ? Date.parse(state.lastSuccessfulRunAt) : 0;
             const hoursSince = lastRunMs ? (Date.now() - lastRunMs) / 3_600_000 : Infinity;
             const enoughMemories = changed >= cfg.dream.minNewMemoriesToDream;

package/dist/lib/dreamRunLog.d.ts

@@ -107,6 +107,16 @@ export declare function memoryWatermark(memories: DbMemory[]): {
     maxModified: string | undefined;
 };
 export declare function countChangedMemoriesSince(memories: DbMemory[], sinceIso?: string): number;
+/**
+ * v5.13.1: total change signal for the dreamworthiness gate. The date-only
+ * watermark misses bulk imports, deletions, and stale/polluted state files
+ * (a test-suite bug wrote lastMemoryCount=5 against 1,200+ memory brains,
+ * suppressing scheduled dreaming indefinitely — fixed in v5.13.0, but
+ * already-polluted machines need the gate itself to self-heal). A mismatch
+ * between the stored memory count and reality IS change — take the max of
+ * both signals.
+ */
+export declare function countDreamworthyChanges(memories: DbMemory[], state: DreamState): number;
 export declare function isInsideNightWindow(now: Date, schedule: DreamConfig["schedule"]): boolean;
 export declare function getSystemIdleMinutes(): number | null;
 export declare function createSkipRunRecord(input: {

package/dist/lib/dreamRunLog.js

@@ -175,6 +175,20 @@ export function countChangedMemoriesSince(memories, sinceIso) {
         return memories.length;
     return memories.filter((m) => Date.parse(m.modified || m.created) > sinceMs).length;
 }
+/**
+ * v5.13.1: total change signal for the dreamworthiness gate. The date-only
+ * watermark misses bulk imports, deletions, and stale/polluted state files
+ * (a test-suite bug wrote lastMemoryCount=5 against 1,200+ memory brains,
+ * suppressing scheduled dreaming indefinitely — fixed in v5.13.0, but
+ * already-polluted machines need the gate itself to self-heal). A mismatch
+ * between the stored memory count and reality IS change — take the max of
+ * both signals.
+ */
+export function countDreamworthyChanges(memories, state) {
+    const byDate = countChangedMemoriesSince(memories, state.lastMemoryMaxModified);
+    const countDelta = state.lastMemoryCount == null ? 0 : Math.abs(memories.length - state.lastMemoryCount);
+    return Math.max(byDate, countDelta);
+}
 export function isInsideNightWindow(now, schedule) {
     const start = schedule.startHour;
     const end = schedule.endHour;

package/dist/lib/projectIdentity.js

@@ -202,29 +202,61 @@ export async function configureClaudeCode(projectDir) {
     catch {
         // No settings yet
     }
-    // Build the Gnosys SessionStart hook
+    // v5.14.0: the hook command is `gnosys recall-hook` — it reads the hook
+    // event JSON from stdin (per the Claude Code hooks contract) and prints
+    // a <gnosys-recall> block, which Claude Code adds to the model context.
+    // Pre-5.14 installs wrote `gnosys recall --query ... --projectRoot ...`,
+    // options that never existed — the hook failed silently on every
+    // session start. Detect and heal that shape below.
+    const hookCommand = "gnosys recall-hook 2>/dev/null || true";
     const gnosysHook = {
         type: "command",
-        command: "gnosys recall --query \"session start\" --projectRoot \"$CLAUDE_PROJECT_DIR\" 2>/dev/null || true",
+        command: hookCommand,
         timeout: 10,
     };
-    // Merge into existing hooks without clobbering other SessionStart hooks
+    const isGnosysHookCmd = (h) => typeof h.command === "string" &&
+        (h.command.includes("gnosys recall-hook") ||
+            // the exact broken pre-5.14 shape only — a user's own `gnosys recall
+            // <topic>` hook must not count as "already configured"
+            h.command.includes("gnosys recall --query"));
+    const isBrokenLegacyCmd = (h) => typeof h.command === "string" && h.command.includes("gnosys recall --query");
+    // Merge into existing hooks without clobbering other entries
     const hooks = (settings.hooks || {});
+    let changed = false;
+    // Heal the broken legacy command wherever it appears
+    for (const eventName of Object.keys(hooks)) {
+        for (const entry of (hooks[eventName] || [])) {
+            const entryHooks = (entry.hooks || []);
+            for (const h of entryHooks) {
+                if (isBrokenLegacyCmd(h)) {
+                    h.command = hookCommand;
+                    changed = true;
+                }
+            }
+        }
+    }
+    // SessionStart: top memories at startup/resume/compact
     const sessionStartEntries = (hooks.SessionStart || []);
-    // Check if a Gnosys hook already exists
-    const hasGnosysHook = sessionStartEntries.some((entry) => {
-        const entryHooks = (entry.hooks || []);
-        return entryHooks.some((h) => typeof h.command === "string" && h.command.includes("gnosys recall"));
-    });
-    if (!hasGnosysHook) {
-        sessionStartEntries.push({
-            matcher: "startup|resume|compact",
-            hooks: [gnosysHook],
-        });
+    const hasSessionHook = sessionStartEntries.some((entry) => (entry.hooks || []).some(isGnosysHookCmd));
+    if (!hasSessionHook) {
+        sessionStartEntries.push({ matcher: "startup|resume|compact", hooks: [gnosysHook] });
         hooks.SessionStart = sessionStartEntries;
+        changed = true;
+    }
+    // UserPromptSubmit: per-prompt recall with the prompt text as the query —
+    // this is the "automatic memory injection" path (no matcher: always fires)
+    const promptEntries = (hooks.UserPromptSubmit || []);
+    const hasPromptHook = promptEntries.some((entry) => (entry.hooks || []).some(isGnosysHookCmd));
+    if (!hasPromptHook) {
+        promptEntries.push({ hooks: [gnosysHook] });
+        hooks.UserPromptSubmit = promptEntries;
+        changed = true;
+    }
+    if (changed) {
         settings.hooks = hooks;
         await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
     }
+    const hasGnosysHook = !changed;
     // v5.8.4: also register the MCP server itself (not just the recall hook),
     // so `gnosys init` is a one-stop shop. Previously the user had to ALSO
     // run `gnosys setup` for agents to actually call gnosys MCP tools.
@@ -234,7 +266,9 @@ export async function configureClaudeCode(projectDir) {
         configured: true,
         filePath: settingsPath,
         details: [
-            hasGnosysHook ? "SessionStart hook already configured" : "Added SessionStart hook",
+            hasGnosysHook
+                ? "Recall hooks already configured"
+                : "Recall hooks configured (SessionStart + UserPromptSubmit → gnosys recall-hook)",
             mcpResult.success ? mcpResult.message : `MCP register skipped: ${mcpResult.message}`,
         ].join("; "),
     };

package/dist/lib/recall.d.ts

@@ -62,9 +62,10 @@ interface RecallMemory {
  */
 export declare function recall(query: string, options: {
     limit?: number;
-    search: GnosysSearch;
-    resolver: GnosysResolver;
-    storePath: string;
+    /** Optional in v5.14: callers on the DB fast path (hooks) skip the file-store deps. */
+    search?: GnosysSearch;
+    resolver?: GnosysResolver;
+    storePath?: string;
     traceId?: string;
     recallConfig?: RecallConfig;
     /** v2.0: When provided, recall uses SQLite directly — no filesystem reads */

package/dist/lib/recall.js

@@ -23,6 +23,7 @@
 import { GnosysArchive } from "./archive.js";
 import { mergeOverlayDiscoverResults, pendingAddToDbMemory, } from "./clientReadOverlay.js";
 import { auditLog } from "./audit.js";
+import { ftsTerms } from "./ftsQuery.js";
 /** Default recall config */
 const DEFAULT_RECALL_CONFIG = {
     aggressive: true,
@@ -71,6 +72,17 @@ export async function recall(query, options) {
         return recallFromDb(query, options.gnosysDb, limit, cfg, options.traceId, options.pendingOverlay);
     }
     // ─── v1.x legacy path (filesystem + search.db) ────────────────────
+    // v5.14: DB-only callers (recall-hook) pass no file-store deps; without
+    // them and without a central DB there is nothing to search.
+    if (!options.search || !options.resolver) {
+        return {
+            memories: [],
+            totalActive: 0,
+            totalArchived: 0,
+            recallTimeMs: Math.round((performance.now() - start) * 100) / 100,
+            aggressive: cfg.aggressive,
+        };
+    }
     const memories = [];
     // Step 1: Fast keyword search on active memories (FTS5 — sub-10ms)
     const fetchLimit = Math.max(limit * 2, 15);
@@ -95,7 +107,7 @@ export async function recall(query, options) {
     }
     // Step 2: Archive fallback if active results are thin
     let totalArchived = 0;
-    if (memories.length < limit) {
+    if (memories.length < limit && options.storePath) {
         try {
             const archive = new GnosysArchive(options.storePath);
             if (archive.isAvailable()) {
@@ -150,6 +162,48 @@ function recallFromDb(query, db, limit, cfg, traceId, pendingOverlay) {
     const memories = [];
     // Step 1: FTS5 discover on gnosys.db
     const fetchLimit = Math.max(limit * 2, 15);
+    // v5.13.1: wildcard recall. The gnosys://recall resource passes "*"
+    // meaning "inject the top memories, no specific query" — but "*" was
+    // never a valid FTS5 match-all (it's a syntax error), so the resource
+    // returned zero memories since it shipped in v4.0.0. Any query with no
+    // searchable terms now serves top active memories ranked by
+    // reinforcement, confidence, and recency.
+    if (ftsTerms(query).length === 0) {
+        const top = db.getTopActiveMemories(fetchLimit);
+        for (let i = 0; i < top.length; i++) {
+            const mem = top[i];
+            memories.push({
+                id: mem.id,
+                title: mem.title,
+                category: mem.category,
+                relevance: mem.relevance || "",
+                confidence: mem.confidence,
+                path: mem.id,
+                fromArchive: false,
+                snippet: mem.content.substring(0, 300),
+                // Rank-derived score, floored above minRelevance (0.4 default) so
+                // non-aggressive mode keeps top memories too.
+                relevanceScore: Math.max(0.9 - i * 0.02, 0.5),
+            });
+        }
+        const wildcardCounts = db.getMemoryCount();
+        const result = applyRecallFiltering(memories, top.length, wildcardCounts.archived, limit, cfg, start);
+        db.logAudit({
+            timestamp: new Date().toISOString(),
+            operation: "recall",
+            memory_id: null,
+            details: JSON.stringify({
+                query,
+                wildcard: true,
+                aggressive: cfg.aggressive,
+                totalCandidates: memories.length,
+                filtered: result.memories.length,
+            }),
+            duration_ms: Math.round(result.recallTimeMs),
+            trace_id: traceId || null,
+        });
+        return result;
+    }
     let dbResults = db.discoverFts(query, fetchLimit);
     if (pendingOverlay?.length) {
         dbResults = mergeOverlayDiscoverResults(dbResults, pendingOverlay, query, fetchLimit, (p) => ({

package/dist/lib/recallCommand.js

@@ -70,7 +70,7 @@ export async function runRecallCommand(query, opts) {
         }
         return;
     }
-    // Legacy file-based recall
+    // Default recall path
     const resolver = new GnosysResolver();
     await resolver.resolve();
     const stores = resolver.getStores();
@@ -91,14 +91,29 @@ export async function runRecallCommand(query, opts) {
     // Build search index
     const search = new GnosysSearch(storePath);
     await search.addStoreMemories(stores[0].store);
-    const result = await recall(query, {
-        limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
-        search,
-        resolver,
-        storePath,
-        traceId: opts.traceId,
-        recallConfig,
-    });
+    // v5.14.0: recall from the central DB (the brain) like the MCP tool
+    // does — the CLI previously only searched the project file store, so
+    // `gnosys recall` (and the SessionStart hook built on it) returned
+    // nothing on DB-only installs. Snapshot-aware via clientReadResolve;
+    // falls back to the file-store path when no central DB exists.
+    const { resolveClientRead } = await import("./clientReadResolve.js");
+    const clientRead = resolveClientRead();
+    let result;
+    try {
+        result = await recall(query, {
+            limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+            search,
+            resolver,
+            storePath,
+            traceId: opts.traceId,
+            recallConfig,
+            gnosysDb: clientRead?.db,
+            pendingOverlay: clientRead?.pendingOverlay,
+        });
+    }
+    finally {
+        clientRead?.release();
+    }
     if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
     }

package/dist/lib/recallHookCommand.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `gnosys recall-hook` — Claude Code hook entry point (v5.14.0).
+ *
+ * This is what makes "automatic memory injection" real: Claude Code never
+ * auto-reads MCP resources, but its hooks contract
+ * (code.claude.com/docs/en/hooks.md) adds a hook's plain stdout to the
+ * model context on exit 0. `gnosys init` wires this command into
+ * UserPromptSubmit (every prompt, query = the prompt text) and
+ * SessionStart (startup/resume/compact, wildcard = top memories).
+ *
+ * Contract obligations:
+ *  - FAST: runs on every prompt. DB fast path only — no file stores, no
+ *    embeddings, no model loads. (~150ms cold including node startup.)
+ *  - NEVER breaks the prompt: always exit 0; every failure is silent.
+ *  - Empty stdout when there is nothing to inject (no noise strings).
+ *  - Output stays well under the 10,000-char hook cap.
+ */
+export type HookEvent = {
+    hook_event_name?: string;
+    prompt_text?: string;
+    /** Older docs name the field `prompt`; accept both. */
+    prompt?: string;
+    source?: string;
+    cwd?: string;
+};
+/** Parse the hook event JSON into a recall query ("*" = top memories). */
+export declare function hookQueryFromStdin(raw: string): string;
+export declare function runRecallHookCommand(opts?: {
+    limit?: string;
+}): Promise<void>;

package/dist/lib/recallHookCommand.js

@@ -0,0 +1,85 @@
+/**
+ * `gnosys recall-hook` — Claude Code hook entry point (v5.14.0).
+ *
+ * This is what makes "automatic memory injection" real: Claude Code never
+ * auto-reads MCP resources, but its hooks contract
+ * (code.claude.com/docs/en/hooks.md) adds a hook's plain stdout to the
+ * model context on exit 0. `gnosys init` wires this command into
+ * UserPromptSubmit (every prompt, query = the prompt text) and
+ * SessionStart (startup/resume/compact, wildcard = top memories).
+ *
+ * Contract obligations:
+ *  - FAST: runs on every prompt. DB fast path only — no file stores, no
+ *    embeddings, no model loads. (~150ms cold including node startup.)
+ *  - NEVER breaks the prompt: always exit 0; every failure is silent.
+ *  - Empty stdout when there is nothing to inject (no noise strings).
+ *  - Output stays well under the 10,000-char hook cap.
+ */
+/** Max chars of the user prompt used as the recall query. */
+const MAX_QUERY_CHARS = 400;
+/** Keep comfortably under Claude Code's 10k hook-output cap. */
+const MAX_OUTPUT_CHARS = 8_000;
+/** Parse the hook event JSON into a recall query ("*" = top memories). */
+export function hookQueryFromStdin(raw) {
+    try {
+        const evt = JSON.parse(raw);
+        const prompt = evt.prompt_text ?? evt.prompt;
+        if (typeof prompt === "string" && prompt.trim().length > 0) {
+            return prompt.trim().slice(0, MAX_QUERY_CHARS);
+        }
+    }
+    catch {
+        // Not JSON (manual invocation / future contract change) — wildcard.
+    }
+    return "*";
+}
+async function readStdin(timeoutMs) {
+    if (process.stdin.isTTY)
+        return "";
+    return new Promise((resolve) => {
+        let data = "";
+        const timer = setTimeout(() => resolve(data), timeoutMs);
+        timer.unref?.();
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+        process.stdin.on("error", () => {
+            clearTimeout(timer);
+            resolve(data);
+        });
+    });
+}
+export async function runRecallHookCommand(opts = {}) {
+    try {
+        const raw = await readStdin(1_000);
+        const query = hookQueryFromStdin(raw);
+        const { resolveClientRead } = await import("./clientReadResolve.js");
+        const clientRead = resolveClientRead();
+        if (!clientRead)
+            return; // no central DB — inject nothing, exit 0
+        try {
+            const { recall, formatRecall } = await import("./recall.js");
+            const result = await recall(query, {
+                limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+                gnosysDb: clientRead.db,
+                pendingOverlay: clientRead.pendingOverlay,
+                traceId: "claude-code-hook",
+            });
+            if (result.memories.length === 0)
+                return; // empty stdout = no injection
+            const block = formatRecall(result);
+            process.stdout.write(block.length > MAX_OUTPUT_CHARS ? `${block.slice(0, MAX_OUTPUT_CHARS)}\n</gnosys-recall>\n` : `${block}\n`);
+        }
+        finally {
+            clientRead.release();
+        }
+    }
+    catch {
+        // Never fail the user's prompt over memory recall.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnosys",
-  "version": "5.13.0",
+  "version": "5.14.0",
   "description": "Gnosys — Persistent Memory for AI Agents. Sandbox-first runtime, central SQLite brain, federated search, Dream Mode, Web Knowledge Base, Obsidian export.",
   "type": "module",
   "main": "dist/index.js",