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

package/dist/core/engine/compaction-hook.js

@@ -1,154 +0,0 @@
-/**
- * Engine loop integration point for the six-tier compaction engine.
- *
- * `maybeCompactAfterTool` is the single function the engine loop calls
- * after each tool result has been appended to the transcript. It:
- *
- *   1. Estimates current context-window pressure (transcript bytes
- *      against the model's budget, plus the static blocks).
- *   2. Calls `selectTier` on the snapshot.
- *   3. Runs the tier. Microcompact / cached_microcompact are sync;
- *      reactive_summary / session_memory / full_compaction / reset
- *      are async-shaped (the call returns before commit when run
- *      against a long transcript) but currently run inline — the
- *      engine loop is single-threaded today, so true backgrounding
- *      waits for the SSE consumer refactor in α5.7.
- *   4. Runs invariant checks against the result. On any violation,
- *      emits `compaction.invariant_violated` and returns the
- *      pre-compaction transcript untouched.
- *   5. On success, emits `compaction.completed` with reclaim numbers
- *      and returns the new transcript for the caller to adopt.
- *   6. On no-op, emits `compaction.skipped` and returns the original.
- *
- * Why a separate file (not inlined into `native-pugi.ts`):
- *
- *   Sprint α5.3 (feat/pugi-cli-hooks-lifecycle-m1-gap-c) is in flight
- *   and already modifies session.ts + tool-bridge + permission. Editing
- *   native-pugi.ts in this PR risks a merge conflict against α5.3's
- *   landing PR. Keeping the wiring as an exported helper means the
- *   one-line callsite in native-pugi.ts can be added in a tiny
- *   follow-up after both α5.3 and α5.5 have landed.
- *
- * Expected callsite in `apps/pugi-cli/src/core/engine/native-pugi.ts`,
- * inside `onToolResult`:
- *
- *   ```ts
- *   const compactionOutcome = await maybeCompactAfterTool({
- *     session,
- *     transcript: currentTranscript,
- *     toolOutputs: recentToolOutputs,
- *     contextBudgetUsed: estimatedTokens,
- *     contextBudgetMax: budget.maxTokens,
- *     workspaceRoot: root,
- *     contextStaticHash: {
- *       instructionsHash,
- *       toolSchemaHash,
- *     },
- *   });
- *   if (compactionOutcome.committed) {
- *     currentTranscript = compactionOutcome.newTranscript;
- *   }
- *   ```
- */
-import { runCompaction, selectTier, } from '../context/compaction.js';
-import { checkInvariants } from '../context/invariants.js';
-import { emitCompactionCompleted, emitCompactionInvariantViolated, emitCompactionSkipped, emitCompactionStarted, } from '../context/compaction-events.js';
-/**
- * Engine-loop callback. See file header for the expected callsite shape.
- *
- * Contract:
- *   - Never throws. All errors degrade to `committed: false` with the
- *     original transcript and an event record.
- *   - On `committed: true`, the caller MUST adopt `newTranscript` as
- *     the live working transcript for the next model turn.
- *   - On `committed: false`, the caller MUST keep the input transcript
- *     and try again on the next tool turn (compaction will retry once
- *     pressure stays above threshold).
- */
-export async function maybeCompactAfterTool(input) {
-    const compactionInput = {
-        sessionId: input.session.id,
-        contextBudgetUsed: input.contextBudgetUsed,
-        contextBudgetMax: input.contextBudgetMax,
-        toolOutputs: input.toolOutputs,
-        transcript: input.transcript,
-        workspaceRoot: input.workspaceRoot,
-    };
-    const tier = selectTier(compactionInput);
-    emitCompactionStarted(input.session, tier, {
-        budgetUsed: input.contextBudgetUsed,
-        budgetMax: input.contextBudgetMax,
-    });
-    let result;
-    try {
-        result = await runCompaction(compactionInput, tier);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        emitCompactionSkipped(input.session, tier, `compaction crashed: ${reason}`);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: `crashed: ${reason}`,
-        };
-    }
-    if (result.skipped) {
-        emitCompactionSkipped(input.session, tier, result.skipReason || 'no work');
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: result.skipReason,
-        };
-    }
-    // Invariant gate: static-hash-unchanged is enforced by passing the
-    // same hashes in for `before` and `after` — compaction never touches
-    // static blocks, so the hashes are equal by construction. We pass
-    // both so the contract is explicit; if a future tier introduces a
-    // bug that overwrites static state, the check still catches it.
-    const violations = checkInvariants({
-        before: compactionInput,
-        after: result,
-        summaryText: result.summaryText,
-        staticHashBefore: input.contextStaticHash,
-        staticHashAfter: input.contextStaticHash,
-    });
-    if (violations.length > 0) {
-        for (const v of violations)
-            emitCompactionInvariantViolated(input.session, v);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations,
-            skipped: false,
-            skipReason: '',
-        };
-    }
-    emitCompactionCompleted(input.session, tier, result.bytesReclaimed, result.newContextSize, result.artifactsCreated);
-    return {
-        committed: true,
-        tier,
-        newTranscript: result.newTranscript,
-        bytesReclaimed: result.bytesReclaimed,
-        newContextSize: result.newContextSize,
-        violations: [],
-        skipped: false,
-        skipReason: '',
-    };
-}
-function byteSize(transcript) {
-    return transcript.reduce((sum, t) => sum + Buffer.byteLength(t.content, 'utf8'), 0);
-}
-//# sourceMappingURL=compaction-hook.js.map

package/dist/core/init/scaffold.js

@@ -1,195 +0,0 @@
-/**
- * Workspace scaffold — extracted from `pugi init` so the bare REPL boot
- * can call it automatically when the operator launches `pugi` in a
- * fresh directory (CEO directive 2026-05-26).
- *
- * Before this module, `pugi init` was the only path that materialised
- * `.pugi/` + the canonical config files. Launching the REPL in an empty
- * directory printed `workspace: (not bound - run /init OR cd into
- * project)` and instructed the operator to Ctrl+C, run `pugi init`,
- * relaunch. That round trip is hostile on a first-touch install — CEO
- * escalated "auto = решение" on 2026-05-26.
- *
- * The module is intentionally side-effect free at import time: the
- * scaffold runs only when `ensureWorkspaceInitialized` is called. The
- * scaffold is also idempotent — every file write is gated by an
- * `existsSync` check, so re-running against a workspace that already has
- * `.pugi/settings.json` (e.g. a manual `pugi init` followed by auto-init
- * on next REPL launch) is a no-op. The function is safe to call before
- * any other init logic.
- *
- * Two CRITICAL invariants:
- *
- *   1. **Atomic per-file.** Every write uses `existsSync` + `writeFileSync`
- *      against the final path. There is no read-modify-write pattern that
- *      could lose data on a concurrent `pugi init` race. The one path
- *      that DOES mutate an existing file — `.gitignore` (append `.pugi/`
- *      marker) — also gates on the marker being absent before appending,
- *      so the worst-case race is a duplicate marker line that the next
- *      run skips.
- *
- *   2. **Silent by default.** When `opts.silent` is true (the REPL
- *      auto-init path) the scaffold writes NOTHING to stderr/stdout.
- *      The REPL bootstrap runs before Ink mounts, and a stray
- *      stdout/stderr write at that point would land on the operator's
- *      shell ABOVE the alt-screen entry — visible until they scroll up,
- *      and noisy in a CI tail. The explicit `pugi init` path stays
- *      verbose via the standalone command in `runtime/cli.ts`.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { emptyIndex } from '../index-store.js';
-/**
- * Materialise the canonical `.pugi/` workspace scaffold under `cwd`.
- * Returns a `{created, dir, createdPaths, skippedPaths}` summary so the
- * caller can log a one-shot "initialized" line on the first call without
- * re-checking the filesystem.
- *
- * The scaffold mirrors `pugi init` minus the bundled default-skills
- * install (that is a heavier operation gated on the `--no-defaults`
- * flag, and the standalone `pugi init` command keeps owning it).
- *
- * Idempotent: every file write gates on `existsSync`, so re-running
- * against an existing workspace is a no-op and returns
- * `{created: false}` with every path in `skippedPaths`.
- */
-export function ensureWorkspaceInitialized(cwd, opts = {}) {
-    const silent = opts.silent !== false;
-    const pugiDir = resolve(cwd, '.pugi');
-    // Local trackers so the existing helpers (mkdirIfMissing /
-    // writeJsonIfMissing / writeTextIfMissing) keep their (created, skipped)
-    // signature. The explicit `pugi init` command forwards these straight
-    // into its JSON payload.
-    const created = [];
-    const skipped = [];
-    mkdirIfMissing(pugiDir, created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'artifacts'), created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'sessions'), created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'skills'), created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'settings.json'), {
-        schema: 1,
-        workflow: {
-            brand: 'pugi',
-            legacyName: 'codeforge',
-            approvals: 'auto',
-            notAutomatic: [],
-            defaultBaseBranch: 'dev',
-            branchPrefixes: ['feature', 'fix', 'refactor', 'chore'],
-            aiCoAuthorTrailers: false,
-        },
-        permissions: {
-            mode: 'auto',
-            allow: [],
-            deny: [],
-            notAutomatic: [],
-        },
-        privacy: {
-            mode: 'balanced',
-            telemetry: 'off',
-        },
-        artifacts: {
-            defaultPath: '.pugi/artifacts',
-            promoteExplicitly: true,
-        },
-    }, created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'mcp.json'), { schema: 1, servers: [] }, created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'index.json'), emptyIndex(), created, skipped);
-    writeTextIfMissing(resolve(pugiDir, 'PUGI.md'), [
-        '# Pugi Project Context',
-        '',
-        '## Product Workflow',
-        '',
-        '- Public product name: Pugi',
-        '- Default flow: idea -> build -> review',
-        '- Approvals are automatic by default until a repo, environment, workflow, or action is marked notAutomatic.',
-        '- Do not add AI Co-Authored-By trailers.',
-        '- Generated code, comments, commits, PR text, and technical docs default to English.',
-        '',
-        '## Project Notes',
-        '',
-        '- Add repo-specific architecture, commands, and business rules here.',
-        '- Do not store secrets, real IPs, private key paths, tokens, or credentials here.',
-        '',
-    ].join('\n'), created, skipped);
-    writeTextIfMissing(resolve(cwd, '.pugiignore'), [
-        '# Pugi ignore rules',
-        '.env',
-        '.env.*',
-        '!.env.example',
-        'node_modules/',
-        'dist/',
-        '.next/',
-        'coverage/',
-        '*.log',
-        '*.pem',
-        '*.key',
-        '*.crt',
-        '*.p12',
-        '*.sql',
-        '*.dump',
-        '',
-    ].join('\n'), created, skipped);
-    ensurePugiGitIgnore(cwd, created, skipped);
-    // `silent` is honoured implicitly — this module never writes to
-    // stdout/stderr. The flag exists so the standalone `pugi init` command
-    // can layer its own logger on top (it does, in runtime/cli.ts), while
-    // the auto-init REPL path leaves the boot stream untouched. We
-    // reference the flag here to defeat the lint "unused" warning and to
-    // document the contract in the source.
-    void silent;
-    return {
-        created: created.length > 0,
-        dir: pugiDir,
-        createdPaths: created,
-        skippedPaths: skipped,
-    };
-}
-/* ------------------------------------------------------------------ */
-/* Helpers (mirror the previous in-file implementations in cli.ts)     */
-/* ------------------------------------------------------------------ */
-function mkdirIfMissing(path, created, skipped) {
-    if (existsSync(path)) {
-        skipped.push(path);
-        return;
-    }
-    mkdirSync(path, { recursive: true });
-    created.push(path);
-}
-function writeJsonIfMissing(path, value, created, skipped) {
-    writeTextIfMissing(path, `${JSON.stringify(value, null, 2)}\n`, created, skipped);
-}
-function writeTextIfMissing(path, value, created, skipped) {
-    if (existsSync(path)) {
-        skipped.push(path);
-        return;
-    }
-    writeFileSync(path, value, { encoding: 'utf8', mode: 0o600 });
-    created.push(path);
-}
-/**
- * Ensure the workspace `.gitignore` ignores `.pugi/`. The function is
- * additive: it leaves an existing `.gitignore` body intact and appends
- * the marker only when none of `.pugi/`, `/.pugi/`, or `.pugi` is
- * already present. On a fresh repo with no `.gitignore` it creates the
- * file with the single marker line. Mode 0o600 matches the rest of the
- * scaffold so a paranoid CI does not surface "world-readable" warnings.
- */
-function ensurePugiGitIgnore(cwd, created, skipped) {
-    const gitignorePath = resolve(cwd, '.gitignore');
-    const marker = '.pugi/';
-    if (!existsSync(gitignorePath)) {
-        writeFileSync(gitignorePath, `${marker}\n`, { encoding: 'utf8', mode: 0o600 });
-        created.push(gitignorePath);
-        return;
-    }
-    const current = readFileSync(gitignorePath, 'utf8');
-    const lines = current.split('\n').map((line) => line.trim());
-    if (lines.includes(marker) || lines.includes('/.pugi/') || lines.includes('.pugi')) {
-        skipped.push(gitignorePath);
-        return;
-    }
-    const next = current.endsWith('\n') ? `${current}${marker}\n` : `${current}\n${marker}\n`;
-    writeFileSync(gitignorePath, next, { encoding: 'utf8' });
-    created.push(`${gitignorePath} (+${marker})`);
-}
-//# sourceMappingURL=scaffold.js.map

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

@@ -1,297 +0,0 @@
-/**
- * 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