@gkorepanov/ccodex 0.3.0 → 0.4.0

package/dist/handoff/store.js

@@ -10,13 +10,16 @@ export class HandoffStore {
       PRAGMA journal_mode=WAL;
       PRAGMA synchronous=FULL;
       PRAGMA busy_timeout=5000;
+      PRAGMA foreign_keys=ON;
       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
+        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,
@@ -25,21 +28,136 @@ export class HandoffStore {
         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,
+        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 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
+      );
     `);
+        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");
+        }
         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
-      ) VALUES (?, ?, ?, ?, ?, ?)
+        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
-    `).run(pending.threadId, pending.sourceProvider, pending.targetProvider, pending.targetModel, JSON.stringify(pending.settings), Date.now());
+        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 = ?")
@@ -50,10 +168,382 @@ export class HandoffStore {
             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) {
-        this.database.prepare("DELETE FROM pending_provider_switches WHERE thread_id = ?").run(threadId);
+    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;
+    }
+    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({ ...input.thread, turns: [] }), 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({ ...thread, id: publicThreadId, turns: [] }), 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));
+    }
+    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;
+            const result = this.database.prepare(`
+        UPDATE provider_epochs SET model = ?, settings_json = ?
+        WHERE epoch_id = ? AND public_thread_id = ? AND state = 'current'
+      `).run(patch.model ?? epoch.model, JSON.stringify({ ...epoch.settings, ...(patch.settings ?? {}) }), expectedEpochId, publicThreadId);
+            return Number(result.changes) === 1 ? this.getEpoch(expectedEpochId) : undefined;
+        });
+    }
+    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 epoch = logical && this.getEpoch(logical.currentEpochId);
+            const active = this.database.prepare(`
+        SELECT 1 AS found FROM provider_switch_jobs
+        WHERE public_thread_id = ? AND status IN ('queued', 'running', 'targetCreated')
+      `).get(input.publicThreadId);
+            if (!logical || logical.currentEpochId !== input.expectedEpochId || active
+                || epoch?.provider !== pending?.sourceProvider
+                || 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 (
+          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, logical.revision, 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);
+        });
+    }
+    getProviderSwitchJob(jobId) {
+        const row = this.database.prepare("SELECT * FROM provider_switch_jobs WHERE job_id = ?")
+            .get(jobId);
+        return row ? this.providerSwitchJobFromRow(row) : undefined;
+    }
+    recoverableProviderSwitchJobs() {
+        return this.database.prepare(`
+      SELECT * FROM provider_switch_jobs
+      WHERE status IN ('queued', 'running', 'targetCreated') ORDER BY created_at ASC
+    `).all().map((row) => this.providerSwitchJobFromRow(row));
+    }
+    claimProviderSwitchJob(jobId) {
+        const result = this.database.prepare(`
+      UPDATE provider_switch_jobs 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 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 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 = ?
+        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({ ...input.thread, turns: [] }), 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 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 SET status = 'failed', error = ?, 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;
+    }
+    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;
+        });
+    }
+    commitForkSelection(input) {
+        return this.transaction(() => {
+            const selection = this.getForkSelection(input.targetPublicThreadId);
+            const target = selection && this.getLogicalThread(selection.targetPublicThreadId);
+            const selected = this.getEpoch(input.selectedSourceEpochId);
+            const provisional = this.getEpoch(input.expectedProvisionalEpochId);
+            if (!selection || selection.status !== "pending" || !target
+                || selection.provisionalEpochId !== input.expectedProvisionalEpochId
+                || selection.expectedTargetRevision !== target.revision
+                || target.currentEpochId !== input.expectedProvisionalEpochId
+                || selected?.publicThreadId !== selection.sourcePublicThreadId
+                || provisional?.publicThreadId !== target.publicThreadId || provisional.state !== "current"
+                || input.targetEpoch.provider !== selected.provider)
+                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 = ?
+        WHERE epoch_id = ? AND public_thread_id = ? AND state = 'current'
+      `).run(committedAt, provisional.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({ ...input.thread, turns: [] }), committedAt, target.publicThreadId, provisional.id, selection.expectedTargetRevision);
+            if (Number(updated.changes) !== 1)
+                throw new Error("Fork selection lost its logical-thread CAS during commit.");
+            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, provisional.id);
+            if (Number(finalized.changes) !== 1)
+                throw new Error("Fork selection lost its 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(`
@@ -82,5 +572,126 @@ export class HandoffStore {
     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, epoch.model, JSON.stringify(epoch.settings), 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.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 }),
+        };
+    }
+    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;
+        }
+    }
 }
 //# sourceMappingURL=store.js.map