@gkorepanov/ccodex 0.3.0 → 0.3.4

package/dist/store/sqliteStore.d.ts

@@ -1,8 +1,7 @@
 import type { Thread } from "../codex/generated/v2/Thread.js";
 import type { ThreadListParams } from "../codex/generated/v2/ThreadListParams.js";
 import type { Turn } from "../codex/generated/v2/Turn.js";
-import type { ThreadGoal } from "../codex/generated/v2/ThreadGoal.js";
-import type { ClaudeThreadRecord, EventPersistence, HybridStore, PendingRequestRecord } from "./HybridStore.js";
+import type { AppendProviderEvent, ClaudeThreadRecord, EventPersistence, GoalPatch, GoalUsageInput, HybridStore, InternalGoal, PendingRequestRecord, PendingThreadRemoval, ProviderEventDisposition, ProviderEventRecord, ProviderItemCorrelation, ProviderRetractionMutation, StoredEvent, ThreadStateCommit, TurnProviderBoundary } from "./HybridStore.js";
 export declare class SqliteHybridStore implements HybridStore {
     private readonly database;
     private readonly path;
@@ -13,7 +12,13 @@ export declare class SqliteHybridStore implements HybridStore {
     allThreadRecords(): ClaudeThreadRecord[];
     listThreads(params: ThreadListParams): Thread[];
     updateThread(record: ClaudeThreadRecord): void;
+    isThreadArchived(threadId: string): boolean;
     setThreadArchived(threadId: string, archived: boolean): void;
+    commitThreadsArchived(threadIds: readonly string[], archived: boolean): void;
+    beginThreadRemoval(removal: PendingThreadRemoval): void;
+    cancelThreadRemoval(rootThreadId: string): void;
+    listPendingThreadRemovals(): PendingThreadRemoval[];
+    commitThreadRemoval(rootThreadId: string, threadIds: readonly string[]): void;
     deleteThread(threadId: string): void;
     createTurn(threadId: string, turn: Turn): void;
     updateTurn(threadId: string, turn: Turn): void;
@@ -22,20 +27,41 @@ export declare class SqliteHybridStore implements HybridStore {
     setTurnClaudeMessageUuid(threadId: string, turnId: string, messageUuid: string): void;
     getTurnClaudeMessageUuid(threadId: string, turnId: string): string | undefined;
     truncateTurns(threadId: string, keepCount: number): void;
+    commitForkedThread(record: ClaudeThreadRecord, turns: readonly Turn[], boundaries: readonly TurnProviderBoundary[]): void;
+    commitThreadRollback(record: ClaudeThreadRecord, keepCount: number, boundaries: readonly TurnProviderBoundary[], removedThreadIds?: readonly string[]): void;
+    commitThreadState(commit: ThreadStateCommit): number[];
     appendEvent(threadId: string, turnId: string | null, method: string, params: unknown, persistence?: EventPersistence): number;
+    eventHighWatermark(threadId: string): number;
+    listEventsAfter(threadId: string, sequence: number): StoredEvent[];
     hasProcessedProviderEvent(threadId: string, providerEventId: string): boolean;
     markProviderEventProcessed(threadId: string, providerEventType: string, providerEventId: string): void;
+    appendProviderEvent(event: AppendProviderEvent): {
+        record: ProviderEventRecord;
+        inserted: boolean;
+    };
+    completeProviderEvent(threadId: string, sequence: number, disposition: Exclude<ProviderEventDisposition, "pending">, error?: string | null): void;
+    listProviderEvents(threadId: string, disposition?: ProviderEventDisposition): ProviderEventRecord[];
+    pruneProviderEvents(threadId: string, maxEvents: number, maxBytes: number): number;
+    linkProviderItems(threadId: string, providerMessageId: string, ownerThreadId: string, turnId: string, itemIds: readonly string[]): void;
+    private insertProviderItems;
+    listProviderItemCorrelations(threadId: string, providerMessageIds: readonly string[]): ProviderItemCorrelation[];
+    deleteProviderItemCorrelations(threadId: string, providerMessageIds: readonly string[]): void;
+    commitProviderRetraction(record: ClaudeThreadRecord, providerMessageIds: readonly string[], mutations: readonly ProviderRetractionMutation[], removedThreadIds?: readonly string[]): void;
     createPendingRequest(request: PendingRequestRecord): void;
     getPendingRequest(requestId: string): PendingRequestRecord | undefined;
     findPendingRequestByClaudeId(threadId: string, claudeRequestId: string): PendingRequestRecord | undefined;
     listPendingRequests(threadId: string): PendingRequestRecord[];
     resolvePendingRequest(requestId: string, status: "resolved" | "cancelled", response: unknown): void;
-    getGoal(threadId: string): ThreadGoal | undefined;
-    setGoal(goal: ThreadGoal): void;
+    getGoal(threadId: string): InternalGoal | undefined;
+    setGoal(threadId: string, patch: GoalPatch): InternalGoal;
     clearGoal(threadId: string): boolean;
+    accountGoalUsage(input: GoalUsageInput): InternalGoal | undefined;
     close(): void;
     private transaction;
+    private insertEvent;
+    private deleteThreadRows;
     private writeTurn;
+    private insertTurn;
     private syncItems;
     private backup;
     private migrate;

package/dist/store/sqliteStore.js

@@ -2,6 +2,7 @@ import { chmodSync, copyFileSync, existsSync, mkdirSync, renameSync, unlinkSync,
 import { dirname } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { v7 as uuidv7 } from "uuid";
+import { settingsGeneration, withSettingsFrom } from "./HybridStore.js";
 import { filterSortThreads } from "./threadFilter.js";
 function json(value) {
     return JSON.stringify(value);
@@ -67,6 +68,12 @@ function parseRecord(row, turns) {
         tokenUsageTotal: runtime.tokenUsageTotal && typeof runtime.tokenUsageTotal === "object"
             ? runtime.tokenUsageTotal
             : { totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 },
+        tokenUsageLast: runtime.tokenUsageLast && typeof runtime.tokenUsageLast === "object"
+            ? runtime.tokenUsageLast
+            : null,
+        modelContextWindow: typeof runtime.modelContextWindow === "number" ? runtime.modelContextWindow : null,
+        providerCostUsdTotal: typeof runtime.providerCostUsdTotal === "number" ? runtime.providerCostUsdTotal : 0,
+        settingsGeneration: typeof runtime.settingsGeneration === "number" ? runtime.settingsGeneration : 0,
     };
 }
 function parsePending(row) {
@@ -83,6 +90,21 @@ function parsePending(row) {
         resolvedAt: row.resolved_at,
     };
 }
+function parseProviderEvent(row) {
+    return {
+        sequence: row.sequence,
+        threadId: row.thread_id,
+        processEpoch: row.process_epoch,
+        providerSequence: row.provider_sequence,
+        providerEventType: row.provider_event_type,
+        providerEventId: row.provider_event_id,
+        payload: JSON.parse(row.payload_json),
+        disposition: row.disposition,
+        error: row.error,
+        createdAt: row.created_at,
+        projectedAt: row.projected_at,
+    };
+}
 export class SqliteHybridStore {
     database;
     path;
@@ -113,6 +135,10 @@ export class SqliteHybridStore {
             collaborationMode: record.collaborationMode,
             outputSchema: record.outputSchema,
             tokenUsageTotal: record.tokenUsageTotal,
+            tokenUsageLast: record.tokenUsageLast,
+            modelContextWindow: record.modelContextWindow,
+            providerCostUsdTotal: record.providerCostUsdTotal ?? 0,
+            settingsGeneration: settingsGeneration(record),
         }));
     }
     hasThread(threadId) {
@@ -149,44 +175,85 @@ export class SqliteHybridStore {
         return filterSortThreads(rows.map((row) => JSON.parse(row.thread_json)), params);
     }
     updateThread(record) {
+        const current = this.getThreadRecord(record.thread.id, false);
+        const merged = current && settingsGeneration(current) > settingsGeneration(record)
+            ? withSettingsFrom(record, current)
+            : record;
         this.database.prepare(`
       UPDATE threads SET
         claude_session_id = ?, model_picker_id = ?, claude_model_value = ?,
-        service_tier = ?, cwd = ?, archived = ?, updated_at = ?, thread_json = ?,
+        service_tier = ?, cwd = ?, updated_at = ?, thread_json = ?,
         approval_policy_json = ?, sandbox_policy_json = ?, base_instructions = ?,
         developer_instructions = ?, personality = ?, resolved_model = ?,
         last_claude_message_uuid = ?, last_completed_turn_id = ?, claude_code_version = ?,
         runtime_settings_json = ?
       WHERE id = ?
-    `).run(record.claudeSessionId, record.modelPickerId, record.claudeModelValue, record.serviceTier, record.thread.cwd, record.thread.archived ? 1 : 0, record.thread.updatedAt, json({ ...record.thread, turns: [] }), json(record.approvalPolicy), json(record.sandboxPolicy), record.baseInstructions, record.developerInstructions, record.personality, record.resolvedModel, record.lastClaudeMessageUuid, record.lastCompletedTurnId, record.claudeCodeVersion, json({
-            approvalsReviewer: record.approvalsReviewer,
-            reasoningEffort: record.reasoningEffort,
-            reasoningSummary: record.reasoningSummary,
-            collaborationMode: record.collaborationMode,
-            outputSchema: record.outputSchema,
-            tokenUsageTotal: record.tokenUsageTotal,
-        }), record.thread.id);
+    `).run(merged.claudeSessionId, merged.modelPickerId, merged.claudeModelValue, merged.serviceTier, merged.thread.cwd, merged.thread.updatedAt, json({ ...merged.thread, turns: [] }), json(merged.approvalPolicy), json(merged.sandboxPolicy), merged.baseInstructions, merged.developerInstructions, merged.personality, merged.resolvedModel, merged.lastClaudeMessageUuid, merged.lastCompletedTurnId, merged.claudeCodeVersion, json({
+            approvalsReviewer: merged.approvalsReviewer,
+            reasoningEffort: merged.reasoningEffort,
+            reasoningSummary: merged.reasoningSummary,
+            collaborationMode: merged.collaborationMode,
+            outputSchema: merged.outputSchema,
+            tokenUsageTotal: merged.tokenUsageTotal,
+            tokenUsageLast: merged.tokenUsageLast,
+            modelContextWindow: merged.modelContextWindow,
+            providerCostUsdTotal: merged.providerCostUsdTotal ?? 0,
+            settingsGeneration: settingsGeneration(merged),
+        }), merged.thread.id);
+    }
+    isThreadArchived(threadId) {
+        const row = this.database.prepare("SELECT archived FROM threads WHERE id = ?").get(threadId);
+        return row?.archived === 1;
     }
     setThreadArchived(threadId, archived) {
         this.database.prepare("UPDATE threads SET archived = ? WHERE id = ?").run(archived ? 1 : 0, threadId);
     }
-    deleteThread(threadId) {
+    commitThreadsArchived(threadIds, archived) {
+        const method = archived ? "thread/archived" : "thread/unarchived";
         this.transaction(() => {
-            this.database.prepare("DELETE FROM goals WHERE thread_id = ?").run(threadId);
-            this.database.prepare("DELETE FROM pending_requests WHERE thread_id = ?").run(threadId);
-            this.database.prepare("DELETE FROM events WHERE thread_id = ?").run(threadId);
-            this.database.prepare("DELETE FROM turns WHERE thread_id = ?").run(threadId);
-            this.database.prepare("DELETE FROM threads WHERE id = ?").run(threadId);
+            for (const threadId of threadIds) {
+                this.setThreadArchived(threadId, archived);
+                this.insertEvent(threadId, null, method, { threadId });
+            }
         });
     }
-    createTurn(threadId, turn) {
+    beginThreadRemoval(removal) {
+        this.database.prepare(`
+      INSERT INTO pending_thread_removals (root_thread_id, claude_session_id, cwd, kind)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(root_thread_id) DO UPDATE SET
+        claude_session_id = excluded.claude_session_id,
+        cwd = excluded.cwd,
+        kind = excluded.kind
+    `).run(removal.rootThreadId, removal.claudeSessionId, removal.cwd, removal.kind);
+    }
+    cancelThreadRemoval(rootThreadId) {
+        this.database.prepare("DELETE FROM pending_thread_removals WHERE root_thread_id = ?").run(rootThreadId);
+    }
+    listPendingThreadRemovals() {
+        return this.database.prepare(`
+      SELECT root_thread_id, claude_session_id, cwd, kind
+      FROM pending_thread_removals ORDER BY root_thread_id
+    `).all().map((row) => ({
+            rootThreadId: row.root_thread_id,
+            claudeSessionId: row.claude_session_id,
+            cwd: row.cwd,
+            kind: row.kind,
+        }));
+    }
+    commitThreadRemoval(rootThreadId, threadIds) {
         this.transaction(() => {
-            const ordinalRow = this.database.prepare("SELECT COALESCE(MAX(ordinal), -1) + 1 AS ordinal FROM turns WHERE thread_id = ?").get(threadId);
-            this.database.prepare("INSERT INTO turns (id, thread_id, ordinal, status, turn_json) VALUES (?, ?, ?, ?, ?)")
-                .run(turn.id, threadId, ordinalRow.ordinal, turn.status, json(turn));
-            this.syncItems(threadId, turn);
+            for (const threadId of [...threadIds].reverse())
+                this.deleteThreadRows(threadId);
+            this.database.prepare("DELETE FROM pending_thread_removals WHERE root_thread_id = ?").run(rootThreadId);
         });
     }
+    deleteThread(threadId) {
+        this.transaction(() => this.deleteThreadRows(threadId));
+    }
+    createTurn(threadId, turn) {
+        this.transaction(() => this.insertTurn(threadId, turn));
+    }
     updateTurn(threadId, turn) {
         this.transaction(() => this.writeTurn(threadId, turn));
     }
@@ -212,25 +279,68 @@ export class SqliteHybridStore {
     truncateTurns(threadId, keepCount) {
         this.database.prepare("DELETE FROM turns WHERE thread_id = ? AND ordinal >= ?").run(threadId, keepCount);
     }
-    appendEvent(threadId, turnId, method, params, persistence) {
+    commitForkedThread(record, turns, boundaries) {
+        this.transaction(() => {
+            this.createThread(record);
+            for (const turn of turns)
+                this.insertTurn(record.thread.id, turn);
+            for (const boundary of boundaries) {
+                this.setTurnClaudeMessageUuid(record.thread.id, boundary.turnId, boundary.messageUuid);
+            }
+        });
+    }
+    commitThreadRollback(record, keepCount, boundaries, removedThreadIds = []) {
+        this.transaction(() => {
+            for (const threadId of removedThreadIds)
+                this.deleteThreadRows(threadId);
+            this.truncateTurns(record.thread.id, keepCount);
+            for (const boundary of boundaries) {
+                this.setTurnClaudeMessageUuid(record.thread.id, boundary.turnId, boundary.messageUuid);
+            }
+            this.updateThread(record);
+        });
+    }
+    commitThreadState(commit) {
         return this.transaction(() => {
-            if (persistence?.dedupKey) {
-                const found = this.database.prepare("SELECT 1 FROM events WHERE thread_id = ? AND dedup_key = ?")
-                    .get(threadId, persistence.dedupKey);
-                if (found)
-                    return 0;
+            this.updateThread(commit.record);
+            if (commit.turn) {
+                if (commit.insertTurn)
+                    this.insertTurn(commit.record.thread.id, commit.turn);
+                else
+                    this.writeTurn(commit.record.thread.id, commit.turn);
             }
-            if (persistence?.turn)
-                this.writeTurn(threadId, persistence.turn);
-            const result = this.database.prepare(`
-        INSERT INTO events (
-          event_id, thread_id, turn_id, method, params_json, provider_event_type,
-          provider_event_id, dedup_key, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(uuidv7(), threadId, turnId, method, json(params), persistence?.providerEventType ?? null, persistence?.providerEventId ?? null, persistence?.dedupKey ?? null, Date.now());
-            return Number(result.lastInsertRowid);
+            if (commit.providerBoundary) {
+                const boundary = commit.providerBoundary;
+                this.setTurnClaudeMessageUuid(boundary.ownerThreadId, boundary.turnId, boundary.messageUuid);
+                this.insertProviderItems(commit.record.thread.id, boundary.messageUuid, boundary.ownerThreadId, boundary.turnId, boundary.itemIds ?? []);
+            }
+            return commit.events.map((event) => this.insertEvent(commit.record.thread.id, event.turnId, event.method, event.params, event));
         });
     }
+    appendEvent(threadId, turnId, method, params, persistence) {
+        return this.transaction(() => this.insertEvent(threadId, turnId, method, params, persistence));
+    }
+    eventHighWatermark(threadId) {
+        const row = this.database.prepare("SELECT COALESCE(MAX(sequence), 0) AS sequence FROM events WHERE thread_id = ?")
+            .get(threadId);
+        return row.sequence;
+    }
+    listEventsAfter(threadId, sequence) {
+        const rows = this.database.prepare(`
+      SELECT sequence, thread_id, turn_id, method, params_json, created_at
+      FROM events
+      WHERE thread_id = ? AND sequence > ? AND method NOT LIKE 'hybrid/%'
+      ORDER BY sequence ASC
+    `).all(threadId, sequence);
+        return rows.map((row) => ({
+            sequence: row.sequence,
+            threadId: row.thread_id,
+            turnId: row.turn_id,
+            method: row.method,
+            params: JSON.parse(row.params_json),
+            createdAt: row.created_at,
+        }));
+    }
     hasProcessedProviderEvent(threadId, providerEventId) {
         return this.database.prepare(`
       SELECT 1 FROM events
@@ -242,6 +352,111 @@ export class SqliteHybridStore {
             providerEventType, providerEventId, dedupKey: `provider:${providerEventId}`,
         });
     }
+    appendProviderEvent(event) {
+        return this.transaction(() => {
+            const existing = event.providerEventId === null ? undefined : this.database.prepare(`
+        SELECT * FROM provider_events WHERE thread_id = ? AND provider_event_id = ?
+      `).get(event.threadId, event.providerEventId);
+            if (existing)
+                return { record: parseProviderEvent(existing), inserted: false };
+            const result = this.database.prepare(`
+        INSERT INTO provider_events (
+          thread_id, process_epoch, provider_sequence, provider_event_type,
+          provider_event_id, payload_json, disposition, error, created_at, projected_at
+        ) VALUES (?, ?, ?, ?, ?, ?, 'pending', NULL, ?, NULL)
+      `).run(event.threadId, event.processEpoch, event.providerSequence, event.providerEventType, event.providerEventId, json(event.payload), event.createdAt);
+            const row = this.database.prepare("SELECT * FROM provider_events WHERE sequence = ?")
+                .get(Number(result.lastInsertRowid));
+            return { record: parseProviderEvent(row), inserted: true };
+        });
+    }
+    completeProviderEvent(threadId, sequence, disposition, error = null) {
+        this.database.prepare(`
+      UPDATE provider_events SET disposition = ?, error = ?, projected_at = ? WHERE thread_id = ? AND sequence = ?
+    `).run(disposition, error, Date.now(), threadId, sequence);
+    }
+    listProviderEvents(threadId, disposition) {
+        const rows = (disposition
+            ? this.database.prepare("SELECT * FROM provider_events WHERE thread_id = ? AND disposition = ? ORDER BY sequence")
+                .all(threadId, disposition)
+            : this.database.prepare("SELECT * FROM provider_events WHERE thread_id = ? ORDER BY sequence").all(threadId));
+        return rows.map(parseProviderEvent);
+    }
+    pruneProviderEvents(threadId, maxEvents, maxBytes) {
+        if (maxEvents < 1)
+            throw new Error("Provider event retention must keep at least one event.");
+        const result = this.database.prepare(`
+      DELETE FROM provider_events
+      WHERE thread_id = ?
+        AND disposition IN ('projected', 'stateOnly', 'retainedOnly', 'unsupportedVisible')
+        AND sequence IN (
+          SELECT sequence FROM (
+            SELECT sequence,
+                   ROW_NUMBER() OVER (ORDER BY sequence DESC) AS ordinal,
+                   SUM(LENGTH(CAST(payload_json AS BLOB))) OVER (ORDER BY sequence DESC) AS retained_bytes
+            FROM provider_events
+            WHERE thread_id = ?
+              AND disposition IN ('projected', 'stateOnly', 'retainedOnly', 'unsupportedVisible')
+          )
+          WHERE ordinal > ? OR (ordinal > 1 AND retained_bytes > ?)
+        )
+    `).run(threadId, threadId, maxEvents, maxBytes);
+        return Number(result.changes);
+    }
+    linkProviderItems(threadId, providerMessageId, ownerThreadId, turnId, itemIds) {
+        this.transaction(() => this.insertProviderItems(threadId, providerMessageId, ownerThreadId, turnId, itemIds));
+    }
+    insertProviderItems(threadId, providerMessageId, ownerThreadId, turnId, itemIds) {
+        const insert = this.database.prepare(`
+      INSERT OR IGNORE INTO provider_item_correlations (
+        thread_id, provider_message_id, owner_thread_id, turn_id, item_id
+      ) VALUES (?, ?, ?, ?, ?)
+    `);
+        for (const itemId of itemIds)
+            insert.run(threadId, providerMessageId, ownerThreadId, turnId, itemId);
+    }
+    listProviderItemCorrelations(threadId, providerMessageIds) {
+        if (providerMessageIds.length === 0)
+            return [];
+        const placeholders = providerMessageIds.map(() => "?").join(", ");
+        const rows = this.database.prepare(`
+      SELECT provider_message_id, owner_thread_id, turn_id, item_id
+      FROM provider_item_correlations
+      WHERE thread_id = ? AND provider_message_id IN (${placeholders})
+    `).all(threadId, ...providerMessageIds);
+        return rows.map((row) => ({
+            providerMessageId: row.provider_message_id,
+            ownerThreadId: row.owner_thread_id,
+            turnId: row.turn_id,
+            itemId: row.item_id,
+        }));
+    }
+    deleteProviderItemCorrelations(threadId, providerMessageIds) {
+        if (providerMessageIds.length === 0)
+            return;
+        const placeholders = providerMessageIds.map(() => "?").join(", ");
+        this.database.prepare(`
+      DELETE FROM provider_item_correlations
+      WHERE thread_id = ? AND provider_message_id IN (${placeholders})
+    `).run(threadId, ...providerMessageIds);
+    }
+    commitProviderRetraction(record, providerMessageIds, mutations, removedThreadIds = []) {
+        this.transaction(() => {
+            for (const threadId of removedThreadIds)
+                this.deleteThreadRows(threadId);
+            for (const mutation of mutations) {
+                this.writeTurn(mutation.ownerThreadId, mutation.turn);
+                if (mutation.clearBoundary) {
+                    this.database.prepare(`
+            UPDATE turns SET last_claude_message_uuid = NULL
+            WHERE id = ? AND thread_id = ?
+          `).run(mutation.turn.id, mutation.ownerThreadId);
+                }
+            }
+            this.deleteProviderItemCorrelations(record.thread.id, providerMessageIds);
+            this.updateThread(record);
+        });
+    }
     createPendingRequest(request) {
         this.database.prepare(`
       INSERT INTO pending_requests (
@@ -273,17 +488,72 @@ export class SqliteHybridStore {
     }
     getGoal(threadId) {
         const row = this.database.prepare("SELECT goal_json FROM goals WHERE thread_id = ?").get(threadId);
-        return row ? JSON.parse(row.goal_json) : undefined;
-    }
-    setGoal(goal) {
-        this.database.prepare(`
-      INSERT INTO goals (thread_id, goal_json) VALUES (?, ?)
-      ON CONFLICT(thread_id) DO UPDATE SET goal_json = excluded.goal_json
-    `).run(goal.threadId, json(goal));
+        if (!row)
+            return undefined;
+        const stored = JSON.parse(row.goal_json);
+        if (stored.goalId)
+            return stored;
+        const migrated = { ...stored, goalId: uuidv7() };
+        this.database.prepare("UPDATE goals SET goal_json = ? WHERE thread_id = ?").run(json(migrated), threadId);
+        return migrated;
+    }
+    setGoal(threadId, patch) {
+        return this.transaction(() => {
+            const previous = this.getGoal(threadId);
+            const now = patch.now ?? Math.floor(Date.now() / 1_000);
+            const replace = patch.replace === true || !previous;
+            if (replace && patch.objective === undefined)
+                throw new Error(`cannot create goal for thread ${threadId} without an objective`);
+            const goal = {
+                threadId,
+                goalId: replace ? uuidv7() : previous.goalId,
+                objective: patch.objective ?? previous?.objective ?? "",
+                status: patch.status ?? (replace ? "active" : previous.status),
+                tokenBudget: patch.tokenBudget === undefined ? (replace ? null : previous.tokenBudget) : patch.tokenBudget,
+                tokensUsed: replace ? 0 : previous.tokensUsed,
+                timeUsedSeconds: replace ? 0 : previous.timeUsedSeconds,
+                createdAt: replace ? now : previous.createdAt,
+                updatedAt: now,
+            };
+            if (goal.status === "active" && goal.tokenBudget !== null && goal.tokensUsed >= goal.tokenBudget)
+                goal.status = "budgetLimited";
+            this.database.prepare(`
+        INSERT INTO goals (thread_id, goal_json) VALUES (?, ?)
+        ON CONFLICT(thread_id) DO UPDATE SET goal_json = excluded.goal_json
+      `).run(threadId, json(goal));
+            return goal;
+        });
     }
     clearGoal(threadId) {
         return Number(this.database.prepare("DELETE FROM goals WHERE thread_id = ?").run(threadId).changes) > 0;
     }
+    accountGoalUsage(input) {
+        return this.transaction(() => {
+            if (input.checkpointKey) {
+                const inserted = this.database.prepare(`
+          INSERT OR IGNORE INTO goal_checkpoints (thread_id, goal_id, checkpoint_key)
+          VALUES (?, ?, ?)
+        `).run(input.threadId, input.expectedGoalId, input.checkpointKey);
+                if (Number(inserted.changes) === 0)
+                    return this.getGoal(input.threadId);
+            }
+            const previous = this.getGoal(input.threadId);
+            if (!previous || previous.goalId !== input.expectedGoalId)
+                return previous;
+            if (previous.status !== "active" && previous.status !== "budgetLimited")
+                return previous;
+            const goal = {
+                ...previous,
+                tokensUsed: previous.tokensUsed + Math.max(0, input.tokenDelta),
+                timeUsedSeconds: previous.timeUsedSeconds + Math.max(0, input.timeDeltaSeconds),
+                updatedAt: Math.floor(Date.now() / 1_000),
+            };
+            if (goal.status === "active" && goal.tokenBudget !== null && goal.tokensUsed >= goal.tokenBudget)
+                goal.status = "budgetLimited";
+            this.database.prepare("UPDATE goals SET goal_json = ? WHERE thread_id = ?").run(json(goal), input.threadId);
+            return goal;
+        });
+    }
     close() {
         try {
             this.backup();
@@ -304,11 +574,43 @@ export class SqliteHybridStore {
             throw error;
         }
     }
+    insertEvent(threadId, turnId, method, params, persistence) {
+        if (persistence?.dedupKey) {
+            const found = this.database.prepare("SELECT 1 FROM events WHERE thread_id = ? AND dedup_key = ?")
+                .get(threadId, persistence.dedupKey);
+            if (found)
+                return 0;
+        }
+        if (persistence?.turn)
+            this.writeTurn(threadId, persistence.turn);
+        const result = this.database.prepare(`
+      INSERT INTO events (
+        event_id, thread_id, turn_id, method, params_json, provider_event_type,
+        provider_event_id, dedup_key, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(uuidv7(), threadId, turnId, method, json(params), persistence?.providerEventType ?? null, persistence?.providerEventId ?? null, persistence?.dedupKey ?? null, Date.now());
+        return Number(result.lastInsertRowid);
+    }
+    deleteThreadRows(threadId) {
+        this.database.prepare("DELETE FROM provider_item_correlations WHERE owner_thread_id = ?").run(threadId);
+        this.database.prepare("DELETE FROM goals WHERE thread_id = ?").run(threadId);
+        this.database.prepare("DELETE FROM pending_requests WHERE thread_id = ?").run(threadId);
+        this.database.prepare("DELETE FROM events WHERE thread_id = ?").run(threadId);
+        this.database.prepare("DELETE FROM turns WHERE thread_id = ?").run(threadId);
+        this.database.prepare("DELETE FROM threads WHERE id = ?").run(threadId);
+    }
     writeTurn(threadId, turn) {
         this.database.prepare("UPDATE turns SET status = ?, turn_json = ? WHERE id = ? AND thread_id = ?")
             .run(turn.status, json(turn), turn.id, threadId);
         this.syncItems(threadId, turn);
     }
+    insertTurn(threadId, turn) {
+        const ordinalRow = this.database.prepare("SELECT COALESCE(MAX(ordinal), -1) + 1 AS ordinal FROM turns WHERE thread_id = ?")
+            .get(threadId);
+        this.database.prepare("INSERT INTO turns (id, thread_id, ordinal, status, turn_json) VALUES (?, ?, ?, ?, ?)")
+            .run(turn.id, threadId, ordinalRow.ordinal, turn.status, json(turn));
+        this.syncItems(threadId, turn);
+    }
     syncItems(threadId, turn) {
         this.database.prepare("DELETE FROM items WHERE turn_id = ? AND thread_id = ?").run(turn.id, threadId);
         const insert = this.database.prepare(`
@@ -356,6 +658,7 @@ export class SqliteHybridStore {
         ,last_completed_turn_id TEXT
         ,claude_code_version TEXT
         ,runtime_settings_json TEXT
+        ,deletion_pending INTEGER NOT NULL DEFAULT 0
       );
       CREATE TABLE IF NOT EXISTS turns (
         id TEXT PRIMARY KEY,
@@ -409,6 +712,44 @@ export class SqliteHybridStore {
         thread_id TEXT PRIMARY KEY,
         goal_json TEXT NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS goal_checkpoints (
+        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+        goal_id TEXT NOT NULL,
+        checkpoint_key TEXT NOT NULL,
+        PRIMARY KEY(thread_id, goal_id, checkpoint_key)
+      );
+      CREATE TABLE IF NOT EXISTS provider_events (
+        sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+        process_epoch TEXT NOT NULL,
+        provider_sequence INTEGER NOT NULL,
+        provider_event_type TEXT NOT NULL,
+        provider_event_id TEXT,
+        payload_json TEXT NOT NULL,
+        disposition TEXT NOT NULL,
+        error TEXT,
+        created_at INTEGER NOT NULL,
+        projected_at INTEGER,
+        UNIQUE(thread_id, process_epoch, provider_sequence)
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS provider_events_thread_event_id
+        ON provider_events(thread_id, provider_event_id) WHERE provider_event_id IS NOT NULL;
+      CREATE TABLE IF NOT EXISTS provider_item_correlations (
+        thread_id TEXT NOT NULL REFERENCES threads(id) ON DELETE CASCADE,
+        provider_message_id TEXT NOT NULL,
+        owner_thread_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        item_id TEXT NOT NULL,
+        PRIMARY KEY(thread_id, provider_message_id, item_id)
+      );
+      CREATE INDEX IF NOT EXISTS provider_item_correlations_owner
+        ON provider_item_correlations(owner_thread_id, turn_id);
+      CREATE TABLE IF NOT EXISTS pending_thread_removals (
+        root_thread_id TEXT PRIMARY KEY,
+        claude_session_id TEXT NOT NULL,
+        cwd TEXT NOT NULL,
+        kind TEXT NOT NULL
+      );
       INSERT OR IGNORE INTO schema_migrations(version) VALUES (1);
     `);
             this.ensureColumn("threads", "resolved_model", "TEXT");
@@ -416,6 +757,15 @@ export class SqliteHybridStore {
             this.ensureColumn("threads", "last_completed_turn_id", "TEXT");
             this.ensureColumn("threads", "claude_code_version", "TEXT");
             this.ensureColumn("threads", "runtime_settings_json", "TEXT");
+            this.ensureColumn("threads", "deletion_pending", "INTEGER NOT NULL DEFAULT 0");
+            const threadColumns = new Set(this.database.prepare("PRAGMA table_info(threads)").all()
+                .map((column) => column.name));
+            if (threadColumns.has("claude_session_id") && threadColumns.has("cwd")) {
+                this.database.exec(`
+          INSERT OR IGNORE INTO pending_thread_removals (root_thread_id, claude_session_id, cwd, kind)
+          SELECT id, claude_session_id, cwd, 'delete' FROM threads WHERE deletion_pending = 1
+        `);
+            }
             this.ensureColumn("turns", "last_claude_message_uuid", "TEXT");
             this.ensureColumn("events", "event_id", "TEXT");
             this.ensureColumn("events", "provider_event_type", "TEXT");
@@ -429,6 +779,9 @@ export class SqliteHybridStore {
             const threadScopedIds = this.database.prepare("SELECT 1 FROM schema_migrations WHERE version = 3").get();
             if (!threadScopedIds)
                 this.migrateThreadScopedIds();
+            this.database.exec("INSERT OR IGNORE INTO schema_migrations(version) VALUES (4)");
+            this.database.exec("INSERT OR IGNORE INTO schema_migrations(version) VALUES (5)");
+            this.database.exec("INSERT OR IGNORE INTO schema_migrations(version) VALUES (6)");
         });
     }
     migrateThreadScopedIds() {