@gkorepanov/ccodex 0.4.25 → 0.5.0-rc.2

package/dist/handoff/store.js

@@ -1,867 +0,0 @@
-import { chmodSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-export class HandoffStore {
-    path;
-    database;
-    constructor(path) {
-        this.path = path;
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-        this.database = new DatabaseSync(path);
-        this.database.exec(`
-      PRAGMA journal_mode=WAL;
-      PRAGMA synchronous=FULL;
-      PRAGMA busy_timeout=5000;
-      PRAGMA foreign_keys=ON;
-      CREATE TABLE IF NOT EXISTS side_threads (
-        public_thread_id TEXT PRIMARY KEY,
-        record_json TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS pending_provider_switches (
-        thread_id TEXT PRIMARY KEY,
-        source_provider TEXT NOT NULL,
-        target_provider TEXT NOT NULL,
-        target_model TEXT NOT NULL,
-        settings_json TEXT NOT NULL,
-        updated_at INTEGER NOT NULL,
-        revision INTEGER NOT NULL DEFAULT 1,
-        expected_epoch_id TEXT
-      );
-      CREATE TABLE IF NOT EXISTS stock_history_overlays (
-        thread_id TEXT PRIMARY KEY,
-        source_thread_id TEXT NOT NULL,
-        source_thread_json TEXT NOT NULL,
-        turns_json TEXT NOT NULL,
-        created_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS handoff_jobs (
-        job_id TEXT PRIMARY KEY,
-        source_thread_id TEXT NOT NULL,
-        params_json TEXT NOT NULL,
-        pending_json TEXT,
-        status TEXT NOT NULL,
-        result_json TEXT,
-        target_json TEXT,
-        error TEXT,
-        error_notified INTEGER NOT NULL DEFAULT 0,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS handoff_jobs_recovery
-        ON handoff_jobs(status, created_at);
-      CREATE INDEX IF NOT EXISTS handoff_jobs_failure
-        ON handoff_jobs(source_thread_id, status, error_notified, updated_at);
-      CREATE TABLE IF NOT EXISTS logical_threads (
-        public_thread_id TEXT PRIMARY KEY,
-        current_epoch_id TEXT NOT NULL,
-        thread_json TEXT NOT NULL,
-        revision INTEGER NOT NULL DEFAULT 1,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS provider_epochs (
-        epoch_id TEXT PRIMARY KEY,
-        public_thread_id TEXT NOT NULL REFERENCES logical_threads(public_thread_id) ON DELETE CASCADE,
-        ordinal INTEGER NOT NULL,
-        provider TEXT NOT NULL CHECK(provider IN ('claude', 'stock')),
-        backend_thread_id TEXT NOT NULL,
-        model TEXT NOT NULL,
-        settings_json TEXT NOT NULL,
-        state TEXT NOT NULL CHECK(state IN ('current', 'sealed', 'provisional')),
-        created_at INTEGER NOT NULL,
-        sealed_at INTEGER,
-        archive_pending INTEGER NOT NULL DEFAULT 0,
-        delete_done INTEGER NOT NULL DEFAULT 0,
-        UNIQUE(public_thread_id, ordinal),
-        UNIQUE(provider, backend_thread_id)
-      );
-      CREATE UNIQUE INDEX IF NOT EXISTS provider_epochs_one_current
-        ON provider_epochs(public_thread_id) WHERE state = 'current';
-      CREATE INDEX IF NOT EXISTS provider_epochs_public
-        ON provider_epochs(public_thread_id, ordinal);
-      CREATE TABLE IF NOT EXISTS logical_turns (
-        public_thread_id TEXT NOT NULL REFERENCES logical_threads(public_thread_id) ON DELETE CASCADE,
-        position INTEGER NOT NULL,
-        public_turn_id TEXT NOT NULL,
-        epoch_id TEXT REFERENCES provider_epochs(epoch_id),
-        provider_turn_id TEXT,
-        turn_json TEXT NOT NULL,
-        kind TEXT NOT NULL CHECK(kind IN ('provider', 'migrationCompact')),
-        PRIMARY KEY(public_thread_id, position),
-        UNIQUE(public_thread_id, public_turn_id),
-        CHECK((kind = 'provider' AND epoch_id IS NOT NULL AND provider_turn_id IS NOT NULL)
-          OR (kind = 'migrationCompact' AND epoch_id IS NULL AND provider_turn_id IS NULL))
-      );
-      CREATE UNIQUE INDEX IF NOT EXISTS logical_turns_provider
-        ON logical_turns(public_thread_id, epoch_id, provider_turn_id)
-        WHERE epoch_id IS NOT NULL AND provider_turn_id IS NOT NULL;
-      CREATE TABLE IF NOT EXISTS provider_switch_jobs (
-        job_id TEXT PRIMARY KEY,
-        public_thread_id TEXT NOT NULL REFERENCES logical_threads(public_thread_id) ON DELETE CASCADE,
-        expected_epoch_id TEXT NOT NULL REFERENCES provider_epochs(epoch_id),
-        expected_thread_revision INTEGER NOT NULL,
-        pending_revision INTEGER NOT NULL,
-        target_provider TEXT NOT NULL CHECK(target_provider IN ('claude', 'stock')),
-        target_model TEXT NOT NULL,
-        settings_json TEXT NOT NULL,
-        turn_params_json TEXT NOT NULL,
-        compaction_turn_json TEXT NOT NULL,
-        status TEXT NOT NULL CHECK(status IN ('queued', 'running', 'targetCreated', 'committed', 'failed')),
-        summary TEXT,
-        target_backend_thread_id TEXT,
-        target_provider_turn_id TEXT,
-        error TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE UNIQUE INDEX IF NOT EXISTS provider_switch_jobs_active
-        ON provider_switch_jobs(public_thread_id)
-        WHERE status IN ('queued', 'running', 'targetCreated');
-      CREATE INDEX IF NOT EXISTS provider_switch_jobs_recovery
-        ON provider_switch_jobs(status, created_at);
-      CREATE TABLE IF NOT EXISTS provider_switch_jobs_v2 (
-        job_id TEXT PRIMARY KEY,
-        public_thread_id TEXT NOT NULL,
-        expected_epoch_id TEXT NOT NULL,
-        expected_thread_revision INTEGER NOT NULL,
-        pending_revision INTEGER NOT NULL,
-        target_provider TEXT NOT NULL CHECK(target_provider IN ('claude', 'stock')),
-        target_model TEXT NOT NULL,
-        settings_json TEXT NOT NULL,
-        turn_params_json TEXT NOT NULL,
-        compaction_turn_json TEXT NOT NULL,
-        status TEXT NOT NULL CHECK(status IN ('queued', 'running', 'targetCreated', 'committed', 'failed')),
-        summary TEXT,
-        target_backend_thread_id TEXT,
-        target_provider_turn_id TEXT,
-        error TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE UNIQUE INDEX IF NOT EXISTS provider_switch_jobs_v2_active
-        ON provider_switch_jobs_v2(public_thread_id)
-        WHERE status IN ('queued', 'running', 'targetCreated');
-      CREATE INDEX IF NOT EXISTS provider_switch_jobs_v2_recovery
-        ON provider_switch_jobs_v2(status, created_at);
-      CREATE TABLE IF NOT EXISTS fork_selections (
-        target_public_thread_id TEXT PRIMARY KEY REFERENCES logical_threads(public_thread_id) ON DELETE CASCADE,
-        source_public_thread_id TEXT NOT NULL REFERENCES logical_threads(public_thread_id) ON DELETE CASCADE,
-        provisional_epoch_id TEXT NOT NULL REFERENCES provider_epochs(epoch_id),
-        expected_target_revision INTEGER NOT NULL,
-        selected_epoch_id TEXT REFERENCES provider_epochs(epoch_id),
-        status TEXT NOT NULL CHECK(status IN ('pending', 'finalized')),
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS remote_catalog_tombstones (
-        thread_id TEXT PRIMARY KEY,
-        created_at INTEGER NOT NULL
-      );
-    `);
-        const pendingColumns = this.database.prepare("PRAGMA table_info(pending_provider_switches)")
-            .all();
-        if (!pendingColumns.some((column) => column.name === "revision")) {
-            this.database.exec("ALTER TABLE pending_provider_switches ADD COLUMN revision INTEGER NOT NULL DEFAULT 1");
-        }
-        if (!pendingColumns.some((column) => column.name === "expected_epoch_id")) {
-            this.database.exec("ALTER TABLE pending_provider_switches ADD COLUMN expected_epoch_id TEXT");
-        }
-        const jobColumns = this.database.prepare("PRAGMA table_info(handoff_jobs)")
-            .all();
-        if (!jobColumns.some((column) => column.name === "target_json")) {
-            this.database.exec("ALTER TABLE handoff_jobs ADD COLUMN target_json TEXT");
-        }
-        const switchColumns = this.database.prepare("PRAGMA table_info(provider_switch_jobs)")
-            .all();
-        if (!switchColumns.some((column) => column.name === "compaction_turn_json")) {
-            this.database.exec("ALTER TABLE provider_switch_jobs ADD COLUMN compaction_turn_json TEXT");
-        }
-        this.database.exec(`
-      INSERT OR IGNORE INTO provider_switch_jobs_v2 (
-        job_id, public_thread_id, expected_epoch_id, expected_thread_revision, pending_revision,
-        target_provider, target_model, settings_json, turn_params_json, compaction_turn_json,
-        status, summary, target_backend_thread_id, target_provider_turn_id, error, created_at, updated_at
-      )
-      SELECT job_id, public_thread_id, expected_epoch_id, expected_thread_revision, pending_revision,
-        target_provider, target_model, settings_json, turn_params_json,
-        COALESCE(compaction_turn_json, '{}'), status, summary, target_backend_thread_id,
-        target_provider_turn_id, error, created_at, updated_at
-      FROM provider_switch_jobs
-    `);
-        const epochColumns = this.database.prepare("PRAGMA table_info(provider_epochs)")
-            .all();
-        if (!epochColumns.some((column) => column.name === "archive_pending")) {
-            this.database.exec("ALTER TABLE provider_epochs ADD COLUMN archive_pending INTEGER NOT NULL DEFAULT 0");
-        }
-        if (!epochColumns.some((column) => column.name === "delete_done")) {
-            this.database.exec("ALTER TABLE provider_epochs ADD COLUMN delete_done INTEGER NOT NULL DEFAULT 0");
-        }
-        chmodSync(path, 0o600);
-    }
-    setPending(pending) {
-        this.database.prepare(`
-      INSERT INTO pending_provider_switches (
-        thread_id, source_provider, target_provider, target_model, settings_json, updated_at, revision,
-        expected_epoch_id
-      ) VALUES (?, ?, ?, ?, ?, ?, 1, ?)
-      ON CONFLICT(thread_id) DO UPDATE SET
-        source_provider = excluded.source_provider,
-        target_provider = excluded.target_provider,
-        target_model = excluded.target_model,
-        settings_json = excluded.settings_json,
-        updated_at = excluded.updated_at,
-        expected_epoch_id = excluded.expected_epoch_id,
-        revision = pending_provider_switches.revision + 1
-    `).run(pending.threadId, pending.sourceProvider, pending.targetProvider, pending.targetModel, JSON.stringify(pending.settings), Date.now(), pending.expectedEpochId ?? null);
-        return this.getPending(pending.threadId);
-    }
-    getPending(threadId) {
-        const row = this.database.prepare("SELECT * FROM pending_provider_switches WHERE thread_id = ?")
-            .get(threadId);
-        return row ? {
-            threadId: row.thread_id,
-            sourceProvider: row.source_provider,
-            targetProvider: row.target_provider,
-            targetModel: row.target_model,
-            settings: JSON.parse(row.settings_json),
-            revision: row.revision,
-            ...(row.expected_epoch_id ? { expectedEpochId: row.expected_epoch_id } : {}),
-        } : undefined;
-    }
-    clearPending(threadId, revision) {
-        const result = revision === undefined
-            ? this.database.prepare("DELETE FROM pending_provider_switches WHERE thread_id = ?").run(threadId)
-            : this.database.prepare("DELETE FROM pending_provider_switches WHERE thread_id = ? AND revision = ?")
-                .run(threadId, revision);
-        return Number(result.changes) > 0;
-    }
-    cancelProviderSwitches(threadId, reason) {
-        this.transaction(() => {
-            this.database.prepare(`
-        UPDATE provider_switch_jobs_v2 SET status = 'failed', error = ?, updated_at = ?
-        WHERE public_thread_id = ? AND status IN ('queued', 'running', 'targetCreated')
-      `).run(reason, Date.now(), threadId);
-            this.database.prepare("DELETE FROM pending_provider_switches WHERE thread_id = ?").run(threadId);
-        });
-    }
-    createLogicalThread(input) {
-        const now = input.epoch.createdAt ?? Date.now();
-        return this.transaction(() => {
-            this.database.prepare(`
-        INSERT INTO logical_threads (
-          public_thread_id, current_epoch_id, thread_json, revision, created_at, updated_at
-        ) VALUES (?, ?, ?, 1, ?, ?)
-      `).run(input.thread.id, input.epoch.id, JSON.stringify(threadIdentity(input.thread)), now, now);
-            this.insertEpoch(input.thread.id, 0, input.epoch, "current", now);
-            return this.getLogicalThread(input.thread.id);
-        });
-    }
-    getLogicalThread(publicThreadId) {
-        const row = this.database.prepare("SELECT * FROM logical_threads WHERE public_thread_id = ?")
-            .get(publicThreadId);
-        return row ? this.logicalThreadFromRow(row) : undefined;
-    }
-    updateLogicalThread(publicThreadId, expectedRevision, thread) {
-        const result = this.database.prepare(`
-      UPDATE logical_threads SET thread_json = ?, updated_at = ?
-      WHERE public_thread_id = ? AND revision = ?
-    `).run(JSON.stringify(threadIdentity({ ...thread, id: publicThreadId })), Date.now(), publicThreadId, expectedRevision);
-        return Number(result.changes) === 1 ? this.getLogicalThread(publicThreadId) : undefined;
-    }
-    deleteLogicalThread(publicThreadId) {
-        return Number(this.database.prepare("DELETE FROM logical_threads WHERE public_thread_id = ?")
-            .run(publicThreadId).changes) === 1;
-    }
-    getEpoch(epochId) {
-        const row = this.database.prepare("SELECT * FROM provider_epochs WHERE epoch_id = ?")
-            .get(epochId);
-        return row ? this.epochFromRow(row) : undefined;
-    }
-    listEpochs(publicThreadId) {
-        return this.database.prepare(`
-      SELECT * FROM provider_epochs WHERE public_thread_id = ? ORDER BY ordinal ASC
-    `).all(publicThreadId).map((row) => this.epochFromRow(row));
-    }
-    pendingStockArchives() {
-        return this.database.prepare(`
-      SELECT * FROM provider_epochs
-      WHERE provider = 'stock' AND state = 'sealed' AND archive_pending = 1
-      ORDER BY sealed_at ASC
-    `).all().map((row) => this.epochFromRow(row));
-    }
-    markStockArchived(epochId) {
-        return Number(this.database.prepare(`
-      UPDATE provider_epochs SET archive_pending = 0
-      WHERE epoch_id = ? AND provider = 'stock' AND state = 'sealed'
-    `).run(epochId).changes) === 1;
-    }
-    markEpochDeleted(epochId) {
-        return Number(this.database.prepare(`
-      UPDATE provider_epochs SET delete_done = 1 WHERE epoch_id = ?
-    `).run(epochId).changes) === 1;
-    }
-    addRemoteCatalogTombstone(threadId) {
-        this.database.prepare(`
-      INSERT INTO remote_catalog_tombstones(thread_id, created_at) VALUES (?, ?)
-      ON CONFLICT(thread_id) DO UPDATE SET created_at = excluded.created_at
-    `).run(threadId, Date.now());
-        this.database.prepare(`
-      DELETE FROM remote_catalog_tombstones WHERE thread_id IN (
-        SELECT thread_id FROM remote_catalog_tombstones ORDER BY created_at DESC LIMIT -1 OFFSET 4096
-      )
-    `).run();
-    }
-    remoteCatalogTombstones() {
-        return this.database.prepare(`
-      SELECT thread_id FROM remote_catalog_tombstones ORDER BY created_at ASC
-    `).all().map((row) => row.thread_id);
-    }
-    updateCurrentEpoch(publicThreadId, expectedEpochId, patch) {
-        return this.transaction(() => {
-            const logical = this.getLogicalThread(publicThreadId);
-            const epoch = logical && this.getEpoch(expectedEpochId);
-            if (!logical || logical.currentEpochId !== expectedEpochId || epoch?.state !== "current")
-                return undefined;
-            // Provider settings belong to the native provider stores. This legacy
-            // row only guards operational transactions; a copy here becomes stale.
-            void patch;
-            return epoch;
-        });
-    }
-    findEpochByBackend(provider, backendThreadId) {
-        const row = this.database.prepare(`
-      SELECT * FROM provider_epochs WHERE provider = ? AND backend_thread_id = ?
-    `).get(provider, backendThreadId);
-        return row ? this.epochFromRow(row) : undefined;
-    }
-    listBackendMappings() {
-        return this.database.prepare(`
-      SELECT public_thread_id, epoch_id, provider, backend_thread_id, state
-      FROM provider_epochs ORDER BY public_thread_id ASC, ordinal ASC
-    `).all().map((row) => ({
-            publicThreadId: row.public_thread_id,
-            epochId: row.epoch_id,
-            provider: row.provider,
-            backendThreadId: row.backend_thread_id,
-            state: row.state,
-        }));
-    }
-    listLogicalTurns(publicThreadId) {
-        return this.database.prepare(`
-      SELECT * FROM logical_turns WHERE public_thread_id = ? ORDER BY position ASC
-    `).all(publicThreadId).map((row) => this.logicalTurnFromRow(row));
-    }
-    findLogicalTurn(publicThreadId, publicTurnId) {
-        const row = this.database.prepare(`
-      SELECT * FROM logical_turns WHERE public_thread_id = ? AND public_turn_id = ?
-    `).get(publicThreadId, publicTurnId);
-        return row ? this.logicalTurnFromRow(row) : undefined;
-    }
-    replaceLogicalTurns(publicThreadId, expectedThreadRevision, turns) {
-        return this.transaction(() => {
-            const current = this.getLogicalThread(publicThreadId);
-            if (!current || current.revision !== expectedThreadRevision)
-                return false;
-            this.replaceTurns(publicThreadId, turns);
-            const result = this.database.prepare(`
-        UPDATE logical_threads SET revision = revision + 1, updated_at = ?
-        WHERE public_thread_id = ? AND revision = ?
-      `).run(Date.now(), publicThreadId, expectedThreadRevision);
-            return Number(result.changes) === 1;
-        });
-    }
-    stageProviderSwitch(input) {
-        return this.transaction(() => {
-            const logical = this.getLogicalThread(input.pending.threadId);
-            const epoch = logical && this.getEpoch(logical.currentEpochId);
-            if (!logical || logical.currentEpochId !== input.expectedEpochId
-                || epoch?.provider !== input.pending.sourceProvider)
-                return undefined;
-            return this.setPending({ ...input.pending, expectedEpochId: input.expectedEpochId });
-        });
-    }
-    createProviderSwitchJob(input) {
-        return this.transaction(() => {
-            const logical = this.getLogicalThread(input.publicThreadId);
-            const pending = this.getPending(input.publicThreadId);
-            const active = this.database.prepare(`
-        SELECT 1 AS found FROM provider_switch_jobs_v2
-        WHERE public_thread_id = ? AND status IN ('queued', 'running', 'targetCreated')
-      `).get(input.publicThreadId);
-            const expectedThreadRevision = input.expectedThreadRevision ?? logical?.revision;
-            if (expectedThreadRevision === undefined || active
-                || pending?.revision !== input.pendingRevision || pending.expectedEpochId !== input.expectedEpochId
-                || pending.targetProvider !== input.targetProvider || pending.targetModel !== input.targetModel)
-                return undefined;
-            const now = input.createdAt ?? Date.now();
-            this.database.prepare(`
-        INSERT INTO provider_switch_jobs_v2 (
-          job_id, public_thread_id, expected_epoch_id, expected_thread_revision, pending_revision,
-          target_provider, target_model, settings_json, turn_params_json, status, created_at, updated_at
-          , compaction_turn_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?, ?)
-      `).run(input.id, input.publicThreadId, input.expectedEpochId, expectedThreadRevision, input.pendingRevision, input.targetProvider, input.targetModel, JSON.stringify(input.settings), JSON.stringify(input.turnParams), now, now, JSON.stringify(input.compactionTurn));
-            return this.getProviderSwitchJob(input.id);
-        });
-    }
-    completeProviderSwitch(jobId) {
-        return this.transaction(() => {
-            const job = this.getProviderSwitchJob(jobId);
-            if (!job || job.status !== "targetCreated")
-                return job?.status === "committed";
-            this.database.prepare(`
-        DELETE FROM pending_provider_switches
-        WHERE thread_id = ? AND revision = ? AND expected_epoch_id = ?
-      `).run(job.publicThreadId, job.pendingRevision, job.expectedEpochId);
-            return Number(this.database.prepare(`
-        DELETE FROM provider_switch_jobs_v2 WHERE job_id = ? AND status = 'targetCreated'
-      `).run(jobId).changes) === 1;
-        });
-    }
-    getProviderSwitchJob(jobId) {
-        const row = this.database.prepare("SELECT * FROM provider_switch_jobs_v2 WHERE job_id = ?")
-            .get(jobId);
-        return row ? this.providerSwitchJobFromRow(row) : undefined;
-    }
-    recoverableProviderSwitchJobs() {
-        return this.database.prepare(`
-      SELECT * FROM provider_switch_jobs_v2
-      WHERE status IN ('queued', 'running', 'targetCreated') ORDER BY created_at ASC
-    `).all().map((row) => this.providerSwitchJobFromRow(row));
-    }
-    hiddenProviderSwitchTargetIds() {
-        return this.database.prepare(`
-      SELECT DISTINCT target_backend_thread_id AS thread_id FROM provider_switch_jobs_v2
-      WHERE target_backend_thread_id IS NOT NULL AND status != 'committed'
-    `).all().map((row) => row.thread_id);
-    }
-    claimProviderSwitchJob(jobId) {
-        const result = this.database.prepare(`
-      UPDATE provider_switch_jobs_v2 SET status = 'running', updated_at = ?
-      WHERE job_id = ? AND status = 'queued'
-    `).run(Date.now(), jobId);
-        return Number(result.changes) === 1 ? this.getProviderSwitchJob(jobId) : undefined;
-    }
-    requeueProviderSwitchJob(jobId) {
-        const result = this.database.prepare(`
-      UPDATE provider_switch_jobs_v2 SET
-        status = 'queued', summary = NULL, target_backend_thread_id = NULL,
-        target_provider_turn_id = NULL, error = NULL, updated_at = ?
-      WHERE job_id = ? AND status IN ('running', 'targetCreated')
-    `).run(Date.now(), jobId);
-        return Number(result.changes) === 1 ? this.getProviderSwitchJob(jobId) : this.getProviderSwitchJob(jobId);
-    }
-    checkpointProviderSwitchTarget(jobId, checkpoint) {
-        return this.transaction(() => {
-            const job = this.getProviderSwitchJob(jobId);
-            if (!job || !["running", "targetCreated"].includes(job.status)
-                || (job.targetBackendThreadId && job.targetBackendThreadId !== checkpoint.backendThreadId))
-                return false;
-            const result = this.database.prepare(`
-        UPDATE provider_switch_jobs_v2 SET
-          status = 'targetCreated', target_backend_thread_id = ?,
-          summary = COALESCE(?, summary), target_provider_turn_id = COALESCE(?, target_provider_turn_id),
-          updated_at = ?
-        WHERE job_id = ? AND status IN ('running', 'targetCreated')
-      `).run(checkpoint.backendThreadId, checkpoint.summary ?? null, checkpoint.providerTurnId ?? null, Date.now(), jobId);
-            return Number(result.changes) === 1;
-        });
-    }
-    commitProviderSwitch(input) {
-        return this.transaction(() => {
-            const job = this.getProviderSwitchJob(input.jobId);
-            const logical = job && this.getLogicalThread(job.publicThreadId);
-            const pending = job && this.getPending(job.publicThreadId);
-            if (!job || job.status !== "targetCreated" || !job.targetProviderTurnId || !logical
-                || logical.currentEpochId !== job.expectedEpochId || logical.revision !== job.expectedThreadRevision
-                || pending?.revision !== job.pendingRevision || pending.expectedEpochId !== job.expectedEpochId
-                || input.targetEpoch.provider !== job.targetProvider || input.targetEpoch.model !== job.targetModel
-                || input.targetEpoch.backendThreadId !== job.targetBackendThreadId)
-                return undefined;
-            const committedAt = input.committedAt ?? Date.now();
-            const ordinal = this.database.prepare(`
-        SELECT COALESCE(MAX(ordinal), -1) + 1 AS ordinal FROM provider_epochs WHERE public_thread_id = ?
-      `).get(job.publicThreadId).ordinal;
-            this.database.prepare(`
-        UPDATE provider_epochs SET state = 'sealed', sealed_at = ?,
-          archive_pending = CASE WHEN provider = 'stock' THEN 1 ELSE 0 END
-        WHERE epoch_id = ? AND public_thread_id = ? AND state = 'current'
-      `).run(committedAt, job.expectedEpochId, job.publicThreadId);
-            this.insertEpoch(job.publicThreadId, ordinal, input.targetEpoch, "current", committedAt);
-            this.replaceTurns(job.publicThreadId, input.sourceTurns);
-            const update = this.database.prepare(`
-        UPDATE logical_threads SET current_epoch_id = ?, thread_json = ?, revision = revision + 1, updated_at = ?
-        WHERE public_thread_id = ? AND current_epoch_id = ? AND revision = ?
-      `).run(input.targetEpoch.id, JSON.stringify(threadIdentity(input.thread)), committedAt, job.publicThreadId, job.expectedEpochId, job.expectedThreadRevision);
-            if (Number(update.changes) !== 1)
-                throw new Error("Provider switch lost its logical-thread CAS during commit.");
-            this.database.prepare(`
-        DELETE FROM pending_provider_switches WHERE thread_id = ? AND revision = ? AND expected_epoch_id = ?
-      `).run(job.publicThreadId, job.pendingRevision, job.expectedEpochId);
-            this.database.prepare(`
-        UPDATE provider_switch_jobs_v2 SET status = 'committed', error = NULL, updated_at = ?
-        WHERE job_id = ? AND status = 'targetCreated'
-      `).run(committedAt, job.id);
-            return this.getLogicalThread(job.publicThreadId);
-        });
-    }
-    failProviderSwitch(jobId, error) {
-        return this.transaction(() => {
-            const job = this.getProviderSwitchJob(jobId);
-            if (!job || !["queued", "running", "targetCreated"].includes(job.status))
-                return false;
-            const result = this.database.prepare(`
-        UPDATE provider_switch_jobs_v2 SET status = 'failed', error = ?,
-          settings_json = '{}', turn_params_json = '{}', compaction_turn_json = '{}',
-          summary = NULL, target_provider_turn_id = NULL, updated_at = ?
-        WHERE job_id = ? AND status IN ('queued', 'running', 'targetCreated')
-      `).run(error, Date.now(), jobId);
-            if (Number(result.changes) !== 1)
-                return false;
-            const logical = this.getLogicalThread(job.publicThreadId);
-            if (logical?.currentEpochId === job.expectedEpochId) {
-                this.database.prepare(`
-          DELETE FROM pending_provider_switches WHERE thread_id = ? AND revision = ? AND expected_epoch_id = ?
-        `).run(job.publicThreadId, job.pendingRevision, job.expectedEpochId);
-            }
-            return true;
-        });
-    }
-    createForkSelection(selection) {
-        return this.transaction(() => {
-            const epoch = this.getEpoch(selection.provisionalEpochId);
-            const target = this.getLogicalThread(selection.targetPublicThreadId);
-            if (!epoch || epoch.publicThreadId !== selection.targetPublicThreadId
-                || target?.currentEpochId !== selection.provisionalEpochId
-                || !this.getLogicalThread(selection.sourcePublicThreadId))
-                return false;
-            const now = selection.createdAt ?? Date.now();
-            const result = this.database.prepare(`
-        INSERT OR IGNORE INTO fork_selections (
-          target_public_thread_id, source_public_thread_id, provisional_epoch_id, expected_target_revision,
-          status, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, 'pending', ?, ?)
-      `).run(selection.targetPublicThreadId, selection.sourcePublicThreadId, selection.provisionalEpochId, target.revision, now, now);
-            return Number(result.changes) === 1;
-        });
-    }
-    getForkSelection(targetPublicThreadId) {
-        const row = this.database.prepare("SELECT * FROM fork_selections WHERE target_public_thread_id = ?")
-            .get(targetPublicThreadId);
-        return row ? this.forkSelectionFromRow(row) : undefined;
-    }
-    epochBelongsToLineage(publicThreadId, epochId) {
-        const epoch = this.getEpoch(epochId);
-        if (!epoch)
-            return false;
-        const visited = new Set();
-        let threadId = publicThreadId;
-        while (threadId && !visited.has(threadId)) {
-            if (epoch.publicThreadId === threadId)
-                return true;
-            visited.add(threadId);
-            const logical = this.getLogicalThread(threadId);
-            const forkedFromId = logical?.thread.forkedFromId;
-            threadId = this.getForkSelection(threadId)?.sourcePublicThreadId
-                ?? (typeof forkedFromId === "string" && this.getLogicalThread(forkedFromId) ? forkedFromId : undefined);
-        }
-        return false;
-    }
-    finalizeForkSelection(targetPublicThreadId, expectedProvisionalEpochId, selectedEpochId) {
-        return this.transaction(() => {
-            const selection = this.getForkSelection(targetPublicThreadId);
-            const selected = this.getEpoch(selectedEpochId);
-            if (!selection || selection.status !== "pending"
-                || selection.provisionalEpochId !== expectedProvisionalEpochId
-                || this.getLogicalThread(targetPublicThreadId)?.revision !== selection.expectedTargetRevision
-                || selected?.publicThreadId !== selection.sourcePublicThreadId)
-                return false;
-            const result = this.database.prepare(`
-        UPDATE fork_selections SET selected_epoch_id = ?, status = 'finalized', updated_at = ?
-        WHERE target_public_thread_id = ? AND provisional_epoch_id = ? AND status = 'pending'
-      `).run(selectedEpochId, Date.now(), targetPublicThreadId, expectedProvisionalEpochId);
-            return Number(result.changes) === 1;
-        });
-    }
-    commitLogicalRollback(input) {
-        return this.transaction(() => {
-            const target = this.getLogicalThread(input.targetPublicThreadId);
-            const current = this.getEpoch(input.expectedCurrentEpochId);
-            const selected = this.getEpoch(input.selectedEpochId);
-            const selection = this.getForkSelection(input.targetPublicThreadId);
-            const pending = selection?.status === "pending" ? selection : undefined;
-            if (!target || target.revision !== input.expectedThreadRevision
-                || target.currentEpochId !== input.expectedCurrentEpochId
-                || current?.publicThreadId !== target.publicThreadId || current.state !== "current"
-                || !selected
-                || input.targetEpoch.provider !== selected.provider)
-                return undefined;
-            if (pending) {
-                if (pending.expectedTargetRevision !== input.expectedThreadRevision
-                    || input.expectedCurrentEpochId !== pending.provisionalEpochId
-                    || !this.epochBelongsToLineage(pending.sourcePublicThreadId, selected.id))
-                    return undefined;
-            }
-            else if (!this.epochBelongsToLineage(target.publicThreadId, selected.id)) {
-                return undefined;
-            }
-            const committedAt = input.committedAt ?? Date.now();
-            const ordinal = this.database.prepare(`
-        SELECT COALESCE(MAX(ordinal), -1) + 1 AS ordinal FROM provider_epochs WHERE public_thread_id = ?
-      `).get(target.publicThreadId).ordinal;
-            this.database.prepare(`
-        UPDATE provider_epochs SET state = 'sealed', sealed_at = ?,
-          archive_pending = CASE WHEN provider = 'stock' THEN 1 ELSE 0 END
-        WHERE epoch_id = ? AND public_thread_id = ? AND state = 'current'
-      `).run(committedAt, current.id, target.publicThreadId);
-            this.insertEpoch(target.publicThreadId, ordinal, input.targetEpoch, "current", committedAt);
-            this.replaceTurns(target.publicThreadId, input.turns);
-            const updated = this.database.prepare(`
-        UPDATE logical_threads SET current_epoch_id = ?, thread_json = ?, revision = revision + 1, updated_at = ?
-        WHERE public_thread_id = ? AND current_epoch_id = ? AND revision = ?
-      `).run(input.targetEpoch.id, JSON.stringify(threadIdentity(input.thread)), committedAt, target.publicThreadId, current.id, input.expectedThreadRevision);
-            if (Number(updated.changes) !== 1)
-                throw new Error("Rollback lost its logical-thread CAS during commit.");
-            if (pending) {
-                const finalized = this.database.prepare(`
-          UPDATE fork_selections SET selected_epoch_id = ?, status = 'finalized', updated_at = ?
-          WHERE target_public_thread_id = ? AND provisional_epoch_id = ? AND status = 'pending'
-        `).run(selected.id, committedAt, target.publicThreadId, pending.provisionalEpochId);
-                if (Number(finalized.changes) !== 1)
-                    throw new Error("Rollback lost its fork finalize CAS during commit.");
-            }
-            return this.getLogicalThread(target.publicThreadId);
-        });
-    }
-    createJob(job) {
-        const now = Date.now();
-        this.database.prepare(`
-      INSERT INTO handoff_jobs (
-        job_id, source_thread_id, params_json, pending_json, status, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, 'queued', ?, ?)
-    `).run(job.id, job.sourceThreadId, JSON.stringify(job.params), job.pending ? JSON.stringify(job.pending) : null, now, now);
-        return { ...job, status: "queued" };
-    }
-    recoverableJobs() {
-        const rows = this.database.prepare(`
-      SELECT * FROM handoff_jobs WHERE status IN ('queued', 'running') ORDER BY created_at ASC
-    `).all();
-        this.database.prepare(`
-      UPDATE handoff_jobs SET status = 'queued', updated_at = ? WHERE status = 'running'
-    `).run(Date.now());
-        return rows.map((row) => this.jobFromRow({ ...row, status: "queued" }));
-    }
-    markJobRunning(jobId) {
-        this.database.prepare(`
-      UPDATE handoff_jobs SET status = 'running', updated_at = ? WHERE job_id = ?
-    `).run(Date.now(), jobId);
-    }
-    completeJob(jobId, result) {
-        this.database.prepare(`
-      UPDATE handoff_jobs
-      SET status = 'completed', result_json = ?, error = NULL, updated_at = ?
-      WHERE job_id = ?
-    `).run(JSON.stringify(result), Date.now(), jobId);
-    }
-    checkpointJobTarget(jobId, target) {
-        this.database.prepare(`
-      UPDATE handoff_jobs SET target_json = ?, updated_at = ? WHERE job_id = ?
-    `).run(JSON.stringify(target), Date.now(), jobId);
-    }
-    clearJobTarget(jobId) {
-        this.database.prepare(`
-      UPDATE handoff_jobs SET target_json = NULL, updated_at = ? WHERE job_id = ?
-    `).run(Date.now(), jobId);
-    }
-    failJob(jobId, error) {
-        this.database.prepare(`
-      UPDATE handoff_jobs
-      SET status = 'failed', error = ?, updated_at = ?
-      WHERE job_id = ?
-    `).run(error, Date.now(), jobId);
-    }
-    claimFailedJob(sourceThreadId) {
-        const row = this.database.prepare(`
-      SELECT * FROM handoff_jobs
-      WHERE source_thread_id = ? AND status = 'failed' AND error_notified = 0
-      ORDER BY updated_at ASC LIMIT 1
-    `).get(sourceThreadId);
-        if (!row?.error)
-            return undefined;
-        this.database.prepare(`
-      UPDATE handoff_jobs SET error_notified = 1, updated_at = ? WHERE job_id = ?
-    `).run(Date.now(), row.job_id);
-        return row.error;
-    }
-    setOverlay(overlay) {
-        this.database.prepare(`
-      INSERT INTO stock_history_overlays (
-        thread_id, source_thread_id, source_thread_json, turns_json, created_at
-      ) VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(thread_id) DO UPDATE SET
-        source_thread_id = excluded.source_thread_id,
-        source_thread_json = excluded.source_thread_json,
-        turns_json = excluded.turns_json
-    `).run(overlay.threadId, overlay.sourceThreadId, JSON.stringify(overlay.sourceThread), JSON.stringify(overlay.inheritedTurns), Date.now());
-    }
-    getOverlay(threadId) {
-        const row = this.database.prepare("SELECT * FROM stock_history_overlays WHERE thread_id = ?")
-            .get(threadId);
-        return row ? {
-            threadId: row.thread_id,
-            sourceThreadId: row.source_thread_id,
-            sourceThread: JSON.parse(row.source_thread_json),
-            inheritedTurns: JSON.parse(row.turns_json),
-        } : undefined;
-    }
-    clearOverlay(threadId) {
-        this.database.prepare("DELETE FROM stock_history_overlays WHERE thread_id = ?").run(threadId);
-    }
-    saveSideThread(record) {
-        this.database.prepare("INSERT OR REPLACE INTO side_threads (public_thread_id, record_json) VALUES (?, ?)")
-            .run(record.response.thread.id, JSON.stringify(record));
-    }
-    sideThreads() {
-        return this.database.prepare("SELECT record_json FROM side_threads").all()
-            .map((row) => JSON.parse(row.record_json));
-    }
-    deleteSideThread(threadId) {
-        this.database.prepare("DELETE FROM side_threads WHERE public_thread_id = ?").run(threadId);
-    }
-    close() {
-        this.database.close();
-    }
-    jobFromRow(row) {
-        return {
-            id: row.job_id,
-            sourceThreadId: row.source_thread_id,
-            params: JSON.parse(row.params_json),
-            ...(row.pending_json
-                ? { pending: JSON.parse(row.pending_json) }
-                : {}),
-            status: row.status,
-            ...(row.result_json ? { result: JSON.parse(row.result_json) } : {}),
-            ...(row.target_json ? { target: JSON.parse(row.target_json) } : {}),
-            ...(row.error ? { error: row.error } : {}),
-        };
-    }
-    insertEpoch(publicThreadId, ordinal, epoch, state, defaultCreatedAt) {
-        this.database.prepare(`
-      INSERT INTO provider_epochs (
-        epoch_id, public_thread_id, ordinal, provider, backend_thread_id,
-        model, settings_json, state, created_at, sealed_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
-    `).run(epoch.id, publicThreadId, ordinal, epoch.provider, epoch.backendThreadId, "", "{}", state, epoch.createdAt ?? defaultCreatedAt);
-    }
-    replaceTurns(publicThreadId, turns) {
-        this.database.prepare("DELETE FROM logical_turns WHERE public_thread_id = ?").run(publicThreadId);
-        const insert = this.database.prepare(`
-      INSERT INTO logical_turns (
-        public_thread_id, position, public_turn_id, epoch_id, provider_turn_id, turn_json, kind
-      ) VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        turns.forEach((turn, position) => {
-            if (turn.publicTurnId !== turn.turn.id) {
-                throw new Error(`Logical turn id '${turn.publicTurnId}' does not match payload '${turn.turn.id}'.`);
-            }
-            insert.run(publicThreadId, position, turn.publicTurnId, turn.epochId ?? null, turn.providerTurnId ?? null, JSON.stringify(turn.kind === "provider" ? { id: turn.publicTurnId } : turn.turn), turn.kind);
-        });
-    }
-    logicalThreadFromRow(row) {
-        return {
-            publicThreadId: row.public_thread_id,
-            currentEpochId: row.current_epoch_id,
-            thread: JSON.parse(row.thread_json),
-            revision: row.revision,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        };
-    }
-    epochFromRow(row) {
-        return {
-            id: row.epoch_id,
-            publicThreadId: row.public_thread_id,
-            ordinal: row.ordinal,
-            provider: row.provider,
-            backendThreadId: row.backend_thread_id,
-            model: row.model,
-            settings: JSON.parse(row.settings_json),
-            state: row.state,
-            createdAt: row.created_at,
-            ...(row.sealed_at === null ? {} : { sealedAt: row.sealed_at }),
-            archivePending: row.archive_pending === 1,
-            deleteDone: row.delete_done === 1,
-        };
-    }
-    logicalTurnFromRow(row) {
-        return {
-            publicThreadId: row.public_thread_id,
-            position: row.position,
-            publicTurnId: row.public_turn_id,
-            ...(row.epoch_id ? { epochId: row.epoch_id } : {}),
-            ...(row.provider_turn_id ? { providerTurnId: row.provider_turn_id } : {}),
-            turn: JSON.parse(row.turn_json),
-            kind: row.kind,
-        };
-    }
-    providerSwitchJobFromRow(row) {
-        return {
-            id: row.job_id,
-            publicThreadId: row.public_thread_id,
-            expectedEpochId: row.expected_epoch_id,
-            expectedThreadRevision: row.expected_thread_revision,
-            pendingRevision: row.pending_revision,
-            targetProvider: row.target_provider,
-            targetModel: row.target_model,
-            settings: JSON.parse(row.settings_json),
-            turnParams: JSON.parse(row.turn_params_json),
-            compactionTurn: row.compaction_turn_json
-                ? JSON.parse(row.compaction_turn_json)
-                : {
-                    id: row.job_id, items: [], itemsView: "full", status: "inProgress", error: null,
-                    startedAt: null, completedAt: null, durationMs: null,
-                },
-            status: row.status,
-            ...(row.summary === null ? {} : { summary: row.summary }),
-            ...(row.target_backend_thread_id === null ? {} : { targetBackendThreadId: row.target_backend_thread_id }),
-            ...(row.target_provider_turn_id === null ? {} : { targetProviderTurnId: row.target_provider_turn_id }),
-            ...(row.error === null ? {} : { error: row.error }),
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        };
-    }
-    forkSelectionFromRow(row) {
-        return {
-            targetPublicThreadId: row.target_public_thread_id,
-            sourcePublicThreadId: row.source_public_thread_id,
-            provisionalEpochId: row.provisional_epoch_id,
-            expectedTargetRevision: row.expected_target_revision,
-            ...(row.selected_epoch_id === null ? {} : { selectedEpochId: row.selected_epoch_id }),
-            status: row.status,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        };
-    }
-    transaction(action) {
-        this.database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = action();
-            this.database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            this.database.exec("ROLLBACK");
-            throw error;
-        }
-    }
-}
-function threadIdentity(thread) {
-    return {
-        id: thread.id,
-        sessionId: thread.sessionId,
-        forkedFromId: thread.forkedFromId,
-        parentThreadId: thread.parentThreadId,
-        createdAt: thread.createdAt,
-    };
-}
-//# sourceMappingURL=store.js.map