@oortmem/claude-code 0.1.0 → 0.1.1

package/dist/deps.d.ts

@@ -1,5 +1,30 @@
-import type { DecisionController, Embedder, MemoryStore, MemoryWriter, Reranker, ResolvedConfig, Scope } from '@oortmem/core';
+import type { DecisionController, Embedder, Memory, MemoryStore, MemoryWriter, Observation, RecallResult, Reranker, ResolvedConfig, Scope } from '@oortmem/core';
 import type { HookLogger } from './log.js';
+/**
+ * Memory that lives somewhere else (Oort Cloud). When set, the hooks recall and save through it
+ * instead of the local engine; the local store still keeps the Stop cursors and the queue.
+ * Every method rejects on failure; the hooks then inject nothing (they never fall back to a local
+ * store that may hold nothing, or stale memories).
+ */
+export interface RemoteMemory {
+    recall(q: {
+        text: string;
+        projectId?: string;
+    }): Promise<RecallResult>;
+    /** Pinned and hot memories, for SessionStart. */
+    sessionMemories(q: {
+        projectId?: string;
+    }): Promise<Memory[]>;
+    /**
+     * Saves one turn. A rejection with `holdQueue: true` (sign-in, plan, rate limit, outage) keeps
+     * the line queued untouched and stops the drain run; any other rejection counts as an attempt.
+     */
+    /**
+     * Saves one turn. `turnRef` is stable for the turn across retries, so a drain that crashes after
+     * the save and runs again cannot save it twice.
+     */
+    observe(obs: Observation, projectId?: string, turnRef?: string): Promise<void>;
+}
 export interface HookDeps {
     store: MemoryStore;
     embed?: Embedder;
@@ -11,4 +36,6 @@ export interface HookDeps {
     now?: () => Date;
     log: HookLogger;
     spawnDrain?: () => void;
+    /** Oort Cloud mode: recall and save remotely (see `RemoteMemory`). */
+    remote?: RemoteMemory;
 }

package/dist/hooks.js

@@ -76,30 +76,55 @@ export async function handleUserPromptSubmit(input, deps) {
         const degraded = [];
         const t = performance.now();
         let result;
-        const full = recall(q, {
-            store,
-            config,
-            now,
-            ...(deps.embed !== undefined && { embed: deps.embed }),
-            ...(deps.rerank !== undefined && { rerank: deps.rerank }),
-        });
-        // The full recall may lose the race and fail later; nobody awaits it then.
-        full.catch(() => { });
-        try {
-            const r = await withTimeout(full, RECALL_TIMEOUT_MS);
-            if (r === TIMEOUT) {
-                degraded.push('timeout');
-                result = await recall(q, { store, config, now });
+        if (deps.remote !== undefined) {
+            // Oort Cloud: the cloud recalls. A timeout or an error injects nothing, never a local guess.
+            const remote = deps.remote.recall({
+                text: input.prompt,
+                ...(scope.projectId !== undefined && { projectId: scope.projectId }),
+            });
+            remote.catch(() => { });
+            let r;
+            try {
+                r = await withTimeout(remote, RECALL_TIMEOUT_MS);
             }
-            else {
-                result = r;
+            catch {
+                r = undefined;
             }
+            entry.timings['recallMs'] = performance.now() - t;
+            if (r === TIMEOUT || r === undefined) {
+                entry.degraded = [r === TIMEOUT ? 'cloud-timeout' : 'cloud-error'];
+                entry.counts = { memories: 0, chars: 0 };
+                entry.outcome = 'empty';
+                return EMPTY;
+            }
+            result = r;
         }
-        catch {
-            degraded.push('error');
-            result = await recall(q, { store, config, now });
+        else {
+            const full = recall(q, {
+                store,
+                config,
+                now,
+                ...(deps.embed !== undefined && { embed: deps.embed }),
+                ...(deps.rerank !== undefined && { rerank: deps.rerank }),
+            });
+            // The full recall may lose the race and fail later; nobody awaits it then.
+            full.catch(() => { });
+            try {
+                const r = await withTimeout(full, RECALL_TIMEOUT_MS);
+                if (r === TIMEOUT) {
+                    degraded.push('timeout');
+                    result = await recall(q, { store, config, now });
+                }
+                else {
+                    result = r;
+                }
+            }
+            catch {
+                degraded.push('error');
+                result = await recall(q, { store, config, now });
+            }
+            entry.timings['recallMs'] = performance.now() - t;
         }
-        entry.timings['recallMs'] = performance.now() - t;
         // Per-stage timings from recall (numbers only), so slow stages show in the log (CON-57).
         for (const [k, ms] of Object.entries(result.timings)) {
             if (k !== 'totalMs' && k !== 'gateMs')
@@ -179,7 +204,21 @@ export async function handleSessionStart(input, deps) {
         entry.project = scope.projectId ?? null;
         const now = deps.now?.() ?? new Date();
         const { config } = deps;
-        const current = await deps.store.list(grantFor(scope));
+        let current;
+        if (deps.remote !== undefined) {
+            try {
+                current = await deps.remote.sessionMemories(scope.projectId !== undefined ? { projectId: scope.projectId } : {});
+            }
+            catch {
+                entry.degraded = ['cloud-error'];
+                entry.counts = { memories: 0, chars: 0 };
+                entry.outcome = 'empty';
+                return EMPTY;
+            }
+        }
+        else {
+            current = await deps.store.list(grantFor(scope));
+        }
         const picked = current
             .filter((m) => m.pinned || m.tier === 'hot')
             .map((m) => ({

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { HookDeps } from './deps.js';
+export type { HookDeps, RemoteMemory } from './deps.js';
 export { createHookLogger, HOOK_LOG_MAX_BYTES, type HookLogEntry, type HookLogger } from './log.js';
 export { HARNESS_TAGS, OORT_MEMORY_TAG, parseTranscript, parseTranscriptDetailed, selectAfterCursor, turnsToObservations, type DetailedTurn, type Turn, } from './transcript.js';
 export { cursorKey, filterFor, grantFor, handleSessionStart, handleStop, handleUserPromptSubmit, RECALL_TIMEOUT_MS, runHook, STOP_MAX_OBSERVATIONS, type HookEvent, type HookOutput, } from './hooks.js';

package/dist/queue.d.ts

@@ -58,6 +58,17 @@ export interface DrainResult {
     failed: number;
     remaining: number;
 }
+/**
+ * A stable id for a queued turn: `<sessionId>:<transcript turn>` when both are known, else the
+ * queue line's own id (kept across retries, since a failed line stays in its file).
+ */
+export declare function turnRefOf(line: {
+    id: string;
+    obs: {
+        sessionId?: string;
+        turnRef?: string;
+    };
+}): string;
 /**
  * Observes queued lines, oldest file first, at most 50 per run, under the
  * drain lock. A line that observed is removed; one whose observe threw keeps

package/dist/queue.js

@@ -162,6 +162,15 @@ function acquireDrainLock(lock) {
         return null;
     }
 }
+/**
+ * A stable id for a queued turn: `<sessionId>:<transcript turn>` when both are known, else the
+ * queue line's own id (kept across retries, since a failed line stays in its file).
+ */
+export function turnRefOf(line) {
+    return line.obs.sessionId !== undefined && line.obs.turnRef !== undefined
+        ? `${line.obs.sessionId}:${line.obs.turnRef}`
+        : line.id;
+}
 /**
  * Observes queued lines, oldest file first, at most 50 per run, under the
  * drain lock. A line that observed is removed; one whose observe threw keeps
@@ -172,8 +181,9 @@ export async function drainQueue(deps) {
     const t0 = performance.now();
     const dir = queueDir(deps.config.home);
     const logBase = { event: 'drain', session: null, project: null };
-    const { embed, decide, write } = deps;
-    if (embed === undefined || decide === undefined || write === undefined) {
+    const { embed, decide, write, remote } = deps;
+    if (remote === undefined &&
+        (embed === undefined || decide === undefined || write === undefined)) {
         const remaining = countLines(dir);
         deps.log.write({
             ...logBase,
@@ -209,6 +219,7 @@ export async function drainQueue(deps) {
     let budget = DRAIN_MAX_PER_RUN;
     let consecutive = 0;
     let deadCount = 0;
+    let held = false;
     const deadIds = [];
     try {
         fs.writeSync(lock, `${process.pid}\n`);
@@ -244,19 +255,32 @@ export async function drainQueue(deps) {
                 }
                 budget--;
                 try {
-                    await observe(line.obs, line.scope, {
-                        store: deps.store,
-                        embed,
-                        decide,
-                        write,
-                        config: deps.config,
-                        now: deps.now?.() ?? new Date(),
-                        harness: 'claude-code',
-                    });
+                    if (remote !== undefined) {
+                        await remote.observe(line.obs, line.scope.projectId, turnRefOf(line));
+                    }
+                    else {
+                        await observe(line.obs, line.scope, {
+                            store: deps.store,
+                            embed: embed,
+                            decide: decide,
+                            write: write,
+                            config: deps.config,
+                            now: deps.now?.() ?? new Date(),
+                            harness: 'claude-code',
+                        });
+                    }
                     processed++;
                     consecutive = 0;
                 }
-                catch {
+                catch (e) {
+                    if (e?.holdQueue === true) {
+                        // The account cannot save right now (signed out, no plan, a limit, an outage): keep
+                        // this line and the rest exactly as they are and try again on a later drain.
+                        held = true;
+                        keep.push(raw);
+                        budget = 0;
+                        continue;
+                    }
                     failed++;
                     consecutive++;
                     const next = JSON.stringify({ ...line, attempts: line.attempts + 1 });
@@ -318,7 +342,7 @@ export async function drainQueue(deps) {
     const remaining = countLines(dir);
     deps.log.write({
         ...logBase,
-        outcome: 'ok',
+        outcome: held ? 'held' : 'ok',
         counts: { processed, failed, remaining },
         timings: { totalMs: performance.now() - t0 },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oortmem/claude-code",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Oort for Claude Code: hooks that recall and save memories, and transcript import.",
   "keywords": [
     "oort",
@@ -46,11 +46,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@oortmem/core": "0.1.0",
+    "@oortmem/core": "0.1.1",
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@oortmem/store-sqlite": "0.1.0",
+    "@oortmem/store-sqlite": "0.1.1",
     "vitest": "^5.0.5"
   },
   "scripts": {