@pugi/cli 0.1.0-beta.25 → 0.1.0-beta.27

package/dist/runtime/commands/memory.js

@@ -0,0 +1,508 @@
+/**
+ * `pugi memory` — operator surface for the persona-memory layer
+ * (ADR-0063 Day 4).
+ *
+ * Subcommands:
+ *
+ *   pugi memory list [--persona <slug>] [--kind <kind>] [--limit <n>]
+ *     List memories for the current tenant — recency-first. Renders a
+ *     table with TTL countdown.
+ *
+ *   pugi memory recall <query> [--persona <slug>] [--top-k <n>]
+ *     Hybrid recall (vector + BM25 + recency) for one persona.
+ *
+ *   pugi memory write <kind> <content> [--persona <slug>] [--forget-after <iso>]
+ *     Persist a new memory. Queues locally + retries on next sync when
+ *     the admin-api is unreachable.
+ *
+ *   pugi memory forget <id>
+ *     Hard-delete one memory by id.
+ *
+ *   pugi memory sync
+ *     Push the local pending-write queue to the admin-api. Idempotent:
+ *     successful ops are dropped from the queue, failed ops stay queued.
+ *
+ * Auth surface: the same `resolveActiveCredential` flow every other
+ * pugi command uses — bearer token + apiUrl from `~/.pugi/credentials.json`.
+ * The admin-api enforces the tenant boundary via `BridgeOrJwtGuard` +
+ * `prisma.withTenant`.
+ *
+ * Feature flag: the admin-api side honours `PERSONA_MEMORY_ENABLED` and
+ * returns HTTP 503 `{error: feature_disabled}` until the flag is
+ * flipped. The CLI surfaces that response verbatim so the operator
+ * sees the actual gate.
+ */
+import { request } from 'undici';
+import { resolveActiveCredential } from '../../core/credentials.js';
+import { PERSONA_MEMORY_KINDS, countPending, defaultQueuePath, enqueueMemoryOp, readMemoryQueue, rewriteMemoryQueue, } from '../../core/memory-sync/queue.js';
+const SUB_USAGE = [
+    'pugi memory list   [--persona <slug>] [--kind <k>] [--limit <n>]',
+    'pugi memory recall <query> [--persona <slug>] [--top-k <n>]',
+    'pugi memory write  <kind> <content> [--persona <slug>] [--forget-after <iso>]',
+    'pugi memory forget <id>',
+    'pugi memory sync',
+].join('\n  ');
+const DEFAULT_PERSONA = 'mira';
+/** Single CLI entry — top-level `pugi memory` AND the in-REPL `/memory` slash both call this. */
+export async function runMemoryCommand(args, ctx) {
+    const sub = (args[0] ?? '').toLowerCase();
+    const tail = args.slice(1);
+    switch (sub) {
+        case '':
+        case '-h':
+        case '--help':
+            return printUsage(ctx);
+        case 'list':
+            return runList(tail, ctx);
+        case 'recall':
+            return runRecall(tail, ctx);
+        case 'write':
+        case 'remember':
+            return runWrite(tail, ctx);
+        case 'forget':
+        case 'delete':
+            return runForget(tail, ctx);
+        case 'sync':
+            return runSync(ctx);
+        default:
+            ctx.writeOutput({ command: 'memory', sub, status: 'unknown_sub' }, `Unknown sub-command "${sub}".\nUsage:\n  ${SUB_USAGE}`);
+            return { command: 'memory', sub, status: 'unknown_sub' };
+    }
+}
+function printUsage(ctx) {
+    ctx.writeOutput({ command: 'memory', sub: 'help', usage: SUB_USAGE }, `pugi memory — persona-memory operator surface (ADR-0063).\nUsage:\n  ${SUB_USAGE}`);
+    return { command: 'memory', sub: 'help', status: 'listed' };
+}
+// ===========================================================================
+// list
+// ===========================================================================
+async function runList(args, ctx) {
+    const flags = parseFlags(args);
+    const cred = resolveActiveCredential();
+    if (!cred)
+        return emitUnauth('list', ctx);
+    const url = new URL(`${stripTrailing(cred.apiUrl)}/api/persona-memory`);
+    if (flags.persona)
+        url.searchParams.set('personaSlug', flags.persona);
+    if (flags.kind)
+        url.searchParams.set('kind', flags.kind);
+    if (flags.limit)
+        url.searchParams.set('limit', String(flags.limit));
+    const res = await safeGet(url.toString(), cred.apiKey);
+    if (res.status === 503)
+        return emitFeatureDisabled('list', ctx);
+    if (!res.ok) {
+        ctx.writeOutput({ command: 'memory', sub: 'list', status: 'invalid_args', reason: res.detail }, `pugi memory list: HTTP ${res.statusCode} — ${res.detail}`);
+        return { command: 'memory', sub: 'list', status: 'invalid_args', reason: res.detail };
+    }
+    const items = (res.body ?? []);
+    const now = (ctx.now ?? (() => new Date()))();
+    const lines = items.map((item) => formatMemoryRow(item, now));
+    const text = items.length === 0
+        ? 'No memories for the active tenant + filters.'
+        : ['kind         strength  age      ttl         id                                    content', ...lines].join('\n');
+    ctx.writeOutput({ command: 'memory', sub: 'list', count: items.length, items }, text);
+    return { command: 'memory', sub: 'list', status: 'listed', count: items.length };
+}
+// ===========================================================================
+// recall
+// ===========================================================================
+async function runRecall(args, ctx) {
+    const { positional, flags } = splitPositionalFlags(args);
+    if (positional.length === 0) {
+        ctx.writeOutput({ command: 'memory', sub: 'recall', status: 'invalid_args' }, 'pugi memory recall <query> — query is required.');
+        return { command: 'memory', sub: 'recall', status: 'invalid_args' };
+    }
+    const query = positional.join(' ').trim();
+    const persona = flags.persona ?? DEFAULT_PERSONA;
+    const topK = flags.topK ?? 5;
+    const cred = resolveActiveCredential();
+    if (!cred)
+        return emitUnauth('recall', ctx);
+    const url = new URL(`${stripTrailing(cred.apiUrl)}/api/persona-memory/recall`);
+    url.searchParams.set('personaSlug', persona);
+    url.searchParams.set('query', query);
+    url.searchParams.set('topK', String(topK));
+    const res = await safeGet(url.toString(), cred.apiKey);
+    if (res.status === 503)
+        return emitFeatureDisabled('recall', ctx);
+    if (!res.ok) {
+        ctx.writeOutput({ command: 'memory', sub: 'recall', status: 'invalid_args', reason: res.detail }, `pugi memory recall: HTTP ${res.statusCode} — ${res.detail}`);
+        return { command: 'memory', sub: 'recall', status: 'invalid_args', reason: res.detail };
+    }
+    const results = (res.body ?? []);
+    const text = results.length === 0
+        ? `No matches for "${query.slice(0, 64)}" on persona "${persona}".`
+        : results
+            .map((r, idx) => `${(idx + 1).toString().padStart(2, ' ')}. [${r.item.kind}] score=${r.score.toFixed(3)} ${r.item.content}`)
+            .join('\n');
+    ctx.writeOutput({ command: 'memory', sub: 'recall', count: results.length, results }, text);
+    return { command: 'memory', sub: 'recall', status: 'recalled', count: results.length };
+}
+// ===========================================================================
+// write
+// ===========================================================================
+async function runWrite(args, ctx) {
+    const { positional, flags } = splitPositionalFlags(args);
+    if (positional.length < 2) {
+        ctx.writeOutput({ command: 'memory', sub: 'write', status: 'invalid_args' }, 'pugi memory write <kind> <content> — kind + content required.');
+        return { command: 'memory', sub: 'write', status: 'invalid_args' };
+    }
+    const kind = positional[0]?.toLowerCase() ?? '';
+    const content = positional.slice(1).join(' ').trim();
+    if (!PERSONA_MEMORY_KINDS.includes(kind)) {
+        ctx.writeOutput({
+            command: 'memory',
+            sub: 'write',
+            status: 'invalid_args',
+            reason: 'unknown_kind',
+        }, `pugi memory write: unknown kind "${kind}". Expected one of ${PERSONA_MEMORY_KINDS.join(' | ')}.`);
+        return { command: 'memory', sub: 'write', status: 'invalid_args', reason: 'unknown_kind' };
+    }
+    if (content.length === 0) {
+        ctx.writeOutput({ command: 'memory', sub: 'write', status: 'invalid_args' }, 'pugi memory write: content is empty.');
+        return { command: 'memory', sub: 'write', status: 'invalid_args' };
+    }
+    const persona = flags.persona ?? DEFAULT_PERSONA;
+    const cred = resolveActiveCredential();
+    if (!cred) {
+        // Queue offline. Operator can run `pugi memory sync` once auth is up.
+        const pending = enqueueMemoryOp({
+            op: 'write',
+            personaSlug: persona,
+            kind: kind,
+            content,
+            forgetAfter: flags.forgetAfter ?? null,
+        });
+        ctx.writeOutput({
+            command: 'memory',
+            sub: 'write',
+            status: 'queued_offline',
+            pending,
+        }, `Queued offline (no active credential). ${pending} pending — run \`pugi memory sync\` after \`pugi login\`.`);
+        return { command: 'memory', sub: 'write', status: 'queued_offline', pending };
+    }
+    const url = `${stripTrailing(cred.apiUrl)}/api/persona-memory`;
+    const body = {
+        personaSlug: persona,
+        kind,
+        content,
+        forgetAfter: flags.forgetAfter ?? null,
+    };
+    const res = await safePost(url, cred.apiKey, body);
+    if (res.status === 503)
+        return emitFeatureDisabled('write', ctx);
+    if (!res.ok) {
+        // Server unreachable / 5xx → queue for retry. 4xx → surface error,
+        // don't queue (a malformed write would just loop on sync).
+        if (res.statusCode >= 500 || res.statusCode === 0) {
+            const pending = enqueueMemoryOp({
+                op: 'write',
+                personaSlug: persona,
+                kind: kind,
+                content,
+                forgetAfter: flags.forgetAfter ?? null,
+            });
+            ctx.writeOutput({
+                command: 'memory',
+                sub: 'write',
+                status: 'queued_offline',
+                pending,
+                reason: res.detail,
+            }, `Server unreachable (${res.detail}). Queued — ${pending} pending. Run \`pugi memory sync\` later.`);
+            return {
+                command: 'memory',
+                sub: 'write',
+                status: 'queued_offline',
+                pending,
+                reason: res.detail,
+            };
+        }
+        ctx.writeOutput({ command: 'memory', sub: 'write', status: 'invalid_args', reason: res.detail }, `pugi memory write: HTTP ${res.statusCode} — ${res.detail}`);
+        return {
+            command: 'memory',
+            sub: 'write',
+            status: 'invalid_args',
+            reason: res.detail,
+        };
+    }
+    const created = (res.body ?? {});
+    ctx.writeOutput({ command: 'memory', sub: 'write', status: 'written', item: created }, `Persisted [${kind}] on persona "${persona}": ${created.id}`);
+    return { command: 'memory', sub: 'write', status: 'written' };
+}
+// ===========================================================================
+// forget
+// ===========================================================================
+async function runForget(args, ctx) {
+    const id = (args[0] ?? '').trim();
+    if (!id) {
+        ctx.writeOutput({ command: 'memory', sub: 'forget', status: 'invalid_args' }, 'pugi memory forget <id> — memory id is required.');
+        return { command: 'memory', sub: 'forget', status: 'invalid_args' };
+    }
+    const cred = resolveActiveCredential();
+    if (!cred) {
+        const pending = enqueueMemoryOp({ op: 'forget', id });
+        ctx.writeOutput({ command: 'memory', sub: 'forget', status: 'queued_offline', pending }, `Queued offline (no active credential). ${pending} pending — run \`pugi memory sync\` after \`pugi login\`.`);
+        return { command: 'memory', sub: 'forget', status: 'queued_offline', pending };
+    }
+    const url = `${stripTrailing(cred.apiUrl)}/api/persona-memory/${encodeURIComponent(id)}`;
+    const res = await safeDelete(url, cred.apiKey);
+    if (res.status === 503)
+        return emitFeatureDisabled('forget', ctx);
+    if (res.statusCode === 404) {
+        ctx.writeOutput({ command: 'memory', sub: 'forget', status: 'forget_not_found', id }, `No memory with id "${id}" in this tenant.`);
+        return { command: 'memory', sub: 'forget', status: 'forget_not_found' };
+    }
+    if (!res.ok) {
+        if (res.statusCode >= 500 || res.statusCode === 0) {
+            const pending = enqueueMemoryOp({ op: 'forget', id });
+            ctx.writeOutput({
+                command: 'memory',
+                sub: 'forget',
+                status: 'queued_offline',
+                pending,
+                reason: res.detail,
+            }, `Server unreachable. Queued — ${pending} pending.`);
+            return {
+                command: 'memory',
+                sub: 'forget',
+                status: 'queued_offline',
+                pending,
+                reason: res.detail,
+            };
+        }
+        ctx.writeOutput({ command: 'memory', sub: 'forget', status: 'invalid_args', reason: res.detail }, `pugi memory forget: HTTP ${res.statusCode} — ${res.detail}`);
+        return {
+            command: 'memory',
+            sub: 'forget',
+            status: 'invalid_args',
+            reason: res.detail,
+        };
+    }
+    ctx.writeOutput({ command: 'memory', sub: 'forget', status: 'forgot', id }, `Forgot "${id}".`);
+    return { command: 'memory', sub: 'forget', status: 'forgot' };
+}
+// ===========================================================================
+// sync
+// ===========================================================================
+async function runSync(ctx) {
+    const cred = resolveActiveCredential();
+    if (!cred)
+        return emitUnauth('sync', ctx);
+    const pendingBefore = countPending();
+    if (pendingBefore === 0) {
+        ctx.writeOutput({ command: 'memory', sub: 'sync', status: 'sync_noop', pending: 0 }, 'No pending operations to sync.');
+        return { command: 'memory', sub: 'sync', status: 'sync_noop', pending: 0 };
+    }
+    const ops = readMemoryQueue();
+    const remaining = [];
+    let synced = 0;
+    for (const op of ops) {
+        const ok = await flushOne(cred.apiUrl, cred.apiKey, op);
+        if (ok) {
+            synced++;
+        }
+        else {
+            remaining.push(op);
+        }
+    }
+    rewriteMemoryQueue(remaining);
+    if (remaining.length === 0) {
+        ctx.writeOutput({
+            command: 'memory',
+            sub: 'sync',
+            status: 'synced',
+            pending: 0,
+            count: synced,
+        }, `Synced ${synced} pending operation(s). Queue is empty.`);
+        return { command: 'memory', sub: 'sync', status: 'synced', pending: 0, count: synced };
+    }
+    ctx.writeOutput({
+        command: 'memory',
+        sub: 'sync',
+        status: 'sync_partial',
+        pending: remaining.length,
+        count: synced,
+    }, `Synced ${synced} — ${remaining.length} still pending (server unreachable / 4xx).`);
+    return {
+        command: 'memory',
+        sub: 'sync',
+        status: 'sync_partial',
+        pending: remaining.length,
+        count: synced,
+    };
+}
+async function flushOne(apiUrl, apiKey, op) {
+    if (op.op === 'write') {
+        const res = await safePost(`${stripTrailing(apiUrl)}/api/persona-memory`, apiKey, {
+            personaSlug: op.personaSlug,
+            kind: op.kind,
+            content: op.content,
+            forgetAfter: op.forgetAfter ?? null,
+        });
+        if (res.ok)
+            return true;
+        // 4xx → drop from queue (would loop forever otherwise).
+        if (res.statusCode >= 400 && res.statusCode < 500)
+            return true;
+        return false;
+    }
+    // op.op === 'forget'
+    const res = await safeDelete(`${stripTrailing(apiUrl)}/api/persona-memory/${encodeURIComponent(op.id)}`, apiKey);
+    if (res.ok)
+        return true;
+    // 404 → drop (already gone); other 4xx → drop too.
+    if (res.statusCode >= 400 && res.statusCode < 500)
+        return true;
+    return false;
+}
+function parseFlags(args) {
+    const out = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i] ?? '';
+        if (a === '--persona' && args[i + 1]) {
+            out.persona = args[i + 1];
+            i++;
+        }
+        else if (a === '--kind' && args[i + 1]) {
+            out.kind = args[i + 1];
+            i++;
+        }
+        else if (a === '--limit' && args[i + 1]) {
+            const n = Number.parseInt(args[i + 1] ?? '', 10);
+            if (Number.isFinite(n))
+                out.limit = n;
+            i++;
+        }
+        else if (a === '--top-k' && args[i + 1]) {
+            const n = Number.parseInt(args[i + 1] ?? '', 10);
+            if (Number.isFinite(n))
+                out.topK = n;
+            i++;
+        }
+        else if (a === '--forget-after' && args[i + 1]) {
+            out.forgetAfter = args[i + 1];
+            i++;
+        }
+    }
+    return out;
+}
+function splitPositionalFlags(args) {
+    const positional = [];
+    const consumed = new Set();
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i] ?? '';
+        if (a.startsWith('--')) {
+            consumed.add(i);
+            if (i + 1 < args.length && !(args[i + 1] ?? '').startsWith('--')) {
+                consumed.add(i + 1);
+            }
+        }
+        else if (!consumed.has(i)) {
+            positional.push(a);
+        }
+    }
+    const flagArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        if (consumed.has(i))
+            flagArgs.push(args[i] ?? '');
+    }
+    return { positional, flags: parseFlags(flagArgs) };
+}
+function stripTrailing(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+function formatMemoryRow(item, now) {
+    const age = ageHuman(item.lastUsedAt, now);
+    const ttl = item.forgetAfter ? ttlHuman(item.forgetAfter, now) : 'none';
+    const content = item.content.replace(/[\r\n\t]+/g, ' ').slice(0, 60);
+    return `${item.kind.padEnd(12)} ${item.strength.toFixed(2).padEnd(8)} ${age.padEnd(8)} ${ttl.padEnd(11)} ${item.id.padEnd(36)} ${content}`;
+}
+function ageHuman(iso, now) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return '?';
+    const days = Math.floor((now.getTime() - t) / (1000 * 60 * 60 * 24));
+    if (days <= 0)
+        return '<1d';
+    if (days < 30)
+        return `${days}d`;
+    return `${Math.floor(days / 30)}mo`;
+}
+function ttlHuman(iso, now) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return '?';
+    const ms = t - now.getTime();
+    if (ms <= 0)
+        return 'expired';
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+    if (days >= 1)
+        return `${days}d`;
+    const hours = Math.floor(ms / (1000 * 60 * 60));
+    return `${hours}h`;
+}
+async function safeGet(url, apiKey) {
+    return safeRequest(url, apiKey, 'GET');
+}
+async function safeDelete(url, apiKey) {
+    return safeRequest(url, apiKey, 'DELETE');
+}
+async function safePost(url, apiKey, body) {
+    return safeRequest(url, apiKey, 'POST', body);
+}
+async function safeRequest(url, apiKey, method, body) {
+    try {
+        const headers = {
+            authorization: `Bearer ${apiKey}`,
+            accept: 'application/json',
+        };
+        let bodyText;
+        if (body !== undefined) {
+            bodyText = JSON.stringify(body);
+            headers['content-type'] = 'application/json';
+        }
+        const res = await request(url, { method, headers, body: bodyText });
+        const sc = res.statusCode;
+        if (sc < 200 || sc >= 300) {
+            const detail = await res.body.text().catch(() => '');
+            return {
+                ok: false,
+                status: sc,
+                statusCode: sc,
+                detail: detail.slice(0, 300),
+            };
+        }
+        const parsed = await res.body.json().catch(() => undefined);
+        return { ok: true, status: sc, statusCode: sc, body: parsed, detail: '' };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 0,
+            statusCode: 0,
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function emitUnauth(sub, ctx) {
+    ctx.writeOutput({
+        command: 'memory',
+        sub,
+        status: 'unauthenticated',
+        hint: 'pugi login',
+    }, 'pugi memory: no active credential. Run `pugi login` first.');
+    return { command: 'memory', sub, status: 'unauthenticated' };
+}
+function emitFeatureDisabled(sub, ctx) {
+    ctx.writeOutput({
+        command: 'memory',
+        sub,
+        status: 'feature_disabled',
+        hint: 'set PERSONA_MEMORY_ENABLED=true on the admin-api host',
+    }, 'persona-memory feature is disabled on the admin-api host (HTTP 503).');
+    return { command: 'memory', sub, status: 'feature_disabled' };
+}
+/** Re-export for the `pugi doctor` queue-pending probe + the spec. */
+export { defaultQueuePath };
+//# sourceMappingURL=memory.js.map

package/dist/runtime/commands/memory.spec.js

@@ -0,0 +1,174 @@
+import { strict as assert } from 'node:assert';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import { runMemoryCommand } from './memory.js';
+import { countPending } from '../../core/memory-sync/queue.js';
+/**
+ * Integration tests for the `pugi memory` runner.
+ *
+ * Authenticated server paths require mocking undici's `MockAgent`; the
+ * specs below focus on the un-authenticated + arg-parsing branches
+ * (which fully exercise the routing + queue interactions). The shared
+ * `runMemoryCommand` is decoupled from the network for those paths
+ * because `resolveActiveCredential` returns null without a configured
+ * credential file under PUGI_HOME.
+ */
+let tmpHome = '';
+const originalPugiHome = process.env.PUGI_HOME;
+const originalHome = process.env.HOME;
+const originalApiKey = process.env.PUGI_API_KEY;
+const originalApiUrl = process.env.PUGI_API_URL;
+function makeCtx() {
+    const capture = { payloads: [], texts: [] };
+    const ctx = {
+        workspaceRoot: process.cwd(),
+        json: false,
+        writeOutput: (payload, text) => {
+            capture.payloads.push(payload);
+            capture.texts.push(text);
+        },
+    };
+    return { ctx, capture };
+}
+beforeEach(() => {
+    tmpHome = mkdtempSync(resolve(tmpdir(), 'pugi-memory-cli-'));
+    // Both PUGI_HOME (used by the queue) AND HOME (used by
+    // resolveActiveCredential -> os.homedir()) must point at the temp
+    // dir so the spec is hermetic from the operator's real
+    // ~/.pugi/credentials.json.
+    process.env.PUGI_HOME = tmpHome;
+    process.env.HOME = tmpHome;
+    // The test machine may export real prod credentials — strip them so
+    // the unauthenticated-paths block actually sees no credential.
+    delete process.env.PUGI_API_KEY;
+    delete process.env.PUGI_API_URL;
+});
+afterEach(() => {
+    if (originalPugiHome === undefined)
+        delete process.env.PUGI_HOME;
+    else
+        process.env.PUGI_HOME = originalPugiHome;
+    if (originalHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = originalHome;
+    if (originalApiKey === undefined)
+        delete process.env.PUGI_API_KEY;
+    else
+        process.env.PUGI_API_KEY = originalApiKey;
+    if (originalApiUrl === undefined)
+        delete process.env.PUGI_API_URL;
+    else
+        process.env.PUGI_API_URL = originalApiUrl;
+    try {
+        rmSync(tmpHome, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+});
+describe('runMemoryCommand — unauthenticated paths', () => {
+    it('prints usage on empty subcommand', async () => {
+        const { ctx, capture } = makeCtx();
+        const result = await runMemoryCommand([], ctx);
+        assert.equal(result.sub, 'help');
+        assert.ok(capture.texts[0]?.includes('pugi memory'));
+    });
+    it('rejects unknown subcommand with status unknown_sub', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['blarg'], ctx);
+        assert.equal(result.status, 'unknown_sub');
+    });
+    it('returns unauthenticated for list when no credential', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['list'], ctx);
+        assert.equal(result.status, 'unauthenticated');
+    });
+    it('returns unauthenticated for sync when no credential', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['sync'], ctx);
+        assert.equal(result.status, 'unauthenticated');
+    });
+    it('queues offline writes when no credential present', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['write', 'preference', 'pnpm', '--persona', 'mira'], ctx);
+        assert.equal(result.status, 'queued_offline');
+        assert.equal(result.pending, 1);
+        // Confirm the queue file actually grew.
+        assert.equal(countPending(resolve(tmpHome, 'memory-queue.jsonl')), 1);
+    });
+    it('queues offline forget when no credential present', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['forget', 'mem-abc'], ctx);
+        assert.equal(result.status, 'queued_offline');
+        assert.equal(result.pending, 1);
+    });
+    it('rejects write missing kind', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['write'], ctx);
+        assert.equal(result.status, 'invalid_args');
+    });
+    it('rejects write with unknown kind', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['write', 'notakind', 'content here'], ctx);
+        assert.equal(result.status, 'invalid_args');
+        assert.equal(result.reason, 'unknown_kind');
+    });
+    it('rejects write with empty content', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['write', 'fact', '   '], ctx);
+        assert.equal(result.status, 'invalid_args');
+    });
+    it('rejects forget without id', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['forget'], ctx);
+        assert.equal(result.status, 'invalid_args');
+    });
+    it('rejects recall without query', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['recall'], ctx);
+        assert.equal(result.status, 'invalid_args');
+    });
+    it('sync with no pending ops returns sync_noop when offline-then-online flow', async () => {
+        // Two writes queued offline (no credential present), then sync called
+        // — sync without credential still returns unauthenticated, but the
+        // queued ops persist. After credential lands, sync would push them.
+        const { ctx } = makeCtx();
+        await runMemoryCommand(['write', 'fact', 'queued one'], ctx);
+        await runMemoryCommand(['write', 'fact', 'queued two'], ctx);
+        assert.equal(countPending(resolve(tmpHome, 'memory-queue.jsonl')), 2);
+        const { ctx: ctx2 } = makeCtx();
+        const result = await runMemoryCommand(['sync'], ctx2);
+        // Without an active credential, sync returns unauthenticated.
+        assert.equal(result.status, 'unauthenticated');
+        // The queued ops are still on disk for a later authenticated sync.
+        assert.equal(countPending(resolve(tmpHome, 'memory-queue.jsonl')), 2);
+    });
+    it('write+sync flow keeps queue intact across calls', async () => {
+        const { ctx } = makeCtx();
+        await runMemoryCommand(['write', 'workflow', 'sample workflow'], ctx);
+        const path = resolve(tmpHome, 'memory-queue.jsonl');
+        assert.equal(countPending(path), 1);
+        // A second call should append, not overwrite.
+        await runMemoryCommand(['write', 'fact', 'another fact'], ctx);
+        assert.equal(countPending(path), 2);
+    });
+});
+describe('runMemoryCommand — flag parsing', () => {
+    it('parses --persona and --kind flags on list', async () => {
+        const { ctx, capture } = makeCtx();
+        // list path requires auth — we only verify the flag-parsing path
+        // does not throw + surfaces the unauth status.
+        const result = await runMemoryCommand(['list', '--persona', 'marcus', '--kind', 'pattern', '--limit', '5'], ctx);
+        assert.equal(result.status, 'unauthenticated');
+        assert.equal(capture.payloads.length, 1);
+    });
+    it('parses --top-k on recall', async () => {
+        const { ctx } = makeCtx();
+        const result = await runMemoryCommand(['recall', 'what is pugi', '--top-k', '3'], ctx);
+        assert.equal(result.status, 'unauthenticated');
+    });
+});
+//# sourceMappingURL=memory.spec.js.map