@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.31

package/dist/core/memory/dual-write.spec.js

@@ -0,0 +1,297 @@
+/**
+ * Pugi CLI dual-write client spec — Memory Phase 1 (2026-05-27).
+ *
+ * Covers:
+ *   1. happy path — single batch posts to /api/pugi/sessions/:id/events
+ *   2. debounce + batch coalesces multiple enqueues into one POST
+ *   3. retry on transient failure with exponential backoff
+ *   4. surrender after maxRetries — local NDJSON stays authoritative
+ *   5. lastSyncedSeq marker is written + persisted across instances
+ *   6. flushBacklog catches up rows with seq > lastSyncedSeq
+ *   7. env kill-switch turns dual-write off
+ *   8. cliKindToPhase1 remap covers every CLI kind
+ *   9. invalid Phase-1 kinds quietly dropped from enqueue
+ *  10. dispose awaits the pending flush
+ */
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import { DualWriteClient, cliKindToPhase1, debounceMsFromEnv, isDualWriteEnabledFromEnv, isValidPhase1Kind, nextBackoffMs, readSyncState, writeSyncState, } from './dual-write.js';
+import { PUGI_SESSION_EVENT_KINDS, } from './phase1-kinds.js';
+let tmpDir = '';
+beforeEach(() => {
+    tmpDir = mkdtempSync(resolve(tmpdir(), 'pugi-dual-write-'));
+});
+afterEach(() => {
+    try {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+function makeStubFetch(responses) {
+    const calls = [];
+    let i = 0;
+    const fetchImpl = async (input, init) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        const headers = {};
+        if (init?.headers) {
+            const h = init.headers;
+            for (const k of Object.keys(h))
+                headers[k.toLowerCase()] = h[k];
+        }
+        const bodyRaw = typeof init?.body === 'string' ? init.body : '';
+        let body = null;
+        try {
+            body = bodyRaw ? JSON.parse(bodyRaw) : null;
+        }
+        catch {
+            body = bodyRaw;
+        }
+        calls.push({ url, body, headers });
+        const spec = responses[i++] ?? responses[responses.length - 1] ?? { ok: true };
+        if (spec.throw)
+            throw spec.throw;
+        return {
+            ok: spec.ok,
+            status: spec.status ?? (spec.ok ? 200 : 500),
+            statusText: spec.ok ? 'OK' : 'Internal Server Error',
+            json: async () => spec.body ?? {
+                persistedCount: 0,
+                duplicateCount: 0,
+                lastSeq: 0,
+            },
+        };
+    };
+    return { fetchImpl, calls };
+}
+/* --------------------------------------------------------------- */
+/* Pure helpers                                                    */
+/* --------------------------------------------------------------- */
+describe('dual-write: env helpers', () => {
+    it('isDualWriteEnabledFromEnv: defaults to ON', () => {
+        assert.equal(isDualWriteEnabledFromEnv({}), true);
+        assert.equal(isDualWriteEnabledFromEnv({ PUGI_MEMORY_PHASE1_PRISMA_PERSIST_ENABLED: 'true' }), true);
+    });
+    it('isDualWriteEnabledFromEnv: OFF on common false-ish values', () => {
+        assert.equal(isDualWriteEnabledFromEnv({ PUGI_MEMORY_PHASE1_PRISMA_PERSIST_ENABLED: 'false' }), false);
+        assert.equal(isDualWriteEnabledFromEnv({ PUGI_MEMORY_PHASE1_PRISMA_PERSIST_ENABLED: '0' }), false);
+        assert.equal(isDualWriteEnabledFromEnv({ PUGI_MEMORY_PHASE1_PRISMA_PERSIST_ENABLED: 'off' }), false);
+    });
+    it('debounceMsFromEnv: parses + clamps + falls back', () => {
+        assert.equal(debounceMsFromEnv({}), 250);
+        assert.equal(debounceMsFromEnv({ PUGI_MEMORY_DUAL_WRITE_DEBOUNCE_MS: '500' }), 500);
+        // Bogus -> default.
+        assert.equal(debounceMsFromEnv({ PUGI_MEMORY_DUAL_WRITE_DEBOUNCE_MS: 'abc' }), 250);
+        // Negative -> default.
+        assert.equal(debounceMsFromEnv({ PUGI_MEMORY_DUAL_WRITE_DEBOUNCE_MS: '-5' }), 250);
+        // Too large -> default.
+        assert.equal(debounceMsFromEnv({ PUGI_MEMORY_DUAL_WRITE_DEBOUNCE_MS: '120000' }), 250);
+    });
+    it('nextBackoffMs: 1x / 3x / 9x growth', () => {
+        assert.equal(nextBackoffMs(1, 100), 100);
+        assert.equal(nextBackoffMs(2, 100), 300);
+        assert.equal(nextBackoffMs(3, 100), 900);
+    });
+    it('cliKindToPhase1: covers every CLI kind we know about', () => {
+        assert.equal(cliKindToPhase1('user'), 'turn.user');
+        assert.equal(cliKindToPhase1('persona'), 'turn.assistant');
+        assert.equal(cliKindToPhase1('system'), 'system');
+        assert.equal(cliKindToPhase1('tool.start'), 'tool.call');
+        assert.equal(cliKindToPhase1('tool.result'), 'tool.result');
+        assert.equal(cliKindToPhase1('agent.spawned'), 'dispatch.start');
+        assert.equal(cliKindToPhase1('agent.completed'), 'dispatch.end');
+        assert.equal(cliKindToPhase1('compaction'), 'compact.boundary');
+        // rewind-marker and any other -> null (the CLI keeps these in NDJSON only).
+        assert.equal(cliKindToPhase1('rewind-marker'), null);
+        assert.equal(cliKindToPhase1('totally-unknown'), null);
+    });
+    it('isValidPhase1Kind matches the closed set', () => {
+        for (const k of PUGI_SESSION_EVENT_KINDS) {
+            assert.equal(isValidPhase1Kind(k), true);
+        }
+        assert.equal(isValidPhase1Kind('user'), false); // CLI kind, not Phase-1
+        assert.equal(isValidPhase1Kind('nope'), false);
+    });
+});
+/* --------------------------------------------------------------- */
+/* lastSyncedSeq marker                                            */
+/* --------------------------------------------------------------- */
+describe('dual-write: sync state marker', () => {
+    it('reads 0 when no marker on disk', () => {
+        assert.equal(readSyncState('sess-1', tmpDir), 0);
+    });
+    it('writes + reads back monotonic seq', () => {
+        writeSyncState('sess-1', 42, tmpDir);
+        assert.equal(readSyncState('sess-1', tmpDir), 42);
+        writeSyncState('sess-1', 100, tmpDir);
+        assert.equal(readSyncState('sess-1', tmpDir), 100);
+    });
+    it('isolates per-session', () => {
+        writeSyncState('sess-a', 5, tmpDir);
+        writeSyncState('sess-b', 10, tmpDir);
+        assert.equal(readSyncState('sess-a', tmpDir), 5);
+        assert.equal(readSyncState('sess-b', tmpDir), 10);
+    });
+});
+/* --------------------------------------------------------------- */
+/* DualWriteClient end-to-end                                       */
+/* --------------------------------------------------------------- */
+describe('DualWriteClient', () => {
+    it('flushes a single batch on demand', async () => {
+        const { fetchImpl, calls } = makeStubFetch([
+            { ok: true, body: { persistedCount: 2, duplicateCount: 0, lastSeq: 2 } },
+        ]);
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'test-key',
+            sessionId: 'sess-1',
+            fetchImpl,
+            debounceMs: 5,
+            stateDir: tmpDir,
+        });
+        client.enqueue({ seq: 1, kind: 'turn.user', payload: { text: 'hi' } });
+        client.enqueue({ seq: 2, kind: 'turn.assistant', payload: { text: 'hello' } });
+        const result = await client.flush();
+        await client.dispose();
+        assert.equal(calls.length, 1);
+        assert.equal(calls[0].headers['authorization'], 'Bearer test-key');
+        const sentBody = calls[0].body;
+        assert.equal(sentBody.events.length, 2);
+        assert.equal(sentBody.events[0].seq, 1);
+        assert.equal(sentBody.events[1].kind, 'turn.assistant');
+        assert.equal(result?.persistedCount, 2);
+        assert.equal(result?.lastSeq, 2);
+        // Marker persisted.
+        assert.equal(readSyncState('sess-1', tmpDir), 2);
+    });
+    it('retries on transient failure with exponential backoff', async () => {
+        const { fetchImpl, calls } = makeStubFetch([
+            { ok: false, status: 503, body: {} },
+            { ok: false, status: 503, body: {} },
+            { ok: true, body: { persistedCount: 1, duplicateCount: 0, lastSeq: 5 } },
+        ]);
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'k',
+            sessionId: 'sess-r',
+            fetchImpl,
+            debounceMs: 1, // base for backoff -> 1ms / 3ms / 9ms; fast test
+            maxRetries: 3,
+            stateDir: tmpDir,
+        });
+        client.enqueue({ seq: 5, kind: 'turn.user', payload: {} });
+        const result = await client.flush();
+        await client.dispose();
+        assert.equal(calls.length, 3);
+        assert.equal(result?.lastSeq, 5);
+        assert.equal(readSyncState('sess-r', tmpDir), 5);
+    });
+    it('surrenders after maxRetries — local NDJSON stays the truth', async () => {
+        const { fetchImpl, calls } = makeStubFetch([
+            { ok: false, status: 500, body: {} },
+            { ok: false, status: 500, body: {} },
+            { ok: false, status: 500, body: {} },
+        ]);
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'k',
+            sessionId: 'sess-fail',
+            fetchImpl,
+            debounceMs: 1,
+            maxRetries: 3,
+            stateDir: tmpDir,
+        });
+        client.enqueue({ seq: 1, kind: 'turn.user', payload: {} });
+        const result = await client.flush();
+        await client.dispose();
+        assert.equal(calls.length, 3);
+        assert.equal(result, null); // surrender
+        // Marker NOT written — next session retries from zero.
+        assert.equal(readSyncState('sess-fail', tmpDir), 0);
+    });
+    it('drops events whose kind is not in the Phase-1 set', async () => {
+        const { fetchImpl, calls } = makeStubFetch([
+            { ok: true, body: { persistedCount: 1, duplicateCount: 0, lastSeq: 1 } },
+        ]);
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'k',
+            sessionId: 'sess-d',
+            fetchImpl,
+            debounceMs: 5,
+            stateDir: tmpDir,
+        });
+        // The string is broader than Phase-1 — the client filters silently.
+        client.enqueue({ seq: 1, kind: 'rewind-marker', payload: {} });
+        client.enqueue({ seq: 2, kind: 'turn.user', payload: {} });
+        await client.flush();
+        await client.dispose();
+        const sent = calls[0].body;
+        assert.equal(sent.events.length, 1);
+        assert.equal(sent.events[0].seq, 2);
+    });
+    it('flushBacklog skips events <= lastSyncedSeq and posts the rest', async () => {
+        const { fetchImpl, calls } = makeStubFetch([
+            { ok: true, body: { persistedCount: 2, duplicateCount: 0, lastSeq: 10 } },
+        ]);
+        // Seed a marker: last synced was seq=5.
+        writeSyncState('sess-bk', 5, tmpDir);
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'k',
+            sessionId: 'sess-bk',
+            fetchImpl,
+            stateDir: tmpDir,
+        });
+        const allEvents = [
+            { seq: 1, kind: 'turn.user', payload: {} }, // skip
+            { seq: 5, kind: 'turn.assistant', payload: {} }, // skip (<=5)
+            { seq: 7, kind: 'turn.user', payload: {} }, // POST
+            { seq: 10, kind: 'turn.assistant', payload: {} }, // POST
+        ];
+        const result = await client.flushBacklog(allEvents);
+        assert.equal(calls.length, 1);
+        const sent = calls[0].body;
+        assert.equal(sent.events.length, 2);
+        assert.equal(sent.events[0].seq, 7);
+        assert.equal(sent.events[1].seq, 10);
+        assert.equal(result.persistedCount, 2);
+        assert.equal(result.lastSeq, 10);
+        assert.equal(readSyncState('sess-bk', tmpDir), 10);
+        await client.dispose();
+    });
+    it('dispose awaits the in-flight flush', async () => {
+        // Use a fetch that resolves after a tiny delay so the dispose has to
+        // wait.
+        let resolved = false;
+        const fetchImpl = async () => {
+            await new Promise((r) => setTimeout(r, 10));
+            resolved = true;
+            return {
+                ok: true,
+                status: 200,
+                statusText: 'OK',
+                json: async () => ({ persistedCount: 1, duplicateCount: 0, lastSeq: 1 }),
+            };
+        };
+        const client = new DualWriteClient({
+            apiUrl: 'http://localhost',
+            apiKey: 'k',
+            sessionId: 'sess-disp',
+            fetchImpl,
+            debounceMs: 1,
+            stateDir: tmpDir,
+        });
+        client.enqueue({ seq: 1, kind: 'turn.user', payload: {} });
+        // Schedule a flush + immediately dispose; dispose must wait.
+        const flushPromise = client.flush();
+        await client.dispose();
+        await flushPromise;
+        assert.equal(resolved, true);
+    });
+});
+//# sourceMappingURL=dual-write.spec.js.map

package/dist/core/memory/phase1-kinds.js

@@ -0,0 +1,20 @@
+/**
+ * Phase-1 event kind closed set — mirror of
+ * `apps/admin-api/src/pugi-session-events/pugi-session-events.types.ts`
+ * PUGI_SESSION_EVENT_KINDS.
+ *
+ * Kept as a separate file so the CLI does not import from admin-api
+ * (would drag the whole Nest graph). The TWO lists must stay in
+ * lockstep — a new kind requires editing both files.
+ */
+export const PUGI_SESSION_EVENT_KINDS = [
+    'turn.user',
+    'turn.assistant',
+    'tool.call',
+    'tool.result',
+    'dispatch.start',
+    'dispatch.end',
+    'compact.boundary',
+    'system',
+];
+//# sourceMappingURL=phase1-kinds.js.map

package/dist/core/memory-sync/queue.js

@@ -0,0 +1,158 @@
+/**
+ * Pugi memory sync queue (ADR-0063 Day 4).
+ *
+ * Local pending-write queue for `pugi memory` commands when the
+ * operator is offline or the admin-api is unreachable. Each pending
+ * mutation lands on disk as one JSONL line; `pugi memory sync` reads
+ * the queue, fires them to the admin-api in order, and rewrites the
+ * file with only the entries that still failed.
+ *
+ * Storage:
+ *
+ *   ~/.pugi/memory-queue.jsonl          (mode 0600)
+ *
+ * Each line is a fully-typed `PendingMemoryOperation` envelope. The
+ * envelope is forward-compatible: an older CLI reading a JSONL file
+ * written by a newer CLI silently skips lines whose `op` field is
+ * not in its known set (so a partial-rollback scenario doesn't crash
+ * the queue).
+ *
+ * Design intent:
+ *   - Append-only on disk for the hot path (`pugi memory write` /
+ *     `pugi memory forget` queue when offline). Rewrites only on
+ *     successful sync.
+ *   - One file per operator (PUGI_HOME-aware). Queue is local to the
+ *     machine — no cross-host coordination. Multi-device sync is
+ *     deferred to Phase 6 (server-side outbox).
+ *   - No fsync / atomic rename ceremony in v1 — best effort. The
+ *     queue is a convenience surface, not a durability primitive;
+ *     the source of truth is the admin-api row.
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { z } from 'zod';
+/** Six canonical kinds — must mirror `apps/admin-api/src/persona-memory/persona-memory.types.ts`. */
+export const PERSONA_MEMORY_KINDS = [
+    'pattern',
+    'preference',
+    'architecture',
+    'bug',
+    'workflow',
+    'fact',
+];
+const writeOpSchema = z.object({
+    op: z.literal('write'),
+    enqueuedAt: z.string().datetime(),
+    personaSlug: z.string().min(1).max(64),
+    kind: z.enum(PERSONA_MEMORY_KINDS),
+    content: z.string().min(1).max(4000),
+    forgetAfter: z.string().datetime().nullable().optional(),
+});
+const forgetOpSchema = z.object({
+    op: z.literal('forget'),
+    enqueuedAt: z.string().datetime(),
+    id: z.string().min(1),
+});
+const pendingMemoryOpSchema = z.discriminatedUnion('op', [
+    writeOpSchema,
+    forgetOpSchema,
+]);
+/** Default storage path. Override via `PUGI_HOME` for tests / multi-account. */
+export function defaultQueuePath() {
+    const root = process.env.PUGI_HOME ?? resolve(homedir(), '.pugi');
+    return resolve(root, 'memory-queue.jsonl');
+}
+/**
+ * Append one pending operation to the queue file. Creates the parent
+ * directory + file with mode 0600 if missing. Pure-disk, no network.
+ *
+ * Returns the count of pending ops after the append (1-based) so the
+ * CLI command can render "queued (3 pending) — run `pugi memory sync`".
+ */
+export function enqueueMemoryOp(op, pathOverride) {
+    const fullOp = {
+        ...op,
+        enqueuedAt: new Date().toISOString(),
+    };
+    pendingMemoryOpSchema.parse(fullOp);
+    const queuePath = pathOverride ?? defaultQueuePath();
+    ensureQueueFile(queuePath);
+    const existing = readFileSync(queuePath, 'utf-8');
+    const line = `${JSON.stringify(fullOp)}\n`;
+    writeFileSync(queuePath, `${existing}${line}`, { encoding: 'utf-8', mode: 0o600 });
+    // Best-effort chmod (in case the file existed already at the wrong mode).
+    try {
+        chmodSync(queuePath, 0o600);
+    }
+    catch {
+        // ignore — the file was just written above, mode might be platform-dependent.
+    }
+    return countPending(queuePath);
+}
+/** Read the queue file and return parsed entries. Skips unknown / malformed lines. */
+export function readMemoryQueue(pathOverride) {
+    const queuePath = pathOverride ?? defaultQueuePath();
+    if (!existsSync(queuePath))
+        return [];
+    const raw = readFileSync(queuePath, 'utf-8');
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = pendingMemoryOpSchema.parse(JSON.parse(trimmed));
+            out.push(parsed);
+        }
+        catch {
+            // forward-compat: a future op kind we don't recognise should not
+            // crash the queue; just drop the line during this read.
+            continue;
+        }
+    }
+    return out;
+}
+/** Rewrite the queue file with `remaining` entries only. Empty array clears the file. */
+export function rewriteMemoryQueue(remaining, pathOverride) {
+    const queuePath = pathOverride ?? defaultQueuePath();
+    ensureQueueFile(queuePath);
+    if (remaining.length === 0) {
+        writeFileSync(queuePath, '', { encoding: 'utf-8', mode: 0o600 });
+        return;
+    }
+    const body = remaining.map((op) => JSON.stringify(op)).join('\n') + '\n';
+    writeFileSync(queuePath, body, { encoding: 'utf-8', mode: 0o600 });
+}
+/** Count pending ops without re-parsing every line individually for the typed shape. */
+export function countPending(pathOverride) {
+    const queuePath = pathOverride ?? defaultQueuePath();
+    if (!existsSync(queuePath))
+        return 0;
+    const raw = readFileSync(queuePath, 'utf-8');
+    let n = 0;
+    for (const line of raw.split(/\r?\n/)) {
+        if (line.trim().length > 0)
+            n++;
+    }
+    return n;
+}
+/** Quick predicate — was anything ever queued? */
+export function hasPendingOps(pathOverride) {
+    return countPending(pathOverride) > 0;
+}
+function ensureQueueFile(queuePath) {
+    const dir = dirname(queuePath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (!existsSync(queuePath)) {
+        writeFileSync(queuePath, '', { encoding: 'utf-8', mode: 0o600 });
+        try {
+            chmodSync(queuePath, 0o600);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/core/memory-sync/queue.spec.js

@@ -0,0 +1,105 @@
+import { strict as assert } from 'node:assert';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import { countPending, enqueueMemoryOp, hasPendingOps, readMemoryQueue, rewriteMemoryQueue, } from './queue.js';
+let tmpRoot = '';
+let queuePath = '';
+beforeEach(() => {
+    tmpRoot = mkdtempSync(resolve(tmpdir(), 'pugi-memory-queue-'));
+    queuePath = resolve(tmpRoot, 'memory-queue.jsonl');
+});
+afterEach(() => {
+    try {
+        rmSync(tmpRoot, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+});
+describe('memory-sync queue', () => {
+    it('countPending returns 0 for missing file', () => {
+        assert.equal(countPending(queuePath), 0);
+        assert.equal(hasPendingOps(queuePath), false);
+    });
+    it('enqueueMemoryOp appends a write op and returns 1', () => {
+        const n = enqueueMemoryOp({
+            op: 'write',
+            personaSlug: 'mira',
+            kind: 'preference',
+            content: 'operator prefers pnpm',
+        }, queuePath);
+        assert.equal(n, 1);
+        assert.equal(hasPendingOps(queuePath), true);
+    });
+    it('enqueueMemoryOp appends multiple ops sequentially', () => {
+        enqueueMemoryOp({ op: 'write', personaSlug: 'mira', kind: 'fact', content: 'a' }, queuePath);
+        enqueueMemoryOp({ op: 'forget', id: 'mem-abc' }, queuePath);
+        assert.equal(countPending(queuePath), 2);
+    });
+    it('readMemoryQueue returns parsed entries in order', () => {
+        enqueueMemoryOp({ op: 'write', personaSlug: 'mira', kind: 'workflow', content: 'first' }, queuePath);
+        enqueueMemoryOp({ op: 'forget', id: 'mem-1' }, queuePath);
+        const ops = readMemoryQueue(queuePath);
+        assert.equal(ops.length, 2);
+        assert.equal(ops[0]?.op, 'write');
+        if (ops[0]?.op === 'write')
+            assert.equal(ops[0].content, 'first');
+        assert.equal(ops[1]?.op, 'forget');
+    });
+    it('readMemoryQueue skips malformed lines without crashing', () => {
+        writeFileSync(queuePath, [
+            JSON.stringify({
+                op: 'write',
+                personaSlug: 'mira',
+                kind: 'fact',
+                content: 'a',
+                enqueuedAt: new Date().toISOString(),
+            }),
+            '{not valid json',
+            JSON.stringify({ op: 'future_op', whatever: true }),
+        ].join('\n'));
+        const ops = readMemoryQueue(queuePath);
+        assert.equal(ops.length, 1);
+    });
+    it('rewriteMemoryQueue with empty array clears the file', () => {
+        enqueueMemoryOp({ op: 'write', personaSlug: 'mira', kind: 'fact', content: 'a' }, queuePath);
+        rewriteMemoryQueue([], queuePath);
+        assert.equal(countPending(queuePath), 0);
+        const raw = readFileSync(queuePath, 'utf-8');
+        assert.equal(raw, '');
+    });
+    it('rewriteMemoryQueue with remaining entries persists them', () => {
+        enqueueMemoryOp({ op: 'write', personaSlug: 'mira', kind: 'fact', content: 'a' }, queuePath);
+        enqueueMemoryOp({ op: 'write', personaSlug: 'mira', kind: 'fact', content: 'b' }, queuePath);
+        const all = readMemoryQueue(queuePath);
+        rewriteMemoryQueue([all[1]], queuePath);
+        const after = readMemoryQueue(queuePath);
+        assert.equal(after.length, 1);
+        if (after[0]?.op === 'write')
+            assert.equal(after[0].content, 'b');
+    });
+    it('enqueueMemoryOp rejects an invalid kind via Zod', () => {
+        assert.throws(() => enqueueMemoryOp({
+            op: 'write',
+            personaSlug: 'mira',
+            // @ts-expect-error — intentional bad value
+            kind: 'whatever',
+            content: 'a',
+        }, queuePath));
+    });
+    it('enqueueMemoryOp rejects oversized content (>4000 chars)', () => {
+        assert.throws(() => enqueueMemoryOp({
+            op: 'write',
+            personaSlug: 'mira',
+            kind: 'fact',
+            content: 'x'.repeat(4001),
+        }, queuePath));
+    });
+    it('countPending counts non-empty lines only', () => {
+        writeFileSync(queuePath, 'line1\n\n\nline2\n');
+        assert.equal(countPending(queuePath), 2);
+    });
+});
+//# sourceMappingURL=queue.spec.js.map