oortmem 0.1.0 → 0.1.1

package/dist/commands/recall.js

@@ -1,13 +1,22 @@
 import { filterFor } from '@oortmem/claude-code';
 import { formatForInjection, recall } from '@oortmem/core';
 import { uiFor } from '../ui.js';
-import { Refusal, degradedHint, scopeLabel, shapeLinks, withoutEmbedding, withWired, } from '../util.js';
+import { Refusal, cloudOf, degradedHint, scopeLabel, shapeLinks, withoutEmbedding, withWired, } from '../util.js';
 /** Recall for the cwd's project plus global memories; lexical-only without a Voyage key. */
 export async function runRecall(w, text, asOf, now) {
     if (asOf !== undefined && Number.isNaN(Date.parse(asOf))) {
         // The value is not echoed: it is free text the user typed.
         throw new Refusal('--as-of is not an ISO date or timestamp.');
     }
+    const cloud = cloudOf(w);
+    if (cloud !== undefined) {
+        return cloud.recall({
+            text,
+            ...(w.scope.projectId !== undefined && { project: w.scope.projectId }),
+            ...(asOf !== undefined && { asOf }),
+            k: 10,
+        });
+    }
     return recall({ text, scope: filterFor(w.scope), ...(asOf !== undefined && { asOf }) }, {
         store: w.store,
         config: w.config,
@@ -24,7 +33,10 @@ export async function recallCommand(text, opts, ctx) {
         degradedHint(ctx.io, w, result.degraded);
         if (opts.json === true) {
             const filter = filterFor(w.scope);
-            const shaped = await Promise.all(result.memories.map((m) => shapeLinks(w.store, filter, m)));
+            // Cloud memories arrive already shaped for this account.
+            const shaped = w.mode === 'cloud'
+                ? result.memories
+                : await Promise.all(result.memories.map((m) => shapeLinks(w.store, filter, m)));
             const plain = { ...result, memories: shaped.map(withoutEmbedding) };
             ctx.io.out(`${JSON.stringify(plain, null, 2)}\n`);
         }

package/dist/commands/stats.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { filterFor, queueDir } from '@oortmem/claude-code';
 import { isCurrent, localGrant } from '@oortmem/core';
 import { uiFor } from '../ui.js';
-import { scopeLabel, withWired } from '../util.js';
+import { cloudOf, scopeLabel, withWired } from '../util.js';
 const size = (file) => {
     try {
         return fs.statSync(file).size;
@@ -58,6 +58,36 @@ const mb = (bytes) => `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
 /** `oort stats [--json]`: counts for the memories visible from the cwd, and on-disk sizes. */
 export async function statsCommand(opts, ctx) {
     return withWired(ctx, async (w) => {
+        const cloud = cloudOf(w);
+        if (cloud !== undefined) {
+            const c = await cloud.stats();
+            const queue = queueDir(w.config.home);
+            const out = {
+                store: 'cloud',
+                url: cloud.url,
+                ...c,
+                queue: { pending: jsonlLines(queue), deadLetters: jsonlLines(path.join(queue, 'dead')) },
+            };
+            if (opts.json === true) {
+                ctx.io.out(`${JSON.stringify(out, null, 2)}\n`);
+                return 0;
+            }
+            const ui = uiFor(ctx.io);
+            const t = (tier) => `${ui.tierName(tier)} ${c.tiers[tier]}`;
+            ctx.io.out(ui.header('stats', 'Oort Cloud'));
+            ctx.io.out(ui.kv([
+                ['store', `Oort Cloud (${cloud.url})`],
+                ['memories', String(c.memories)],
+                ['tiers', `${t('hot')}, ${t('warm')}, ${t('cold')}`],
+                ['database', mb(c.databaseBytes)],
+                ['consolidated', c.lastConsolidatedAt ?? 'not yet'],
+                [
+                    'queue',
+                    `${out.queue.pending} pending upload, ${out.queue.deadLetters} dead-lettered (this machine)`,
+                ],
+            ]));
+            return 0;
+        }
         const now = new Date();
         const all = await w.store.list(localGrant(filterFor(w.scope)), { validOnly: false });
         const tiers = { hot: 0, warm: 0, cold: 0 };

package/dist/mcp.d.ts

@@ -1,5 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { type MemoryBackend } from '@oortmem/mcp';
+import { type CloudClient } from './cloud.js';
 import type { Wired } from './wire.js';
 /**
  * `oort mcp`: the shared Oort tool set (`@oortmem/mcp`) over a local store. One server
@@ -13,5 +14,13 @@ export interface OortServerDeps {
 }
 /** The local store as an MCP memory backend. */
 export declare function localBackend(deps: OortServerDeps): MemoryBackend;
+/**
+ * Oort Cloud as an MCP memory backend: the same seven tools, answered by the API for this
+ * machine's project (plus account-wide memories). Recall goes through `runRecall`, which already
+ * calls the cloud in cloud mode.
+ */
+export declare function cloudBackend(deps: OortServerDeps & {
+    client: CloudClient;
+}): MemoryBackend;
 /** A new server instance with the seven tools; `serveStdio` calls this once per connection. */
 export declare function createOortServer(deps: OortServerDeps): McpServer;

package/dist/mcp.js

@@ -4,6 +4,7 @@ import { VERSION, activation, isCurrent, scrub, localGrant } from '@oortmem/core
 import { supersedeChain } from './commands/inspect.js';
 import { runRecall } from './commands/recall.js';
 import { rememberFacts } from './remember.js';
+import { OortCloudError, findCloudMemory } from './cloud.js';
 import { Refusal, findMemory, fixed } from './util.js';
 /**
  * `oort mcp`: the shared Oort tool set (`@oortmem/mcp`) over a local store. One server
@@ -54,7 +55,7 @@ export function localBackend(deps) {
                     why: why.join(', ') || 'activation',
                 };
             });
-            const lexicalOnly = w.embed === undefined || w.rerank === undefined;
+            const lexicalOnly = w.mode !== 'cloud' && (w.embed === undefined || w.rerank === undefined);
             const refused = w.relayErrors?.at(-1);
             return {
                 memories,
@@ -157,10 +158,142 @@ export function localBackend(deps) {
         },
     };
 }
+/**
+ * Oort Cloud as an MCP memory backend: the same seven tools, answered by the API for this
+ * machine's project (plus account-wide memories). Recall goes through `runRecall`, which already
+ * calls the cloud in cloud mode.
+ */
+export function cloudBackend(deps) {
+    const w = deps.wired;
+    const client = deps.client;
+    const now = deps.now ?? (() => new Date());
+    const project = w.scope.projectId;
+    const local = localBackend(deps);
+    return {
+        recall: local.recall,
+        async remember({ facts, type }) {
+            // The same turn the local engine observes for a fact, sent to the cloud's write path.
+            const hint = type === undefined ? '' : ` (a ${type} fact)`;
+            const results = [];
+            for (const [i, fact] of facts.entries()) {
+                const r = await client.observe({
+                    ...(project !== undefined && { project }),
+                    observation: {
+                        user: `Remember this${hint}: ${fact}`,
+                        assistant: `Noted: ${fact}`,
+                        at: now().toISOString(),
+                    },
+                });
+                const first = r.memories[0];
+                results.push({
+                    fact: i,
+                    outcome: r.outcome,
+                    ...(first?.id !== undefined && { id: first.id }),
+                    ...(r.outcome === 'skipped' && { reason: 'not durable' }),
+                });
+            }
+            return { results };
+        },
+        async forget({ id }) {
+            const m = await findCloudMemory(client, id);
+            await client.forget(m.id);
+            return { forgotten: m.id };
+        },
+        async pin({ id, pinned }) {
+            const m = await findCloudMemory(client, id);
+            if (m.pinned === pinned)
+                return { id: m.id, pinned, changed: false };
+            await client.pin(m.id, pinned);
+            return { id: m.id, pinned, changed: true };
+        },
+        async explain({ id }) {
+            const at = now();
+            const m = (await findCloudMemory(client, id));
+            const chain = [];
+            let hidden = 0;
+            for (const linkId of [m.supersedes, m.supersededBy]) {
+                if (linkId === null)
+                    continue;
+                try {
+                    const l = await client.get(linkId);
+                    chain.push({
+                        id: l.id,
+                        text: clean(l.text),
+                        valid_from: l.validFrom,
+                        valid_to: l.validTo,
+                        end_reason: l.endReason,
+                    });
+                }
+                catch (e) {
+                    if (e instanceof OortCloudError && e.kind === 'not-found')
+                        hidden++;
+                    else
+                        throw e;
+                }
+            }
+            return {
+                memory: {
+                    id: m.id,
+                    text: clean(m.text),
+                    type: m.type,
+                    tier: m.tier,
+                    pinned: m.pinned,
+                    status: status(m, at),
+                    valid_from: m.validFrom,
+                    valid_to: m.validTo,
+                    salience: m.salience,
+                    activation: Number(fixed(activation(m.accessLog, m.salience, at, w.config.activation))),
+                    source: m.source.harness,
+                    created_at: m.createdAt,
+                },
+                decisions: m.source.decisions,
+                chain,
+                ...(hidden > 0 && { hidden_links: hidden }),
+            };
+        },
+        async listRecent({ since, limit }) {
+            const at = now();
+            const from = since === undefined ? -Infinity : Date.parse(since);
+            const r = await client.list({ ...(project !== undefined && { project }), limit: 100 });
+            const memories = r.memories
+                .filter((m) => Date.parse(m.updatedAt) >= from)
+                .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
+                .slice(0, limit)
+                .map((m) => ({
+                id: m.id,
+                text: clean(m.text),
+                type: m.type,
+                tier: m.tier,
+                status: status(m, at),
+                valid_from: m.validFrom,
+                updated_at: m.updatedAt,
+            }));
+            return { memories };
+        },
+        async whoami() {
+            const me = await client.whoami();
+            return {
+                mode: 'cloud',
+                account: me.account,
+                plan: me.plan,
+                note: 'Memories live in Oort Cloud (EU) for this account.',
+                project: project ?? null,
+                scope: project === undefined ? 'global' : 'project, plus global memories',
+                version: VERSION,
+            };
+        },
+    };
+}
 /** A new server instance with the seven tools; `serveStdio` calls this once per connection. */
 export function createOortServer(deps) {
+    const w = deps.wired;
+    if (w.mode === 'cloud' && w.cloud === undefined) {
+        throw new Refusal(w.cloudProblem ?? 'Oort Cloud is not set up.');
+    }
     return createMcpServer({
-        backend: localBackend(deps),
+        backend: w.mode === 'cloud' && w.cloud !== undefined
+            ? cloudBackend({ ...deps, client: w.cloud })
+            : localBackend(deps),
         version: VERSION,
         isRefusal: (e) => e instanceof Refusal,
     });

package/dist/program.js

@@ -21,6 +21,7 @@ import { recallCommand } from './commands/recall.js';
 import { setupCommand } from './commands/setup.js';
 import { statsCommand } from './commands/stats.js';
 import { keychainFor } from './keychain.js';
+import { cloudExportCommand, cloudImportCommand, cloudStatusCommand, cloudUseCommand, } from './commands/cloud.js';
 import { Refusal, echo } from './util.js';
 import { wire as defaultWire } from './wire.js';
 function program(ctx, setCode) {
@@ -138,6 +139,31 @@ function program(ctx, setCode) {
         .command('unlink')
         .description("remove this repository's binding (back to the derived id)")
         .action(run(() => projectUnlinkCommand(ctx)));
+    const cloud = p
+        .command('cloud')
+        .description('Oort Cloud (Oort Pro): keep memories in your account instead of on this machine');
+    cloud
+        .command('use')
+        .description('use Oort Cloud for hooks, MCP and every command (needs oort login and Pro)')
+        .option('--local', 'switch back to the local store on this machine')
+        .action(run((o) => cloudUseCommand(o, ctx)));
+    cloud
+        .command('status')
+        .description('which store this machine uses, the account, and import progress')
+        .option('--json', 'print JSON')
+        .action(run((o) => cloudStatusCommand(o, ctx)));
+    cloud
+        .command('import')
+        .description('upload the local store to Oort Cloud (resumable; safe to run again)')
+        .option('--dry-run', 'show what would be uploaded and stop')
+        .option('--yes', 'do not ask before uploading')
+        .action(run((o) => cloudImportCommand(o, ctx)));
+    cloud
+        .command('export')
+        .description('download every memory in your Oort Cloud account (v1 export format)')
+        .option('--out <file>', 'write to a new file (0600) instead of stdout')
+        .option('--force', 'with --out, overwrite an existing file (never a symlink)')
+        .action(run((o) => cloudExportCommand(o, ctx)));
     p.command('doctor')
         .description('check keys, hooks, MCP connectors, the store and the relay, with a fix per problem')
         .option('--json', 'print every check as JSON')

package/dist/util.d.ts

@@ -2,6 +2,7 @@ import { type DecisionController, type Embedder, type Memory, type MemoryStore,
 import type { LoginDeps } from './commands/login.js';
 import type { Io } from './io.js';
 import type { Keychain } from './keychain.js';
+import type { CloudClient } from './cloud.js';
 import type { WireFn, Wired } from './wire.js';
 /**
  * A user argument as echoed in a message: scrubbed, clipped to 24 characters,
@@ -24,6 +25,11 @@ export interface Ctx {
 }
 /** The scope a command reads, for header lines: `project <id>` or `global`. */
 export declare function scopeLabel(w: Pick<Wired, 'scope'>): string;
+/**
+ * The Oort Cloud client when this machine uses the cloud store, undefined in local mode. In cloud
+ * mode without a client (no Oort key, a bad URL) it refuses with the reason.
+ */
+export declare function cloudOf(w: Wired): CloudClient | undefined;
 /** Wires for the cwd, runs `fn`, and always closes the store. */
 export declare function withWired<T>(ctx: Ctx, fn: (w: Wired) => Promise<T>): Promise<T>;
 /**

package/dist/util.js

@@ -21,6 +21,17 @@ export class Refusal extends Error {
 export function scopeLabel(w) {
     return w.scope.projectId === undefined ? 'global' : `project ${w.scope.projectId}`;
 }
+/**
+ * The Oort Cloud client when this machine uses the cloud store, undefined in local mode. In cloud
+ * mode without a client (no Oort key, a bad URL) it refuses with the reason.
+ */
+export function cloudOf(w) {
+    if (w.mode !== 'cloud')
+        return undefined;
+    if (w.cloud === undefined)
+        throw new Refusal(w.cloudProblem ?? 'Oort Cloud is not set up.');
+    return w.cloud;
+}
 /** Wires for the cwd, runs `fn`, and always closes the store. */
 export async function withWired(ctx, fn) {
     const w = await ctx.wire(ctx.io.cwd, { env: ctx.io.env });

package/dist/wire.d.ts

@@ -4,9 +4,19 @@ import type { Env } from './io.js';
 import { type AdapterRole, type RouteSummary } from './credentials.js';
 import { type KeychainReader } from './keychain.js';
 import { type OortRelayError } from './relay.js';
+import { type CloudClient } from './cloud.js';
 export type { AdapterRole } from './credentials.js';
 export interface Wired {
     config: ResolvedConfig;
+    /**
+     * Which store this machine uses (`~/.oort/cloud.json`). In `cloud` mode memories live in Oort
+     * Cloud: `cloud` is the API client and no vendor adapter is loaded (the cloud calls the models).
+     * The local store still holds the hooks' cursors and queue.
+     */
+    mode?: 'local' | 'cloud';
+    cloud?: CloudClient;
+    /** Why cloud mode has no client (no Oort key, a bad OORT_CLOUD_URL). */
+    cloudProblem?: string;
     scope: Scope;
     store: MemoryStore;
     embed?: Embedder;
@@ -32,7 +42,7 @@ export interface Wired {
     close(): Promise<void>;
 }
 export interface WireWarning {
-    code: 'embed-dimension-ignored' | 'project-id-untrusted' | 'keychain-unreadable';
+    code: 'embed-dimension-ignored' | 'project-id-untrusted' | 'keychain-unreadable' | 'cloud-unavailable';
     /** One line for stderr; holds config values only. */
     message: string;
 }
@@ -54,6 +64,8 @@ export interface WireOptions {
      * so it neither reads the TypeSafe and Anthropic keys nor imports their SDKs (CON-57).
      */
     roles?: readonly AdapterRole[];
+    /** Per-request timeout for the Oort Cloud client (the hooks pass their budget). */
+    cloudTimeoutMs?: number;
 }
 export type WireFn = (cwd: string, opts?: WireOptions) => Promise<Wired>;
 /**

package/dist/wire.js

@@ -8,6 +8,7 @@ import { diskEmbeddingCache } from './embed-cache-disk.js';
 import { createKeychain } from './keychain.js';
 import { RELAY_MODELS, RELAY_PATHS, relayUrl, viaRelay } from './relay.js';
 import { echo } from './util.js';
+import { cloudUrl, createCloudClient, readCloudSettings } from './cloud.js';
 const EMBED = {
     role: 'embed',
     configKey: 'embed',
@@ -179,6 +180,29 @@ export const wire = async (cwd, opts = {}) => {
         warnings,
         close: () => store.close(),
     };
+    const settings = readCloudSettings(config.home);
+    if (settings.store === 'cloud') {
+        out.mode = 'cloud';
+        const url = cloudUrl(env);
+        const key = await lookup('oort');
+        if ('error' in url)
+            out.cloudProblem = url.error;
+        else if (key === undefined)
+            out.cloudProblem =
+                'cloud mode needs the Oort key: run `oort login` (or `oort cloud use --local`).';
+        else
+            out.cloud = createCloudClient({
+                url: url.url,
+                key: key.key,
+                ...fetchOpt,
+                ...(opts.cloudTimeoutMs !== undefined && { timeoutMs: opts.cloudTimeoutMs }),
+            });
+        if (out.cloudProblem !== undefined)
+            warnings.push({ code: 'cloud-unavailable', message: out.cloudProblem });
+        // The cloud runs the models with Oort's keys: no vendor adapter, no vendor key read.
+        return out;
+    }
+    out.mode = 'local';
     const want = new Set(opts.roles ?? ROLES);
     // The selected adapters load in parallel; key reads are cached per provider, so a shared key
     // (Voyage for embed and rerank) is still read once.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oortmem",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Oort: memory for AI coding agents. The oort command line, MCP server and agent connectors.",
   "keywords": [
     "oort",
@@ -42,14 +42,14 @@
   "dependencies": {
     "@clack/prompts": "1.8.1",
     "@modelcontextprotocol/server": "2.4.0",
-    "@oortmem/claude-code": "0.1.0",
-    "@oortmem/core": "0.1.0",
-    "@oortmem/decide-jev": "0.1.0",
-    "@oortmem/embed-voyage": "0.1.0",
-    "@oortmem/mcp": "0.1.0",
-    "@oortmem/rerank-voyage": "0.1.0",
-    "@oortmem/store-sqlite": "0.1.0",
-    "@oortmem/writer": "0.1.0",
+    "@oortmem/claude-code": "0.1.1",
+    "@oortmem/core": "0.1.1",
+    "@oortmem/decide-jev": "0.1.1",
+    "@oortmem/embed-voyage": "0.1.1",
+    "@oortmem/mcp": "0.1.1",
+    "@oortmem/rerank-voyage": "0.1.1",
+    "@oortmem/store-sqlite": "0.1.1",
+    "@oortmem/writer": "0.1.1",
     "commander": "15.0.0",
     "jsonc-parser": "3.3.1",
     "picocolors": "1.1.1",