@keyou007/agent-bot 0.1.0

package/dist/state/StateStore.js

@@ -0,0 +1,893 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { migrations } from "./migrations.js";
+export class StateStore {
+    db;
+    constructor(sqlitePath) {
+        fs.mkdirSync(path.dirname(sqlitePath), { recursive: true });
+        this.db = new Database(sqlitePath);
+        this.db.pragma("journal_mode = WAL");
+        for (const migration of migrations) {
+            this.db.exec(migration);
+        }
+        this.db.exec("UPDATE message_reactions SET status = 'pending' WHERE status = 'updating'");
+        this.ensureUserContextColumns();
+        this.ensureSessionColumns();
+        this.ensureTurnSnapshotColumns();
+        this.ensureChatContextColumns();
+        this.initializeContextSessionMappings();
+        this.reconcileDuplicateRemoteSessions();
+        this.db.exec(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_remote_session_id_unique
+      ON sessions(remote_session_id)
+      WHERE remote_session_id IS NOT NULL
+    `);
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_chat_contexts_activity
+      ON chat_contexts(last_activity_at)
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+    getOrCreateUserContext(contextKey, defaultAgent) {
+        const existing = this.db
+            .prepare("SELECT * FROM user_contexts WHERE context_key = ?")
+            .get(contextKey);
+        if (existing) {
+            return mapUserContext(existing);
+        }
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`
+        INSERT INTO user_contexts (context_key, default_agent, current_session_id, created_at, updated_at)
+        VALUES (?, ?, NULL, ?, ?)
+        `)
+            .run(contextKey, defaultAgent, now, now);
+        return {
+            contextKey,
+            defaultAgent,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    getUserContext(contextKey) {
+        const row = this.db
+            .prepare("SELECT * FROM user_contexts WHERE context_key = ?")
+            .get(contextKey);
+        return row ? mapUserContext(row) : undefined;
+    }
+    listUserContexts() {
+        const rows = this.db
+            .prepare("SELECT * FROM user_contexts ORDER BY created_at ASC")
+            .all();
+        return rows.map(mapUserContext);
+    }
+    recordChatContext(contextKey, chatType) {
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO chat_contexts (context_key, chat_type, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(context_key) DO UPDATE SET
+        chat_type = excluded.chat_type,
+        updated_at = excluded.updated_at
+    `).run(contextKey, chatType, now, now);
+    }
+    listChatContexts(chatType) {
+        const rows = chatType
+            ? this.db.prepare(`
+          SELECT * FROM chat_contexts
+          WHERE chat_type = ?
+          ORDER BY updated_at DESC
+        `).all(chatType)
+            : this.db.prepare("SELECT * FROM chat_contexts ORDER BY updated_at DESC").all();
+        return rows.map((row) => ({
+            contextKey: row.context_key,
+            chatType: row.chat_type,
+            lastActivityAt: row.last_activity_at ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    markChatActive(contextKey, activeAt = new Date()) {
+        const timestamp = activeAt.toISOString();
+        this.db.prepare(`
+      UPDATE chat_contexts
+      SET last_activity_at = ?, updated_at = ?
+      WHERE context_key = ?
+    `).run(timestamp, timestamp, contextKey);
+    }
+    listRecentlyActiveChatContexts(since) {
+        const rows = this.db.prepare(`
+      SELECT * FROM chat_contexts
+      WHERE last_activity_at >= ?
+      ORDER BY last_activity_at DESC
+    `).all(since.toISOString());
+        return rows.map((row) => ({
+            contextKey: row.context_key,
+            chatType: row.chat_type,
+            lastActivityAt: row.last_activity_at ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    enqueuePrompt(input) {
+        const createdAt = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO queued_prompts (
+        prompt_id, local_session_id, context_key, prompt_text, local_image_paths_json,
+        message_id, reply_message_id, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.promptId, input.localSessionId, input.contextKey, input.text, JSON.stringify(input.localImagePaths ?? []), input.messageId ?? null, input.replyMessageId ?? null, createdAt);
+        return {
+            ...input,
+            localImagePaths: input.localImagePaths?.length ? [...input.localImagePaths] : undefined,
+            createdAt,
+        };
+    }
+    listQueuedPrompts(localSessionId) {
+        const rows = this.db.prepare(`
+      SELECT * FROM queued_prompts
+      WHERE local_session_id = ?
+      ORDER BY created_at ASC, rowid ASC
+    `).all(localSessionId);
+        return rows.map(mapQueuedPrompt);
+    }
+    listQueuedPromptSessionIds() {
+        const rows = this.db.prepare(`
+      SELECT local_session_id, min(created_at) AS first_created_at, min(rowid) AS first_rowid
+      FROM queued_prompts
+      GROUP BY local_session_id
+      ORDER BY first_created_at ASC, first_rowid ASC
+    `).all();
+        return rows.map((row) => row.local_session_id);
+    }
+    countQueuedPrompts(localSessionId) {
+        const row = this.db.prepare(`
+      SELECT count(*) AS count FROM queued_prompts WHERE local_session_id = ?
+    `).get(localSessionId);
+        return row.count;
+    }
+    takeNextQueuedPrompt(localSessionId) {
+        const take = this.db.transaction(() => {
+            const row = this.db.prepare(`
+        SELECT * FROM queued_prompts
+        WHERE local_session_id = ?
+        ORDER BY created_at ASC, rowid ASC
+        LIMIT 1
+      `).get(localSessionId);
+            if (!row)
+                return undefined;
+            this.db.prepare("DELETE FROM queued_prompts WHERE prompt_id = ?").run(row.prompt_id);
+            return mapQueuedPrompt(row);
+        });
+        return take();
+    }
+    cancelQueuedPrompt(promptId, localSessionId) {
+        const cancel = this.db.transaction(() => {
+            const row = this.db.prepare(`
+        SELECT * FROM queued_prompts WHERE prompt_id = ? AND local_session_id = ?
+      `).get(promptId, localSessionId);
+            if (!row)
+                return undefined;
+            this.db.prepare("DELETE FROM queued_prompts WHERE prompt_id = ?").run(promptId);
+            return mapQueuedPrompt(row);
+        });
+        return cancel();
+    }
+    nextForkTitle(sourceTitle) {
+        const baseTitle = forkBaseTitle(sourceTitle);
+        const allocate = this.db.transaction(() => {
+            const existing = this.db
+                .prepare("SELECT last_sequence FROM fork_title_sequences WHERE base_title = ?")
+                .get(baseTitle);
+            const nextSequence = (existing?.last_sequence ?? 0) + 1;
+            this.db.prepare(`
+        INSERT INTO fork_title_sequences (base_title, last_sequence)
+        VALUES (?, ?)
+        ON CONFLICT(base_title) DO UPDATE SET last_sequence = excluded.last_sequence
+      `).run(baseTitle, nextSequence);
+            return nextSequence;
+        });
+        return formatForkTitle(baseTitle, allocate());
+    }
+    reconcileInterruptedAcpSessions(acpAgentNames) {
+        const agentClause = acpAgentNames.length
+            ? ` OR (runtime_kind IS NULL AND agent_name IN (${acpAgentNames.map(() => "?").join(", ")}))`
+            : "";
+        const rows = this.db
+            .prepare(`SELECT * FROM sessions WHERE status = 'running' AND (runtime_kind = 'acp'${agentClause})`)
+            .all(...acpAgentNames);
+        if (rows.length === 0)
+            return [];
+        const now = new Date().toISOString();
+        const completedAt = Date.now();
+        const reconcile = this.db.transaction(() => {
+            for (const row of rows) {
+                this.db.prepare(`
+          UPDATE sessions
+          SET status = 'failed',
+              last_turn_status = CASE WHEN last_turn_id IS NULL THEN last_turn_status ELSE 'failed' END,
+              updated_at = ?
+          WHERE local_session_id = ?
+        `).run(now, row.local_session_id);
+                if (!row.last_turn_id)
+                    continue;
+                const snapshotRow = this.db
+                    .prepare("SELECT snapshot_json FROM turn_snapshots WHERE turn_id = ?")
+                    .get(row.last_turn_id);
+                if (!snapshotRow)
+                    continue;
+                try {
+                    const snapshot = JSON.parse(snapshotRow.snapshot_json);
+                    if (!["starting", "running", "tool_running", "waiting_for_approval"].includes(String(snapshot.status)))
+                        continue;
+                    const startedAt = typeof snapshot.startedAt === "number" ? snapshot.startedAt : undefined;
+                    const failedSnapshot = {
+                        ...snapshot,
+                        status: "failed",
+                        completedAt,
+                        ...(startedAt === undefined ? {} : { durationMs: Math.max(0, completedAt - startedAt) }),
+                        error: "Agent Bot 已重启，原 ACP 进程中的执行无法继续。",
+                    };
+                    delete failedSnapshot.activeTool;
+                    delete failedSnapshot.approval;
+                    this.db.prepare(`
+            UPDATE turn_snapshots SET snapshot_json = ?, updated_at = ? WHERE turn_id = ?
+          `).run(JSON.stringify(failedSnapshot), now, row.last_turn_id);
+                }
+                catch {
+                    // Keep an unreadable historical snapshot intact while still correcting the session state.
+                }
+            }
+        });
+        reconcile();
+        return rows.map(mapSession);
+    }
+    setDefaultAgent(contextKey, agentName) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare("UPDATE user_contexts SET default_agent = ?, updated_at = ? WHERE context_key = ?")
+            .run(agentName, now, contextKey);
+    }
+    setBoundProjectCwd(contextKey, cwd) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare("UPDATE user_contexts SET bound_project_cwd = ?, updated_at = ? WHERE context_key = ?")
+            .run(cwd ? path.resolve(cwd) : null, now, contextKey);
+    }
+    setCurrentSession(contextKey, localSessionId) {
+        const now = new Date().toISOString();
+        if (localSessionId && this.getSession(localSessionId)) {
+            this.attachSessionToContext(contextKey, localSessionId);
+        }
+        this.db
+            .prepare(`
+        UPDATE user_contexts
+        SET previous_session_id = CASE
+              WHEN current_session_id IS NOT ? THEN current_session_id
+              ELSE previous_session_id
+            END,
+            current_session_id = ?,
+            updated_at = ?
+        WHERE context_key = ?
+      `)
+            .run(localSessionId ?? null, localSessionId ?? null, now, contextKey);
+    }
+    createSession(input) {
+        const now = new Date().toISOString();
+        const create = this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO sessions (
+          local_session_id,
+          context_key,
+          agent_name,
+          cwd,
+          acp_session_id,
+          status,
+          created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, NULL, ?, ?, ?)
+        `).run(input.localSessionId, input.contextKey, input.agentName, input.cwd, input.status, now, now);
+            this.db.prepare(`
+        INSERT INTO context_sessions (context_key, local_session_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?)
+      `).run(input.contextKey, input.localSessionId, now, now);
+        });
+        create();
+        return {
+            ...input,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    updateSession(localSessionId, patch) {
+        const existing = this.getSession(localSessionId);
+        if (!existing) {
+            return;
+        }
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`
+        UPDATE sessions
+        SET acp_session_id = ?, status = ?, updated_at = ?
+        WHERE local_session_id = ?
+        `)
+            .run(patch.acpSessionId ?? existing.acpSessionId ?? null, patch.status ?? existing.status, now, localSessionId);
+    }
+    updateRuntimeSession(localSessionId, patch) {
+        const existing = this.getSession(localSessionId);
+        if (!existing) {
+            return;
+        }
+        this.db
+            .prepare(`
+        UPDATE sessions
+        SET runtime_kind = ?, remote_session_id = ?, title = ?, model = ?, reasoning_effort = ?, permission_mode = ?,
+            last_turn_id = ?, last_turn_status = ?, updated_at = ?
+        WHERE local_session_id = ?
+        `)
+            .run(patch.runtimeKind ?? existing.runtimeKind ?? null, patch.remoteSessionId ?? existing.remoteSessionId ?? existing.acpSessionId ?? null, patch.title ?? existing.title ?? null, patch.model ?? existing.model ?? null, patch.reasoningEffort ?? existing.reasoningEffort ?? null, patch.permissionMode ?? existing.permissionMode ?? null, patch.lastTurnId ?? existing.lastTurnId ?? null, patch.lastTurnStatus ?? existing.lastTurnStatus ?? null, new Date().toISOString(), localSessionId);
+    }
+    saveTurnSnapshot(turnId, localSessionId, snapshot, contextKey) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`
+        INSERT INTO turn_snapshots (turn_id, local_session_id, context_key, snapshot_json, updated_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(turn_id) DO UPDATE SET
+          local_session_id = excluded.local_session_id,
+          context_key = coalesce(excluded.context_key, turn_snapshots.context_key),
+          snapshot_json = excluded.snapshot_json,
+          updated_at = excluded.updated_at
+        `)
+            .run(turnId, localSessionId, contextKey ?? null, JSON.stringify(snapshot), now);
+    }
+    promotePendingTurn(pendingTurnId, turnId, localSessionId, snapshot, contextKey) {
+        if (pendingTurnId === turnId) {
+            this.saveTurnSnapshot(turnId, localSessionId, snapshot, contextKey);
+            return;
+        }
+        this.db.transaction(() => {
+            const pendingDelivery = this.getTurnDelivery(pendingTurnId);
+            this.saveTurnSnapshot(turnId, localSessionId, snapshot, contextKey);
+            if (pendingDelivery) {
+                this.saveTurnDelivery(turnId, {
+                    progressMessageId: pendingDelivery.progressMessageId,
+                    lastCardHash: pendingDelivery.lastCardHash,
+                });
+            }
+            this.db.prepare("DELETE FROM turn_deliveries WHERE turn_id = ?").run(pendingTurnId);
+            this.db.prepare("DELETE FROM turn_snapshots WHERE turn_id = ?").run(pendingTurnId);
+        })();
+    }
+    getTurnSnapshot(turnId) {
+        const row = this.db
+            .prepare("SELECT snapshot_json FROM turn_snapshots WHERE turn_id = ?")
+            .get(turnId);
+        return row ? JSON.parse(row.snapshot_json) : undefined;
+    }
+    findLatestCompletedTurnId(localSessionId, contextKey) {
+        const row = this.db
+            .prepare(`
+        SELECT turn_id
+        FROM turn_snapshots
+        WHERE local_session_id = ?
+          AND context_key = ?
+          AND json_extract(snapshot_json, '$.status') = 'completed'
+        ORDER BY
+          coalesce(
+            json_extract(snapshot_json, '$.completedAt'),
+            json_extract(snapshot_json, '$.startedAt'),
+            0
+          ) DESC,
+          updated_at DESC
+        LIMIT 1
+      `)
+            .get(localSessionId, contextKey);
+        return row?.turn_id;
+    }
+    saveTurnDelivery(turnId, patch) {
+        const existing = this.getTurnDelivery(turnId);
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`
+        INSERT INTO turn_deliveries (
+          turn_id, progress_message_id, final_message_ids_json, final_delivered_at, last_card_hash, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(turn_id) DO UPDATE SET
+          progress_message_id = excluded.progress_message_id,
+          last_card_hash = excluded.last_card_hash,
+          updated_at = excluded.updated_at
+        `)
+            .run(turnId, patch.progressMessageId ?? existing?.progressMessageId ?? null, JSON.stringify(existing?.finalMessageIds ?? []), existing?.finalDeliveredAt ?? null, patch.lastCardHash ?? existing?.lastCardHash ?? null, now);
+    }
+    markFinalDelivered(turnId, messageIds) {
+        const now = new Date().toISOString();
+        const existing = this.getTurnDelivery(turnId);
+        this.db
+            .prepare(`
+        INSERT INTO turn_deliveries (
+          turn_id, progress_message_id, final_message_ids_json, final_delivered_at, last_card_hash, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(turn_id) DO UPDATE SET
+          final_message_ids_json = excluded.final_message_ids_json,
+          final_delivered_at = excluded.final_delivered_at,
+          updated_at = excluded.updated_at
+        `)
+            .run(turnId, existing?.progressMessageId ?? null, JSON.stringify(messageIds), now, existing?.lastCardHash ?? null, now);
+    }
+    saveFinalDeliveryProgress(turnId, messageIds) {
+        const now = new Date().toISOString();
+        const existing = this.getTurnDelivery(turnId);
+        this.db
+            .prepare(`
+        INSERT INTO turn_deliveries (
+          turn_id, progress_message_id, final_message_ids_json, final_delivered_at, last_card_hash, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(turn_id) DO UPDATE SET
+          final_message_ids_json = excluded.final_message_ids_json,
+          updated_at = excluded.updated_at
+        `)
+            .run(turnId, existing?.progressMessageId ?? null, JSON.stringify(messageIds), existing?.finalDeliveredAt ?? null, existing?.lastCardHash ?? null, now);
+    }
+    getTurnDelivery(turnId) {
+        const row = this.db
+            .prepare("SELECT * FROM turn_deliveries WHERE turn_id = ?")
+            .get(turnId);
+        if (!row) {
+            return undefined;
+        }
+        return {
+            progressMessageId: row.progress_message_id ?? undefined,
+            finalMessageIds: JSON.parse(row.final_message_ids_json),
+            finalDelivered: Boolean(row.final_delivered_at),
+            finalDeliveredAt: row.final_delivered_at ?? undefined,
+            lastCardHash: row.last_card_hash ?? undefined,
+        };
+    }
+    getSession(localSessionId) {
+        const row = this.db
+            .prepare("SELECT * FROM sessions WHERE local_session_id = ?")
+            .get(localSessionId);
+        return row ? mapSession(row) : undefined;
+    }
+    getSessionForContext(localSessionId, contextKey) {
+        const linked = this.db.prepare(`
+      SELECT 1
+      FROM context_sessions
+      WHERE context_key = ? AND local_session_id = ?
+    `).get(contextKey, localSessionId);
+        if (!linked)
+            return undefined;
+        const session = this.getSession(localSessionId);
+        return session ? { ...session, contextKey } : undefined;
+    }
+    attachSessionToContext(contextKey, localSessionId) {
+        if (!this.getSession(localSessionId))
+            throw new Error(`找不到任务：${localSessionId}`);
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO context_sessions (context_key, local_session_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(context_key, local_session_id) DO UPDATE SET updated_at = excluded.updated_at
+    `).run(contextKey, localSessionId, now, now);
+    }
+    listSessions(contextKey) {
+        const rows = this.db
+            .prepare(`
+        SELECT sessions.*
+        FROM context_sessions
+        JOIN sessions ON sessions.local_session_id = context_sessions.local_session_id
+        WHERE context_sessions.context_key = ?
+        ORDER BY context_sessions.created_at DESC
+      `)
+            .all(contextKey);
+        return rows.map((row) => ({ ...mapSession(row), contextKey }));
+    }
+    listAllSessions() {
+        const rows = this.db
+            .prepare("SELECT * FROM sessions ORDER BY updated_at DESC, created_at DESC")
+            .all();
+        return rows.map(mapSession);
+    }
+    getServerActivityState() {
+        const running = this.db
+            .prepare(`
+        SELECT COUNT(*) AS count
+        FROM sessions
+        WHERE status = 'running'
+           OR EXISTS (
+             SELECT 1 FROM queued_prompts WHERE queued_prompts.local_session_id = sessions.local_session_id
+           )
+      `)
+            .get();
+        const pending = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM sessions x
+      JOIN turn_snapshots s ON s.turn_id = x.last_turn_id
+      LEFT JOIN turn_deliveries d ON d.turn_id = s.turn_id
+      WHERE json_extract(s.snapshot_json, '$.status') = 'completed'
+        AND length(coalesce(json_extract(s.snapshot_json, '$.finalResponse'), '')) > 0
+        AND d.final_delivered_at IS NULL
+    `).get();
+        const inbound = this.db
+            .prepare("SELECT max(created_at) AS latest FROM inbound_event_receipts")
+            .get();
+        return {
+            runningSessions: running.count,
+            pendingFinalDeliveries: pending.count,
+            latestInboundAt: inbound.latest ?? undefined,
+        };
+    }
+    findSessionByRemoteSessionId(remoteSessionId, contextKey) {
+        const row = contextKey
+            ? this.db
+                .prepare(`
+            SELECT sessions.*
+            FROM sessions
+            JOIN context_sessions ON context_sessions.local_session_id = sessions.local_session_id
+            WHERE sessions.remote_session_id = ?
+              AND context_sessions.context_key = ?
+              AND sessions.status != 'closed'
+            LIMIT 1
+          `)
+                .get(remoteSessionId, contextKey)
+            : this.db
+                .prepare(`
+            SELECT * FROM sessions
+            WHERE remote_session_id = ? AND status != 'closed'
+            ORDER BY created_at ASC LIMIT 1
+          `)
+                .get(remoteSessionId);
+        return row ? { ...mapSession(row), ...(contextKey ? { contextKey } : {}) } : undefined;
+    }
+    getTurnContextKey(turnId) {
+        const row = this.db.prepare("SELECT context_key FROM turn_snapshots WHERE turn_id = ?")
+            .get(turnId);
+        return row?.context_key ?? undefined;
+    }
+    audit(contextKey, eventType, payload) {
+        this.db
+            .prepare(`
+        INSERT INTO audit_events (context_key, event_type, payload_json, created_at)
+        VALUES (?, ?, ?, ?)
+        `)
+            .run(contextKey, eventType, JSON.stringify(payload), new Date().toISOString());
+    }
+    claimInboundEvent(eventId, eventKind) {
+        const result = this.db
+            .prepare(`
+        INSERT OR IGNORE INTO inbound_event_receipts (event_id, event_kind, created_at)
+        VALUES (?, ?, ?)
+        `)
+            .run(eventId, eventKind, new Date().toISOString());
+        return result.changes === 1;
+    }
+    saveMessageReaction(messageId, contextKey, reactionId, emojiType) {
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO message_reactions (
+        message_id, context_key, reaction_id, emoji_type, status, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, 'pending', ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET
+        context_key = excluded.context_key,
+        reaction_id = excluded.reaction_id,
+        emoji_type = excluded.emoji_type,
+        status = 'pending',
+        updated_at = excluded.updated_at
+    `).run(messageId, contextKey, reactionId, emojiType, now, now);
+    }
+    bindMessageReaction(messageId, localSessionId, turnId) {
+        this.db.prepare(`
+      UPDATE message_reactions
+      SET local_session_id = ?, turn_id = ?, updated_at = ?
+      WHERE message_id = ? AND status = 'pending'
+    `).run(localSessionId, turnId, new Date().toISOString(), messageId);
+    }
+    bindMessageToTurn(messageId, localSessionId, turnId) {
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO message_turn_bindings (message_id, local_session_id, turn_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET
+        local_session_id = excluded.local_session_id,
+        turn_id = excluded.turn_id,
+        updated_at = excluded.updated_at
+    `).run(messageId, localSessionId, turnId, now, now);
+    }
+    claimMessageReactionsForTurn(turnId) {
+        const claim = this.db.transaction(() => {
+            const rows = this.db.prepare(`
+        SELECT * FROM message_reactions WHERE turn_id = ? AND status = 'pending' ORDER BY created_at ASC
+      `).all(turnId);
+            if (rows.length > 0) {
+                this.db.prepare(`
+          UPDATE message_reactions SET status = 'updating', updated_at = ?
+          WHERE turn_id = ? AND status = 'pending'
+        `).run(new Date().toISOString(), turnId);
+            }
+            return rows.map((row) => ({ ...mapMessageReaction(row), status: "updating" }));
+        });
+        return claim();
+    }
+    claimMessageReaction(messageId) {
+        const claim = this.db.transaction(() => {
+            const row = this.db.prepare(`
+        SELECT * FROM message_reactions WHERE message_id = ? AND status = 'pending'
+      `).get(messageId);
+            if (!row)
+                return undefined;
+            this.db.prepare(`
+        UPDATE message_reactions SET status = 'updating', updated_at = ? WHERE message_id = ? AND status = 'pending'
+      `).run(new Date().toISOString(), messageId);
+            return { ...mapMessageReaction(row), status: "updating" };
+        });
+        return claim();
+    }
+    listPendingMessageReactions() {
+        const rows = this.db.prepare(`
+      SELECT * FROM message_reactions WHERE status = 'pending' AND turn_id IS NOT NULL ORDER BY created_at ASC
+    `).all();
+        return rows.map(mapMessageReaction);
+    }
+    finishMessageReaction(messageId, reactionId, emojiType, status) {
+        this.db.prepare(`
+      UPDATE message_reactions
+      SET reaction_id = ?, emoji_type = ?, status = ?, updated_at = ?
+      WHERE message_id = ?
+    `).run(reactionId, emojiType, status, new Date().toISOString(), messageId);
+    }
+    releaseMessageReaction(messageId) {
+        this.db.prepare(`
+      UPDATE message_reactions SET status = 'pending', updated_at = ?
+      WHERE message_id = ? AND status = 'updating'
+    `).run(new Date().toISOString(), messageId);
+    }
+    getMessageReaction(messageId) {
+        const row = this.db.prepare("SELECT * FROM message_reactions WHERE message_id = ?")
+            .get(messageId);
+        return row ? mapMessageReaction(row) : undefined;
+    }
+    findTurnAnchorByMessageId(messageId) {
+        const binding = this.db.prepare(`
+      SELECT turn_id, local_session_id
+      FROM message_turn_bindings
+      WHERE message_id = ?
+      LIMIT 1
+    `).get(messageId);
+        if (binding) {
+            return {
+                turnId: binding.turn_id,
+                localSessionId: binding.local_session_id,
+                contextKey: this.getTurnContextKey(binding.turn_id),
+            };
+        }
+        const reaction = this.db.prepare(`
+      SELECT turn_id, local_session_id
+      FROM message_reactions
+      WHERE message_id = ? AND turn_id IS NOT NULL AND local_session_id IS NOT NULL
+      LIMIT 1
+    `).get(messageId);
+        if (reaction) {
+            const context = this.db.prepare("SELECT context_key FROM message_reactions WHERE message_id = ?")
+                .get(messageId);
+            return {
+                turnId: reaction.turn_id,
+                localSessionId: reaction.local_session_id,
+                contextKey: context?.context_key ?? this.getTurnContextKey(reaction.turn_id),
+            };
+        }
+        const delivery = this.db.prepare(`
+      SELECT deliveries.turn_id, snapshots.local_session_id
+      FROM turn_deliveries AS deliveries
+      JOIN turn_snapshots AS snapshots ON snapshots.turn_id = deliveries.turn_id
+      WHERE deliveries.progress_message_id = ?
+         OR EXISTS (
+           SELECT 1
+           FROM json_each(deliveries.final_message_ids_json)
+           WHERE json_each.value = ?
+         )
+      ORDER BY deliveries.updated_at DESC
+      LIMIT 1
+    `).get(messageId, messageId);
+        return delivery
+            ? {
+                turnId: delivery.turn_id,
+                localSessionId: delivery.local_session_id,
+                contextKey: this.getTurnContextKey(delivery.turn_id),
+            }
+            : undefined;
+    }
+    initializeContextSessionMappings() {
+        this.db.exec(`
+      INSERT OR IGNORE INTO context_sessions (context_key, local_session_id, created_at, updated_at)
+      SELECT context_key, local_session_id, created_at, updated_at FROM sessions;
+
+      UPDATE turn_snapshots
+      SET context_key = (
+        SELECT sessions.context_key
+        FROM sessions
+        WHERE sessions.local_session_id = turn_snapshots.local_session_id
+      )
+      WHERE context_key IS NULL;
+    `);
+    }
+    reconcileDuplicateRemoteSessions() {
+        const duplicateIds = this.db.prepare(`
+      SELECT remote_session_id
+      FROM sessions
+      WHERE remote_session_id IS NOT NULL
+      GROUP BY remote_session_id
+      HAVING count(*) > 1
+    `).all();
+        if (duplicateIds.length === 0)
+            return;
+        const reconcile = this.db.transaction(() => {
+            for (const { remote_session_id: remoteSessionId } of duplicateIds) {
+                const rows = this.db.prepare(`
+          SELECT * FROM sessions
+          WHERE remote_session_id = ?
+          ORDER BY created_at ASC
+        `).all(remoteSessionId);
+                const canonical = rows[0];
+                if (!canonical)
+                    continue;
+                const latest = [...rows].sort((left, right) => right.updated_at.localeCompare(left.updated_at))[0] ?? canonical;
+                for (const duplicate of rows.slice(1)) {
+                    this.db.prepare(`
+            INSERT OR IGNORE INTO context_sessions (context_key, local_session_id, created_at, updated_at)
+            SELECT context_key, ?, created_at, updated_at
+            FROM context_sessions
+            WHERE local_session_id = ?
+          `).run(canonical.local_session_id, duplicate.local_session_id);
+                    this.db.prepare(`
+            UPDATE user_contexts
+            SET current_session_id = CASE WHEN current_session_id = ? THEN ? ELSE current_session_id END,
+                previous_session_id = CASE WHEN previous_session_id = ? THEN ? ELSE previous_session_id END
+          `).run(duplicate.local_session_id, canonical.local_session_id, duplicate.local_session_id, canonical.local_session_id);
+                    this.db.prepare("UPDATE turn_snapshots SET local_session_id = ? WHERE local_session_id = ?")
+                        .run(canonical.local_session_id, duplicate.local_session_id);
+                    this.db.prepare("UPDATE message_reactions SET local_session_id = ? WHERE local_session_id = ?")
+                        .run(canonical.local_session_id, duplicate.local_session_id);
+                    this.db.prepare("UPDATE message_turn_bindings SET local_session_id = ? WHERE local_session_id = ?")
+                        .run(canonical.local_session_id, duplicate.local_session_id);
+                    this.db.prepare("UPDATE queued_prompts SET local_session_id = ? WHERE local_session_id = ?")
+                        .run(canonical.local_session_id, duplicate.local_session_id);
+                    this.db.prepare("DELETE FROM context_sessions WHERE local_session_id = ?")
+                        .run(duplicate.local_session_id);
+                    this.db.prepare("DELETE FROM sessions WHERE local_session_id = ?")
+                        .run(duplicate.local_session_id);
+                }
+                this.db.prepare(`
+          UPDATE sessions
+          SET agent_name = ?, cwd = ?, acp_session_id = ?, runtime_kind = ?, title = ?, model = ?,
+              reasoning_effort = ?, permission_mode = ?, last_turn_id = ?, last_turn_status = ?,
+              status = ?, updated_at = ?
+          WHERE local_session_id = ?
+        `).run(latest.agent_name, latest.cwd, latest.acp_session_id, latest.runtime_kind, latest.title, latest.model, latest.reasoning_effort, latest.permission_mode, latest.last_turn_id, latest.last_turn_status, latest.status, latest.updated_at, canonical.local_session_id);
+                this.db.prepare(`
+          UPDATE turn_snapshots
+          SET snapshot_json = json_set(snapshot_json, '$.sessionId', ?)
+          WHERE local_session_id = ? AND json_valid(snapshot_json)
+        `).run(canonical.local_session_id, canonical.local_session_id);
+            }
+        });
+        reconcile();
+    }
+    ensureSessionColumns() {
+        const existing = new Set(this.db.pragma("table_info(sessions)").map((column) => column.name));
+        const columns = [
+            ["runtime_kind", "TEXT"],
+            ["remote_session_id", "TEXT"],
+            ["title", "TEXT"],
+            ["model", "TEXT"],
+            ["reasoning_effort", "TEXT"],
+            ["permission_mode", "TEXT"],
+            ["last_turn_id", "TEXT"],
+            ["last_turn_status", "TEXT"],
+        ];
+        for (const [name, type] of columns) {
+            if (!existing.has(name)) {
+                this.db.exec(`ALTER TABLE sessions ADD COLUMN ${name} ${type}`);
+            }
+        }
+    }
+    ensureUserContextColumns() {
+        const existing = new Set(this.db.pragma("table_info(user_contexts)").map((column) => column.name));
+        if (!existing.has("previous_session_id")) {
+            this.db.exec("ALTER TABLE user_contexts ADD COLUMN previous_session_id TEXT");
+        }
+        if (!existing.has("bound_project_cwd")) {
+            this.db.exec("ALTER TABLE user_contexts ADD COLUMN bound_project_cwd TEXT");
+        }
+    }
+    ensureTurnSnapshotColumns() {
+        const existing = new Set(this.db.pragma("table_info(turn_snapshots)").map((column) => column.name));
+        if (!existing.has("context_key")) {
+            this.db.exec("ALTER TABLE turn_snapshots ADD COLUMN context_key TEXT");
+        }
+    }
+    ensureChatContextColumns() {
+        const existing = new Set(this.db.pragma("table_info(chat_contexts)").map((column) => column.name));
+        if (!existing.has("last_activity_at")) {
+            this.db.exec("ALTER TABLE chat_contexts ADD COLUMN last_activity_at TEXT");
+        }
+    }
+}
+const MAX_TASK_TITLE_LENGTH = 120;
+const FORK_TITLE_SUFFIX = /\s*（分支\s+(\d+)）$/u;
+function forkBaseTitle(sourceTitle) {
+    let title = sourceTitle?.replace(/\s+/g, " ").trim() || "未命名任务";
+    while (FORK_TITLE_SUFFIX.test(title))
+        title = title.replace(FORK_TITLE_SUFFIX, "").trim();
+    return title || "未命名任务";
+}
+function formatForkTitle(baseTitle, sequence) {
+    const suffix = `（分支 ${sequence}）`;
+    const available = Math.max(1, MAX_TASK_TITLE_LENGTH - suffix.length);
+    const truncatedBase = baseTitle.length <= available ? baseTitle : baseTitle.slice(0, available).trimEnd();
+    return `${truncatedBase}${suffix}`;
+}
+function mapUserContext(row) {
+    return {
+        contextKey: row.context_key,
+        defaultAgent: row.default_agent,
+        currentSessionId: row.current_session_id ?? undefined,
+        previousSessionId: row.previous_session_id ?? undefined,
+        boundProjectCwd: row.bound_project_cwd ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapSession(row) {
+    return {
+        localSessionId: row.local_session_id,
+        contextKey: row.context_key,
+        agentName: row.agent_name,
+        cwd: row.cwd,
+        acpSessionId: row.acp_session_id ?? undefined,
+        runtimeKind: row.runtime_kind ?? (row.acp_session_id ? "acp" : undefined),
+        remoteSessionId: row.remote_session_id ?? row.acp_session_id ?? undefined,
+        title: row.title ?? undefined,
+        model: row.model ?? undefined,
+        reasoningEffort: row.reasoning_effort ?? undefined,
+        permissionMode: row.permission_mode ?? undefined,
+        lastTurnId: row.last_turn_id ?? undefined,
+        lastTurnStatus: row.last_turn_status ?? undefined,
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapMessageReaction(row) {
+    return {
+        messageId: row.message_id,
+        contextKey: row.context_key,
+        reactionId: row.reaction_id,
+        emojiType: row.emoji_type,
+        localSessionId: row.local_session_id ?? undefined,
+        turnId: row.turn_id ?? undefined,
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapQueuedPrompt(row) {
+    const parsedPaths = JSON.parse(row.local_image_paths_json);
+    const localImagePaths = Array.isArray(parsedPaths)
+        ? parsedPaths.filter((value) => typeof value === "string")
+        : [];
+    return {
+        promptId: row.prompt_id,
+        localSessionId: row.local_session_id,
+        contextKey: row.context_key,
+        text: row.prompt_text,
+        localImagePaths: localImagePaths.length > 0 ? localImagePaths : undefined,
+        messageId: row.message_id ?? undefined,
+        replyMessageId: row.reply_message_id ?? undefined,
+        createdAt: row.created_at,
+    };
+}
+//# sourceMappingURL=StateStore.js.map