oortmem 0.1.0 → 0.1.1

package/dist/commands/cloud.js

@@ -0,0 +1,263 @@
+import * as path from 'node:path';
+import { principalGrant } from '@oortmem/core';
+import { OortCloudError, cloudUrl, createCloudClient, readCloudSettings, writeCloudSettings, } from '../cloud.js';
+import { keyLookup } from '../credentials.js';
+import { uiFor } from '../ui.js';
+import { Refusal, confirm, toJson, withWired, writeOwnerOnly } from '../util.js';
+import { EXPORT_VERSION, decoded, scopeKey } from './export.js';
+/** One import request: at most this many memory lines and bytes (the API takes 1,000 and 10 MB). */
+export const IMPORT_CHUNK_LINES = 500;
+export const IMPORT_CHUNK_BYTES = 8 * 1024 * 1024;
+/** A client for this machine's Oort key, whichever store mode is set. */
+async function clientFor(ctx) {
+    const url = cloudUrl(ctx.io.env);
+    if ('error' in url)
+        throw new Refusal(url.error);
+    const key = await keyLookup(ctx.io.env, ctx.keychain.read)('oort');
+    if (key === undefined) {
+        throw new Refusal('Oort Cloud needs the Oort key: run `oort login` first.');
+    }
+    return createCloudClient({
+        url: url.url,
+        key: key.key,
+        ...(ctx.fetch !== undefined && { fetch: ctx.fetch }),
+    });
+}
+/** Every memory in the local store (all projects of this machine's principal), oldest first. */
+async function localExport(w, ctx) {
+    const s = w.scope;
+    const grant = principalGrant({ orgId: s.orgId, customerId: s.customerId, agentId: s.agentId });
+    const all = await w.store.list(grant, { validOnly: false });
+    all.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt) || (a.id < b.id ? -1 : 1));
+    const lines = [];
+    const scopes = new Map();
+    let withEmbedding = 0;
+    for (const m of all) {
+        const full = await decoded(m, w.store, grant, ctx);
+        if (full.embedding !== undefined && full.embedding.length === w.config.embed.dimension)
+            withEmbedding++;
+        scopes.set(scopeKey(full.scope), full.scope);
+        lines.push(JSON.stringify(toJson(full)));
+    }
+    const manifest = {
+        oort: 'export',
+        version: EXPORT_VERSION,
+        exportedAt: new Date().toISOString(),
+        memories: lines.length,
+        scopes: [...scopes.values()],
+    };
+    return { manifest, lines, withEmbedding };
+}
+/** Chunks of export lines, each within the line and byte caps. */
+function chunks(lines, from) {
+    const out = [];
+    let cur = [];
+    let bytes = 0;
+    let start = from;
+    for (let i = from; i < lines.length; i++) {
+        const line = lines[i];
+        const b = Buffer.byteLength(line) + 1;
+        if (cur.length > 0 && (cur.length >= IMPORT_CHUNK_LINES || bytes + b > IMPORT_CHUNK_BYTES)) {
+            out.push({ start, lines: cur });
+            cur = [];
+            bytes = 0;
+            start = i;
+        }
+        cur.push(line);
+        bytes += b;
+    }
+    if (cur.length > 0)
+        out.push({ start, lines: cur });
+    return out;
+}
+/**
+ * Uploads one chunk. The API imports at most 1,000 lines a call and answers `next` (an index into
+ * the posted lines) when it stopped early; the same lines are posted again with `from = next`
+ * until it is done. `progress` gets how many of the chunk's lines are in after each call.
+ */
+export async function uploadChunk(client, header, lines, progress) {
+    const body = [header, ...lines];
+    const total = { imported: 0, skipped: 0, reembedded: 0, calls: 0 };
+    let from = 0;
+    for (;;) {
+        const r = await client.importLines(body, from);
+        total.calls++;
+        total.imported += r.imported;
+        total.skipped += r.skipped;
+        total.reembedded += r.reembedded;
+        if (r.next === undefined) {
+            progress(lines.length);
+            return total;
+        }
+        // Line 0 is the manifest, so line `next` of the body is line `next - 1` of the chunk.
+        if (!Number.isInteger(r.next) || r.next <= Math.max(from, 1) || r.next > lines.length) {
+            throw new Refusal('Oort Cloud stopped making progress on the import; run it again later.');
+        }
+        progress(r.next - 1);
+        from = r.next;
+    }
+}
+const fingerprintOf = (lines) => {
+    const id = (l) => l === undefined ? '' : (JSON.parse(l).id ?? '');
+    return `${lines.length}:${id(lines[0])}:${id(lines.at(-1))}`;
+};
+/** `oort cloud use [--local]`: switch this machine's store. */
+export async function cloudUseCommand(opts, ctx) {
+    const home = (await withWired(ctx, async (w) => w.config.home));
+    const settings = readCloudSettings(home);
+    const ui = uiFor(ctx.io);
+    if (opts.local === true) {
+        writeCloudSettings(home, { ...settings, store: 'local' });
+        ctx.io.out(ui.header('cloud', 'local store'));
+        ctx.io.out('This machine now uses the local store. Memories already in Oort Cloud stay there; `oort cloud export` downloads them.\n');
+        return 0;
+    }
+    const client = await clientFor(ctx);
+    const me = await client.whoami();
+    const local = await withWired(ctx, async (w) => (await localExport(w, ctx)).lines.length);
+    writeCloudSettings(home, { ...settings, store: 'cloud' });
+    ctx.io.out(ui.header('cloud', 'Oort Cloud'));
+    ctx.io.out(ui.kv([
+        ['account', me.account],
+        ['plan', me.plan],
+        ['store', `Oort Cloud (${client.url}), stored in the EU`],
+    ]));
+    ctx.io.out(`\nHooks, MCP and the oort commands now read and save in Oort Cloud.\n` +
+        (local > 0
+            ? `${local} ${local === 1 ? 'memory stays' : 'memories stay'} in the local store until you run \`oort cloud import\`.\n`
+            : '') +
+        'Switch back any time with `oort cloud use --local`.\n');
+    return 0;
+}
+/** `oort cloud status [--json]` */
+export async function cloudStatusCommand(opts, ctx) {
+    return withWired(ctx, async (w) => {
+        const settings = readCloudSettings(w.config.home);
+        let account;
+        let stats;
+        try {
+            const client = await clientFor(ctx);
+            account = await client.whoami();
+            stats = (await client.stats());
+        }
+        catch (e) {
+            if (!(e instanceof Refusal))
+                throw e;
+            account = { error: e.message };
+        }
+        const out = {
+            store: settings.store,
+            url: (() => {
+                const u = cloudUrl(ctx.io.env);
+                return 'url' in u ? u.url : u.error;
+            })(),
+            account,
+            ...(stats !== undefined && { cloud: stats }),
+            ...(settings.import !== undefined && { import: settings.import }),
+        };
+        if (opts.json === true) {
+            ctx.io.out(`${JSON.stringify(out, null, 2)}\n`);
+            return 0;
+        }
+        const ui = uiFor(ctx.io);
+        const acct = 'error' in account
+            ? ui.yellow(String(account['error']))
+            : `${String(account['account'])} (${String(account['plan'])})`;
+        ctx.io.out(ui.header('cloud', settings.store === 'cloud' ? 'Oort Cloud' : 'local store'));
+        ctx.io.out(ui.kv([
+            ['store', settings.store === 'cloud' ? `Oort Cloud (${out.url})` : 'local (this machine)'],
+            ['account', acct],
+            ...(stats !== undefined
+                ? [['cloud memories', String(stats['memories'])]]
+                : []),
+            ...(settings.import !== undefined
+                ? [
+                    [
+                        'import',
+                        `${settings.import.done}/${settings.import.total} uploaded${settings.import.done < settings.import.total ? ' (run `oort cloud import` to resume)' : ''}`,
+                    ],
+                ]
+                : []),
+        ]));
+        return 0;
+    });
+}
+/** `oort cloud import [--dry-run] [--yes]`: uploads the local store, resumable and idempotent. */
+export async function cloudImportCommand(opts, ctx) {
+    return withWired(ctx, async (w) => {
+        const ui = uiFor(ctx.io);
+        const { manifest, lines, withEmbedding } = await localExport(w, ctx);
+        const settings = readCloudSettings(w.config.home);
+        const fingerprint = fingerprintOf(lines);
+        const resume = settings.import?.fingerprint === fingerprint
+            ? Math.min(settings.import.done, lines.length)
+            : 0;
+        const plan = chunks(lines, resume);
+        const bytes = lines.slice(resume).reduce((n, l) => n + Buffer.byteLength(l) + 1, 0);
+        ctx.io.out(ui.header('cloud import', `${lines.length} local memories`));
+        ctx.io.out(ui.kv([
+            ['to upload', `${lines.length - resume}${resume > 0 ? ` (resuming after ${resume})` : ''}`],
+            ['size', `${(bytes / (1024 * 1024)).toFixed(2)} MB in ${plan.length} requests`],
+            [
+                'embeddings',
+                `${withEmbedding} reused; ${lines.length - withEmbedding} re-embedded in the cloud (counted toward your Pro embed use)`,
+            ],
+        ]));
+        if (opts.dryRun === true || lines.length === resume) {
+            if (lines.length === resume && lines.length > 0)
+                ctx.io.out('Already uploaded.\n');
+            return 0;
+        }
+        const go = await confirm(ctx.io, `Upload ${lines.length - resume} memories to Oort Cloud (EU)?`, opts.yes === true, 'upload them');
+        if (!go) {
+            ctx.io.out('Nothing uploaded.\n');
+            return 0;
+        }
+        const client = w.cloud ?? (await clientFor(ctx));
+        const header = JSON.stringify(manifest);
+        let done = resume;
+        let imported = 0;
+        let skipped = 0;
+        let reembedded = 0;
+        for (const c of plan) {
+            const r = await uploadChunk(client, header, c.lines, (inChunk) => {
+                done = c.start + inChunk;
+                writeCloudSettings(w.config.home, {
+                    ...readCloudSettings(w.config.home),
+                    import: { fingerprint, done, total: lines.length, updatedAt: new Date().toISOString() },
+                });
+            });
+            imported += r.imported;
+            skipped += r.skipped;
+            reembedded += r.reembedded;
+            ctx.io.out(`  uploaded ${done}/${lines.length}\n`);
+        }
+        ctx.io.out(`${ui.ok('done')}: ${imported} imported, ${skipped} already in the cloud, ${reembedded} re-embedded.\n`);
+        if (w.mode !== 'cloud')
+            ctx.io.out('Run `oort cloud use` to start using them.\n');
+        return 0;
+    });
+}
+/** `oort cloud export [--out <file>] [--force]`: the whole cloud account in the v1 format. */
+export async function cloudExportCommand(opts, ctx) {
+    const client = await clientFor(ctx);
+    let data;
+    try {
+        data = await client.exportText();
+    }
+    catch (e) {
+        if (e instanceof OortCloudError)
+            throw e;
+        throw new Refusal('Oort Cloud export failed; try again.');
+    }
+    const memories = Math.max(0, data.split('\n').filter((l) => l.length > 0).length - 1);
+    if (opts.out === undefined)
+        ctx.io.out(data);
+    else {
+        const file = path.resolve(ctx.io.cwd, opts.out);
+        writeOwnerOnly(file, data, opts.force === true);
+        ctx.io.out(`Exported ${memories} memories from Oort Cloud to ${file}\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=cloud.js.map

package/dist/commands/consolidate.js

@@ -1,10 +1,13 @@
 import { filterFor } from '@oortmem/claude-code';
 import { consolidate } from '@oortmem/core';
 import { uiFor } from '../ui.js';
-import { scopeLabel, withWired } from '../util.js';
+import { Refusal, scopeLabel, withWired } from '../util.js';
 /** `oort consolidate`: expire, re-tier and evict the memories visible from the cwd. */
 export async function consolidateCommand(ctx) {
     return withWired(ctx, async (w) => {
+        if (w.mode === 'cloud') {
+            throw new Refusal('In cloud mode Oort Cloud consolidates your memories itself (daily).');
+        }
         const r = await consolidate(filterFor(w.scope), { store: w.store, config: w.config });
         const ui = uiFor(ctx.io);
         ctx.io.out(ui.header('consolidate', scopeLabel(w)));

package/dist/commands/doctor.d.ts

@@ -1,7 +1,7 @@
 import { type Ctx } from '../util.js';
 export type CheckStatus = 'ok' | 'warn' | 'fail' | 'info' | 'unknown';
 export interface Check {
-    group: 'keys' | 'hooks' | 'mcp' | 'store' | 'relay';
+    group: 'keys' | 'hooks' | 'mcp' | 'store' | 'relay' | 'cloud';
     name: string;
     status: CheckStatus;
     /** One line; never a key or a memory. */

package/dist/commands/doctor.js

@@ -6,6 +6,7 @@ import { HOSTS, HOST_LABEL, detectHosts, inspectHost } from '../connectors.js';
 import { ROLES, ROLE_VENDOR, keyLookup, routeFor } from '../credentials.js';
 import { describeProblem, inspectCredentialsFile } from '../credentials-file.js';
 import { PROVIDER_ENV } from '../keychain.js';
+import { OortCloudError, cloudUrl, createCloudClient, readCloudSettings } from '../cloud.js';
 import { RELAY_MODELS, relayUrl } from '../relay.js';
 import { uiFor } from '../ui.js';
 import { Refusal, echo, tilde, withWired } from '../util.js';
@@ -346,6 +347,76 @@ async function relayChecks(ctx, relayed) {
             },
     ];
 }
+/** Oort Cloud: which store this machine uses, and in cloud mode whether the account answers. */
+async function cloudChecks(ctx) {
+    const settings = readCloudSettings(resolveHome(ctx.io.env));
+    const u = cloudUrl(ctx.io.env);
+    if (settings.store !== 'cloud') {
+        return [
+            {
+                group: 'cloud',
+                name: 'store',
+                status: 'info',
+                detail: 'local store on this machine',
+                fix: 'oort cloud use, to keep memories in Oort Cloud (Oort Pro)',
+            },
+        ];
+    }
+    if ('error' in u) {
+        return [
+            {
+                group: 'cloud',
+                name: 'store',
+                status: 'fail',
+                detail: u.error,
+                fix: 'unset OORT_CLOUD_URL (or set it to an https URL, or http://localhost for wrangler dev)',
+            },
+        ];
+    }
+    const key = await keyLookup(ctx.io.env, ctx.keychain.read)('oort');
+    if (key === undefined) {
+        return [
+            {
+                group: 'cloud',
+                name: 'store',
+                status: 'fail',
+                detail: 'cloud mode is on, but there is no Oort key: hooks inject nothing and saves wait',
+                fix: 'oort login (or oort cloud use --local)',
+            },
+        ];
+    }
+    const client = createCloudClient({
+        url: u.url,
+        key: key.key,
+        timeoutMs: PROBE_TIMEOUT_MS,
+        ...(ctx.fetch !== undefined && { fetch: ctx.fetch }),
+    });
+    try {
+        const me = await client.whoami();
+        return [
+            {
+                group: 'cloud',
+                name: 'store',
+                status: 'ok',
+                detail: `Oort Cloud (${u.url}), account ${me.account}, plan ${me.plan}`,
+            },
+        ];
+    }
+    catch (e) {
+        const err = e instanceof OortCloudError ? e : new OortCloudError('network', 0);
+        return [
+            {
+                group: 'cloud',
+                name: 'store',
+                status: err.kind === 'network' || err.kind === 'busy' ? 'warn' : 'fail',
+                detail: err.message,
+                fix: err.kind === 'network' || err.kind === 'busy'
+                    ? 'check your network; saves wait in the local queue meanwhile'
+                    : 'oort login, or oort cloud use --local',
+            },
+        ];
+    }
+}
 const GLYPH = {
     ok: '✓',
     warn: '!',
@@ -381,6 +452,7 @@ export async function doctorCommand(opts, ctx) {
         ...mcpChecks(ctx, cmd),
         ...(await storeChecks(ctx)),
         ...(await relayChecks(ctx, keys.relayed)),
+        ...(await cloudChecks(ctx)),
     ];
     const ok = !checks.some((c) => c.status === 'fail');
     if (opts.json === true) {
@@ -390,7 +462,7 @@ export async function doctorCommand(opts, ctx) {
     const ui = uiFor(ctx.io);
     const problems = checks.filter((c) => c.status === 'warn' || c.status === 'fail').length;
     ctx.io.out(ui.header('doctor', problems === 0 ? 'no problems' : `${problems} to fix`));
-    for (const group of ['keys', 'hooks', 'mcp', 'store', 'relay']) {
+    for (const group of ['keys', 'hooks', 'mcp', 'store', 'relay', 'cloud']) {
         const rows = checks.filter((c) => c.group === group);
         ctx.io.out(`${ui.bold(group)}\n`);
         ctx.io.out(ui.kv(rows.flatMap((c) => [

package/dist/commands/export.d.ts

@@ -1,4 +1,4 @@
-import { type Scope } from '@oortmem/core';
+import { type Grant, type Memory, type MemoryStore, type Scope } from '@oortmem/core';
 import { type Ctx } from '../util.js';
 /** Version of the export format documented in docs/export-format.md. */
 export declare const EXPORT_VERSION = 1;
@@ -9,6 +9,9 @@ export interface ExportManifest {
     memories: number;
     scopes: Scope[];
 }
+/** A cold memory's main record has only its stub indexed; the cold copy holds the full text and embedding. */
+export declare function decoded(m: Memory, store: MemoryStore, grant: Grant, ctx: Ctx): Promise<Memory>;
+export declare const scopeKey: (s: Scope) => string;
 /**
  * `oort export [--out <file>]`: the v1 export format, a manifest line and one
  * JSON line per memory (every tier and validity state) visible from the cwd.

package/dist/commands/export.js

@@ -1,11 +1,11 @@
 import * as path from 'node:path';
 import { filterFor } from '@oortmem/claude-code';
 import { localGrant } from '@oortmem/core';
-import { shapeLinks, toJson, withWired, writeOwnerOnly } from '../util.js';
+import { cloudOf, shapeLinks, toJson, withWired, writeOwnerOnly } from '../util.js';
 /** Version of the export format documented in docs/export-format.md. */
 export const EXPORT_VERSION = 1;
 /** A cold memory's main record has only its stub indexed; the cold copy holds the full text and embedding. */
-async function decoded(m, store, grant, ctx) {
+export async function decoded(m, store, grant, ctx) {
     if (m.tier !== 'cold')
         return m;
     let blob;
@@ -28,13 +28,27 @@ async function decoded(m, store, grant, ctx) {
         ...(blob.embedding !== undefined && { embedding: blob.embedding }),
     };
 }
-const scopeKey = (s) => JSON.stringify(Object.entries(s).sort());
+export const scopeKey = (s) => JSON.stringify(Object.entries(s).sort());
 /**
  * `oort export [--out <file>]`: the v1 export format, a manifest line and one
  * JSON line per memory (every tier and validity state) visible from the cwd.
  */
 export async function exportCommand(opts, ctx) {
     return withWired(ctx, async (w) => {
+        const cloud = cloudOf(w);
+        if (cloud !== undefined) {
+            // The whole account, in the same v1 format: `oort cloud export` is how you leave the cloud.
+            const data = await cloud.exportText();
+            const memories = Math.max(0, data.split('\n').filter((l) => l.length > 0).length - 1);
+            if (opts.out === undefined)
+                ctx.io.out(data);
+            else {
+                const file = path.resolve(ctx.io.cwd, opts.out);
+                writeOwnerOnly(file, data, opts.force === true);
+                ctx.io.out(`Exported ${memories} memories from Oort Cloud to ${file}\n`);
+            }
+            return 0;
+        }
         const filter = filterFor(w.scope);
         const grant = localGrant(filter);
         const listed = await w.store.list(grant, { validOnly: false });

package/dist/commands/forget.js

@@ -1,15 +1,22 @@
 import { filterFor, grantFor } from '@oortmem/claude-code';
-import { clip, confirm, findMemory, short, withWired } from '../util.js';
+import { findCloudMemory } from '../cloud.js';
+import { clip, cloudOf, confirm, findMemory, short, withWired } from '../util.js';
 /** `oort forget <id> [--yes]`: deletes a memory everywhere (main record and cold copy). */
 export async function forgetCommand(id, opts, ctx) {
     return withWired(ctx, async (w) => {
-        const m = await findMemory(w.store, filterFor(w.scope), id);
+        const cloud = cloudOf(w);
+        const m = cloud !== undefined
+            ? await findCloudMemory(cloud, id)
+            : await findMemory(w.store, filterFor(w.scope), id);
         const ok = await confirm(ctx.io, `Forget ${short(m.id)} "${clip(m.text, 60)}"?`, opts.yes === true, 'forget it');
         if (!ok) {
             ctx.io.out('Kept.\n');
             return 0;
         }
-        await w.store.forget(grantFor(w.scope), m.id);
+        if (cloud !== undefined)
+            await cloud.forget(m.id);
+        else
+            await w.store.forget(grantFor(w.scope), m.id);
         ctx.io.out(`Forgot ${m.id}.\n`);
         return 0;
     });

package/dist/commands/hook.js

@@ -1,5 +1,6 @@
 import { HOOK_TIMEOUTS, createHookLogger, runHook } from '@oortmem/claude-code';
 import { resolveHome } from '@oortmem/core';
+import { cloudRemote } from '../cloud-remote.js';
 import { echo } from '../util.js';
 export const HOOK_COMMAND_EVENTS = [
     'UserPromptSubmit',
@@ -105,6 +106,8 @@ export async function hookCommand(event, ctx) {
             const wireStart = performance.now();
             w = await ctx.wire(inputCwd(stdin) ?? io.cwd, {
                 env: io.env,
+                // Oort Cloud: a recall must answer inside the hook's own budget.
+                cloudTimeoutMs: event === 'drain' ? 30_000 : 1400,
                 // The drain serves every project's queue: home config only, whatever lies above OORT_HOME.
                 ...(event === 'drain' ? { projectConfig: false } : { busyTimeoutMs: HOOK_BUSY_TIMEOUT_MS }),
                 roles: HOOK_ROLES[event],
@@ -114,7 +117,7 @@ export async function hookCommand(event, ctx) {
             for (const warning of w.warnings)
                 log(ctx, w, event, `config:${warning.code}`);
             const home = w.config.home;
-            const { harnessLog, unavailable: _u, close: _c, scope: _s, warnings: _w, store, ...engine } = w;
+            const { harnessLog, unavailable: _u, close: _c, scope: _s, warnings: _w, store, mode: _m, cloud: _cl, cloudProblem: _cp, ...engine } = w;
             // The scope is left out: each handler derives it from the session's cwd.
             const out = await runHook(event, stdin, {
                 ...engine,
@@ -125,6 +128,7 @@ export async function hookCommand(event, ctx) {
                 // The drain runs in the home directory, so it resolves the home config only:
                 // project config never affects the write path.
                 spawnDrain: () => io.spawnDrain(home),
+                ...(w.mode === 'cloud' && { remote: cloudRemote(w.cloud, w.cloudProblem) }),
             });
             stdout = out.stdout;
             // The drain is detached and nothing waits on it, so it closes the store cleanly.

package/dist/commands/import.js

@@ -20,6 +20,9 @@ export async function importCommand(opts, ctx) {
     const home = ctx.io.env['HOME'] || os.homedir();
     const projectsDir = path.resolve(ctx.io.cwd, opts.projectsDir ?? path.join(home, '.claude', 'projects'));
     return withWired(ctx, async (w) => {
+        if (w.mode === 'cloud') {
+            throw new Refusal('transcript import writes to the local store: run it with `oort cloud use --local`, then `oort cloud import`.');
+        }
         const deps = { ...w, log: w.harnessLog };
         const base = {
             projectsDir,

package/dist/commands/inspect.js

@@ -1,7 +1,8 @@
 import { filterFor } from '@oortmem/claude-code';
 import { activation, localGrant, } from '@oortmem/core';
+import { OortCloudError, findCloudMemory } from '../cloud.js';
 import { uiFor } from '../ui.js';
-import { Refusal, echo, age, clip, findMemory, fixed, scopeLabel, shapeLinks, short, withoutEmbedding, withWired, } from '../util.js';
+import { Refusal, cloudOf, echo, age, clip, findMemory, fixed, scopeLabel, shapeLinks, short, withoutEmbedding, withWired, } from '../util.js';
 const link = (m) => ({
     id: m.id,
     validFrom: m.validFrom,
@@ -40,6 +41,34 @@ export async function supersedeChain(store, m, filter) {
     await walk(m.supersededBy, (x) => x.supersededBy, (l) => forward.push(l));
     return { links: [...back, link(m), ...forward], hidden };
 }
+/** The supersede chain through `m` in Oort Cloud: links the account cannot read count as hidden. */
+async function cloudChain(client, m) {
+    const seen = new Set([m.id]);
+    let hidden = 0;
+    const walk = async (start, next, add) => {
+        for (let id = start; id !== null && !seen.has(id);) {
+            seen.add(id);
+            let x;
+            try {
+                x = (await client.get(id));
+            }
+            catch (e) {
+                if (e instanceof OortCloudError && e.kind === 'not-found') {
+                    hidden++;
+                    break;
+                }
+                throw e;
+            }
+            add(link(x));
+            id = next(x);
+        }
+    };
+    const back = [];
+    const forward = [];
+    await walk(m.supersedes, (x) => x.supersedes, (l) => back.unshift(l));
+    await walk(m.supersededBy, (x) => x.supersededBy, (l) => forward.push(l));
+    return { links: [...back, link(m), ...forward], hidden };
+}
 function limitOf(raw) {
     if (raw === undefined)
         return 50;
@@ -54,10 +83,19 @@ export async function inspectCommand(id, opts, ctx) {
     return withWired(ctx, async (w) => {
         const now = new Date();
         const filter = filterFor(w.scope);
+        const cloud = cloudOf(w);
+        const project = w.scope.projectId;
         if (id === undefined) {
-            const current = (await w.store.list(localGrant(filter))).slice(0, limit);
+            const current = cloud !== undefined
+                ? (await cloud.list({
+                    ...(project !== undefined && { project }),
+                    limit: Math.min(limit, 100),
+                })).memories
+                : (await w.store.list(localGrant(filter))).slice(0, limit);
             if (opts.json === true) {
-                const shaped = await Promise.all(current.map((m) => shapeLinks(w.store, filter, m)));
+                const shaped = cloud !== undefined
+                    ? current
+                    : await Promise.all(current.map((m) => shapeLinks(w.store, filter, m)));
                 ctx.io.out(`${JSON.stringify(shaped.map(withoutEmbedding), null, 2)}\n`);
                 return 0;
             }
@@ -75,10 +113,12 @@ export async function inspectCommand(id, opts, ctx) {
             ctx.io.out(ui.table(['id', 'type', 'tier', 'activation', 'age', 'text'], rows));
             return 0;
         }
-        const m = await findMemory(w.store, filter, id);
-        const { links: chain, hidden } = await supersedeChain(w.store, m, filter);
+        const m = cloud !== undefined
+            ? (await findCloudMemory(cloud, id))
+            : await findMemory(w.store, filter, id);
+        const { links: chain, hidden } = cloud !== undefined ? await cloudChain(cloud, m) : await supersedeChain(w.store, m, filter);
         if (opts.json === true) {
-            const memory = withoutEmbedding(await shapeLinks(w.store, filter, m));
+            const memory = withoutEmbedding(cloud !== undefined ? m : await shapeLinks(w.store, filter, m));
             const out = { memory, chain, hiddenLinks: hidden };
             ctx.io.out(`${JSON.stringify(out, null, 2)}\n`);
             return 0;

package/dist/commands/observe.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { observe, scrubObservation } from '@oortmem/core';
-import { Refusal, writePath, withWired } from '../util.js';
+import { Refusal, cloudOf, writePath, withWired } from '../util.js';
 const ObservationInput = z.strictObject({
     userText: z.string(),
     assistantText: z.string(),
@@ -59,6 +59,21 @@ export async function observeCommand(opts, ctx) {
         return 0;
     }
     return withWired(ctx, async (w) => {
+        const cloud = cloudOf(w);
+        if (cloud !== undefined) {
+            const result = await cloud.observe({
+                ...(w.scope.projectId !== undefined && { project: w.scope.projectId }),
+                observation: {
+                    user: obs.userText,
+                    assistant: obs.assistantText,
+                    at: obs.at,
+                    ...(obs.sessionId !== undefined && { session: obs.sessionId }),
+                    ...(obs.toolSummaries.length > 0 && { tools: obs.toolSummaries }),
+                },
+            });
+            ctx.io.out(`${JSON.stringify(result, null, 2)}\n`);
+            return 0;
+        }
         const adapters = writePath(w, 'oort observe');
         const result = await observe(obs, w.scope, {
             store: w.store,

package/dist/commands/pin.js

@@ -1,8 +1,20 @@
 import { filterFor, grantFor } from '@oortmem/claude-code';
-import { findMemory, withWired } from '../util.js';
+import { findCloudMemory } from '../cloud.js';
+import { cloudOf, findMemory, withWired } from '../util.js';
 /** `oort pin <id>` / `oort unpin <id>`: consolidation never sends a pinned memory to cold. */
 export async function pinCommand(id, pinned, ctx) {
     return withWired(ctx, async (w) => {
+        const cloud = cloudOf(w);
+        if (cloud !== undefined) {
+            const c = await findCloudMemory(cloud, id);
+            if (c.pinned === pinned) {
+                ctx.io.out(`${c.id} is already ${pinned ? 'pinned' : 'unpinned'}.\n`);
+                return 0;
+            }
+            await cloud.pin(c.id, pinned);
+            ctx.io.out(`${pinned ? 'Pinned' : 'Unpinned'} ${c.id}.\n`);
+            return 0;
+        }
         const m = await findMemory(w.store, filterFor(w.scope), id);
         if (m.pinned === pinned) {
             ctx.io.out(`${m.id} is already ${pinned ? 'pinned' : 'unpinned'}.\n`);