feishu-codex-console 1.0.0-beta.6

package/dist/state-store.js

@@ -0,0 +1,874 @@
+import { chmod, mkdir, open, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createRuntimeBackupFromDatabase, restoreRuntimeBackupFile, } from "./state-backup.js";
+export const PERSISTED_STATE_VERSION = 6;
+export const STATE_SCHEMA_VERSION = 1;
+function freshState() {
+    return {
+        version: PERSISTED_STATE_VERSION,
+        threads: {},
+        projects: {},
+        chats: {},
+        seenEvents: [],
+        tasks: {},
+        projectCards: {},
+        confirmations: {},
+        preferences: {},
+        device: { remoteReadyEnabled: false, updatedAt: new Date(0).toISOString() },
+    };
+}
+function isPersistedState(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === 6 &&
+        isRecord(value.threads) &&
+        isRecord(value.projects) &&
+        isRecord(value.chats) &&
+        Array.isArray(value.seenEvents) &&
+        isRecord(value.tasks) &&
+        isRecord(value.projectCards) &&
+        isRecord(value.confirmations) &&
+        isRecord(value.preferences) &&
+        isRecord(value.device) &&
+        typeof value.device.remoteReadyEnabled === "boolean");
+}
+function isLegacyV5State(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === 5 &&
+        isRecord(value.threads) &&
+        isRecord(value.projects) &&
+        isRecord(value.chats) &&
+        Array.isArray(value.seenEvents) &&
+        isRecord(value.tasks) &&
+        isRecord(value.projectCards) &&
+        isRecord(value.confirmations) &&
+        isRecord(value.device));
+}
+function isLegacyV4State(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === 4 &&
+        isRecord(value.threads) &&
+        isRecord(value.projects) &&
+        Array.isArray(value.seenEvents) &&
+        isRecord(value.tasks) &&
+        isRecord(value.projectCards));
+}
+function isLegacyV3State(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === 3 &&
+        isRecord(value.threads) &&
+        isRecord(value.projects) &&
+        Array.isArray(value.seenEvents) &&
+        isRecord(value.tasks) &&
+        isRecord(value.projectCards));
+}
+function isLegacyV2State(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === 2 &&
+        isRecord(value.threads) &&
+        isRecord(value.projects) &&
+        Array.isArray(value.seenEvents));
+}
+function isLegacyV1State(value) {
+    if (!isRecord(value))
+        return false;
+    return value.version === 1 && isRecord(value.threads) && Array.isArray(value.seenEvents);
+}
+export class StateStore {
+    databaseFile;
+    maxSeenEvents;
+    legacyStateFile;
+    state = freshState();
+    database = null;
+    constructor(databaseFile, maxSeenEvents, legacyStateFile) {
+        this.databaseFile = databaseFile;
+        this.maxSeenEvents = maxSeenEvents;
+        this.legacyStateFile = legacyStateFile;
+    }
+    async load() {
+        if (this.database)
+            return;
+        await ensurePrivateDatabasePath(this.databaseFile);
+        const database = new DatabaseSync(this.databaseFile);
+        this.database = database;
+        let migrationBackup;
+        try {
+            database.exec("PRAGMA journal_mode = WAL");
+            database.exec("PRAGMA synchronous = FULL");
+            database.exec("PRAGMA busy_timeout = 5000");
+            const sqliteUserVersion = databaseUserVersion(database);
+            if (sqliteUserVersion > STATE_SCHEMA_VERSION) {
+                throw new Error(`database schema ${sqliteUserVersion} is newer than supported ${STATE_SCHEMA_VERSION}`);
+            }
+            const existingSchema = databaseObjectCount(database) > 0;
+            const storedStateVersion = databaseStateVersion(database);
+            const migrationReasons = [
+                ...(sqliteUserVersion < STATE_SCHEMA_VERSION
+                    ? [`schema-${sqliteUserVersion}-to-${STATE_SCHEMA_VERSION}`]
+                    : []),
+                ...(storedStateVersion !== undefined && storedStateVersion !== PERSISTED_STATE_VERSION
+                    ? [`state-${storedStateVersion}-to-${PERSISTED_STATE_VERSION}`]
+                    : []),
+            ];
+            if (existingSchema && migrationReasons.length > 0) {
+                migrationBackup = await createRuntimeBackupFromDatabase(database, this.databaseFile, {
+                    reason: migrationReasons.join("_"),
+                });
+            }
+            database.exec("BEGIN IMMEDIATE");
+            try {
+                database.exec(`
+        CREATE TABLE IF NOT EXISTS bridge_state (
+          id INTEGER PRIMARY KEY CHECK (id = 1),
+          version INTEGER NOT NULL,
+          payload TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS outbox (
+          id TEXT PRIMARY KEY,
+          kind TEXT NOT NULL,
+          payload TEXT NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL,
+          next_attempt_at TEXT NOT NULL,
+          last_error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS outbox_due_idx ON outbox(next_attempt_at, created_at);
+        CREATE TABLE IF NOT EXISTS audit_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          occurred_at TEXT NOT NULL,
+          actor_id TEXT NOT NULL,
+          action TEXT NOT NULL,
+          resource_type TEXT NOT NULL,
+          resource_id TEXT NOT NULL,
+          outcome TEXT NOT NULL,
+          detail TEXT
+        );
+        CREATE INDEX IF NOT EXISTS audit_log_time_idx ON audit_log(occurred_at DESC);
+        CREATE TABLE IF NOT EXISTS thread_access (
+          thread_id TEXT NOT NULL,
+          owner_id TEXT NOT NULL,
+          conversation_key TEXT NOT NULL,
+          project_path TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          PRIMARY KEY (thread_id, owner_id)
+        );
+        CREATE INDEX IF NOT EXISTS thread_access_owner_project_idx
+          ON thread_access(owner_id, project_path, updated_at DESC);
+        CREATE TABLE IF NOT EXISTS onboarding_state (
+          conversation_key TEXT PRIMARY KEY,
+          owner_id TEXT NOT NULL,
+          status TEXT NOT NULL,
+          step INTEGER NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS permission_leases (
+          conversation_key TEXT PRIMARY KEY,
+          owner_id TEXT NOT NULL,
+          project_path TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          thread_id TEXT,
+          remaining_uses INTEGER NOT NULL,
+          expires_at TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS permission_leases_expiry_idx
+          ON permission_leases(expires_at);
+        CREATE TABLE IF NOT EXISTS device_cards (
+          message_id TEXT PRIMARY KEY,
+          card_id TEXT NOT NULL,
+          conversation_key TEXT NOT NULL,
+          owner_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          created_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS device_cards_created_idx
+          ON device_cards(created_at DESC);
+        CREATE TABLE IF NOT EXISTS device_recovery_notice (
+          conversation_key TEXT PRIMARY KEY,
+          notified_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS project_usage (
+          owner_id TEXT NOT NULL,
+          project_path TEXT NOT NULL,
+          favorite INTEGER NOT NULL DEFAULT 0,
+          last_used_at TEXT,
+          use_count INTEGER NOT NULL DEFAULT 0,
+          PRIMARY KEY (owner_id, project_path)
+        );
+        CREATE INDEX IF NOT EXISTS project_usage_recent_idx
+          ON project_usage(owner_id, favorite DESC, last_used_at DESC);
+        `);
+                const permissionLeaseColumns = database
+                    .prepare("PRAGMA table_info(permission_leases)")
+                    .all();
+                if (!permissionLeaseColumns.some((column) => column.name === "project_path")) {
+                    // Leases are deliberately ephemeral. An old lease is retained only as an
+                    // invalid row and will be revoked on its next lookup instead of guessing
+                    // which project it belonged to.
+                    database.exec("ALTER TABLE permission_leases ADD COLUMN project_path TEXT NOT NULL DEFAULT ''");
+                }
+                database.exec(`PRAGMA user_version = ${STATE_SCHEMA_VERSION}`);
+                database.exec("COMMIT");
+            }
+            catch (error) {
+                database.exec("ROLLBACK");
+                throw error;
+            }
+            const integrity = database.prepare("PRAGMA quick_check").get();
+            if (integrity?.quick_check !== "ok") {
+                throw new Error(`database integrity check failed: ${integrity?.quick_check ?? "unknown"}`);
+            }
+            await secureSqliteFiles(this.databaseFile);
+            const row = database
+                .prepare("SELECT payload FROM bridge_state WHERE id = 1")
+                .get();
+            if (row?.payload) {
+                this.state = migrateState(JSON.parse(row.payload));
+                await this.persist();
+                return;
+            }
+            if (this.legacyStateFile) {
+                try {
+                    const raw = await readFile(this.legacyStateFile, "utf8");
+                    this.state = migrateState(JSON.parse(raw));
+                    await writeFile(this.legacyStateFile, `${JSON.stringify(this.state, null, 2)}\n`, {
+                        encoding: "utf8",
+                        mode: 0o600,
+                    });
+                    await chmod(this.legacyStateFile, 0o600);
+                    console.info(`[state] migrated legacy JSON state into SQLite: ${this.legacyStateFile}`);
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT") {
+                        throw new Error(`Unable to migrate legacy bridge state: ${error.message}`);
+                    }
+                }
+            }
+            await this.persist();
+        }
+        catch (error) {
+            database.close();
+            this.database = null;
+            if (migrationBackup) {
+                try {
+                    await restoreRuntimeBackupFile(migrationBackup.databaseFile, this.databaseFile);
+                }
+                catch (rollbackError) {
+                    throw new Error(`Unable to load bridge state: ${error.message}; automatic rollback failed: ${rollbackError.message}`);
+                }
+            }
+            throw new Error(`Unable to load bridge state: ${error.message}`);
+        }
+    }
+    getThread(conversationKey) {
+        return this.state.threads[conversationKey]?.threadId;
+    }
+    get threadCount() {
+        return Object.keys(this.state.threads).length;
+    }
+    getProject(conversationKey) {
+        return this.state.projects[conversationKey]?.path;
+    }
+    getChatType(conversationKey) {
+        return this.state.chats[conversationKey]?.type;
+    }
+    getRemoteReady() {
+        return this.state.device.remoteReadyEnabled;
+    }
+    async setRemoteReady(enabled) {
+        if (this.state.device.remoteReadyEnabled === enabled)
+            return;
+        this.state.device = { remoteReadyEnabled: enabled, updatedAt: new Date().toISOString() };
+        await this.persist();
+    }
+    async setChatType(conversationKey, type) {
+        if (this.state.chats[conversationKey]?.type === type)
+            return;
+        this.state.chats[conversationKey] = { type, updatedAt: new Date().toISOString() };
+        await this.persist();
+    }
+    async setProject(conversationKey, projectPath) {
+        const previous = this.state.projects[conversationKey]?.path;
+        if (previous === projectPath)
+            return { changed: false, threadReset: false };
+        const threadReset = conversationKey in this.state.threads;
+        this.state.projects[conversationKey] = {
+            path: projectPath,
+            updatedAt: new Date().toISOString(),
+        };
+        delete this.state.threads[conversationKey];
+        this.revokePermissionLease(conversationKey);
+        await this.persist();
+        return { changed: true, threadReset };
+    }
+    async setThread(conversationKey, threadId) {
+        const previous = this.state.threads[conversationKey]?.threadId;
+        if (previous && previous !== threadId)
+            this.revokeSessionPermissionLease(conversationKey);
+        this.state.threads[conversationKey] = {
+            threadId,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.persist();
+    }
+    async registerThreadAccess(threadId, conversationKey, ownerId, projectPath) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO thread_access
+          (thread_id, owner_id, conversation_key, project_path, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(thread_id, owner_id) DO UPDATE SET
+           conversation_key = excluded.conversation_key,
+           project_path = excluded.project_path,
+           updated_at = excluded.updated_at`)
+            .run(threadId, ownerId, conversationKey, projectPath, new Date().toISOString());
+    }
+    listOwnedThreadIds(ownerId, projectPath) {
+        const rows = this.requireDatabase()
+            .prepare(`SELECT thread_id FROM thread_access
+         WHERE owner_id = ? AND project_path = ?
+         ORDER BY updated_at DESC`)
+            .all(ownerId, projectPath);
+        return new Set(rows.map((row) => row.thread_id));
+    }
+    getOnboarding(conversationKey) {
+        const row = this.requireDatabase()
+            .prepare(`SELECT owner_id, status, step, updated_at
+         FROM onboarding_state WHERE conversation_key = ?`)
+            .get(conversationKey);
+        if (!row || !["active", "completed", "dismissed"].includes(row.status))
+            return undefined;
+        const step = row.step === 2 ? 2 : row.step === 3 ? 3 : row.step === 4 ? 4 : 1;
+        return {
+            ownerId: row.owner_id,
+            status: row.status,
+            step,
+            updatedAt: row.updated_at,
+        };
+    }
+    async setOnboarding(conversationKey, ownerId, status, step) {
+        const updatedAt = new Date().toISOString();
+        this.requireDatabase()
+            .prepare(`INSERT INTO onboarding_state
+          (conversation_key, owner_id, status, step, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(conversation_key) DO UPDATE SET
+           owner_id = excluded.owner_id,
+           status = excluded.status,
+           step = excluded.step,
+           updated_at = excluded.updated_at`)
+            .run(conversationKey, ownerId, status, step, updatedAt);
+        return { ownerId, status, step, updatedAt };
+    }
+    async resetThread(conversationKey) {
+        const existed = conversationKey in this.state.threads;
+        delete this.state.threads[conversationKey];
+        this.revokeSessionPermissionLease(conversationKey);
+        if (existed)
+            await this.persist();
+        return existed;
+    }
+    getPreferences(conversationKey) {
+        const preferences = this.state.preferences[conversationKey];
+        return preferences ? structuredClone(preferences) : undefined;
+    }
+    async setPreferences(conversationKey, preferences) {
+        const saved = {
+            ...preferences,
+            updatedAt: new Date().toISOString(),
+        };
+        this.state.preferences[conversationKey] = saved;
+        await this.persist();
+        return structuredClone(saved);
+    }
+    getPermissionLease(conversationKey, ownerId, now = Date.now()) {
+        const row = this.requireDatabase()
+            .prepare(`SELECT conversation_key, owner_id, project_path, scope, thread_id, remaining_uses,
+                expires_at, created_at, updated_at
+         FROM permission_leases WHERE conversation_key = ?`)
+            .get(conversationKey);
+        if (!row)
+            return undefined;
+        if (row.owner_id !== ownerId ||
+            !isPermissionLeaseScope(row.scope) ||
+            row.remaining_uses <= 0 ||
+            Date.parse(row.expires_at) <= now) {
+            this.requireDatabase()
+                .prepare("DELETE FROM permission_leases WHERE conversation_key = ?")
+                .run(conversationKey);
+            return undefined;
+        }
+        return permissionLeaseFromRow(row);
+    }
+    async setPermissionLease(lease) {
+        const now = new Date().toISOString();
+        const saved = {
+            ...lease,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.requireDatabase()
+            .prepare(`INSERT INTO permission_leases
+          (conversation_key, owner_id, project_path, scope, thread_id, remaining_uses,
+           expires_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(conversation_key) DO UPDATE SET
+           owner_id = excluded.owner_id,
+           project_path = excluded.project_path,
+           scope = excluded.scope,
+           thread_id = excluded.thread_id,
+           remaining_uses = excluded.remaining_uses,
+           expires_at = excluded.expires_at,
+           created_at = excluded.created_at,
+           updated_at = excluded.updated_at`)
+            .run(saved.conversationKey, saved.ownerId, saved.projectPath, saved.scope, saved.threadId ?? null, saved.remainingUses, saved.expiresAt, saved.createdAt, saved.updatedAt);
+        return saved;
+    }
+    consumePermissionLease(conversationKey, ownerId, projectPath, threadId, now = Date.now()) {
+        const lease = this.getPermissionLease(conversationKey, ownerId, now);
+        if (!lease)
+            return undefined;
+        if (lease.projectPath !== projectPath) {
+            this.revokePermissionLease(conversationKey);
+            return undefined;
+        }
+        if (lease.scope === "session" && (!threadId || lease.threadId !== threadId)) {
+            this.revokePermissionLease(conversationKey);
+            return undefined;
+        }
+        if (lease.scope === "next-task") {
+            this.revokePermissionLease(conversationKey);
+        }
+        return lease;
+    }
+    revokePermissionLease(conversationKey) {
+        const result = this.requireDatabase()
+            .prepare("DELETE FROM permission_leases WHERE conversation_key = ?")
+            .run(conversationKey);
+        return Number(result.changes) > 0;
+    }
+    revokeSessionPermissionLease(conversationKey) {
+        this.requireDatabase()
+            .prepare("DELETE FROM permission_leases WHERE conversation_key = ? AND scope = 'session'")
+            .run(conversationKey);
+    }
+    async markEventIfNew(eventId) {
+        if (this.state.seenEvents.some((event) => event.id === eventId))
+            return false;
+        this.state.seenEvents.push({ id: eventId, seenAt: new Date().toISOString() });
+        if (this.state.seenEvents.length > this.maxSeenEvents) {
+            this.state.seenEvents.splice(0, this.state.seenEvents.length - this.maxSeenEvents);
+        }
+        await this.persist();
+        return true;
+    }
+    hasSeenEvent(eventId) {
+        return this.state.seenEvents.some((event) => event.id === eventId);
+    }
+    listTasks() {
+        return Object.values(this.state.tasks).map((task) => structuredClone(task));
+    }
+    async upsertTask(task) {
+        this.state.tasks[task.id] = structuredClone(task);
+        const completed = Object.values(this.state.tasks)
+            .filter((candidate) => candidate.status !== "queued" && candidate.status !== "running")
+            .sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+        while (Object.keys(this.state.tasks).length > 100 && completed.length > 0) {
+            const oldest = completed.shift();
+            if (oldest)
+                delete this.state.tasks[oldest.id];
+        }
+        await this.persist();
+    }
+    async removeTask(taskId) {
+        if (!(taskId in this.state.tasks))
+            return;
+        delete this.state.tasks[taskId];
+        await this.persist();
+    }
+    listProjectCards() {
+        return Object.values(this.state.projectCards).map((card) => structuredClone(card));
+    }
+    async upsertProjectCard(card) {
+        this.state.projectCards[card.messageId] = structuredClone(card);
+        const cards = Object.values(this.state.projectCards).sort((left, right) => left.createdAt - right.createdAt);
+        while (cards.length > 50) {
+            const oldest = cards.shift();
+            if (oldest)
+                delete this.state.projectCards[oldest.messageId];
+        }
+        await this.persist();
+    }
+    async removeProjectCard(messageId) {
+        if (!(messageId in this.state.projectCards))
+            return;
+        delete this.state.projectCards[messageId];
+        await this.persist();
+    }
+    listDeviceCards() {
+        const rows = this.requireDatabase()
+            .prepare(`SELECT message_id, card_id, conversation_key, owner_id, sequence, created_at
+         FROM device_cards ORDER BY created_at DESC`)
+            .all();
+        return rows.map((row) => ({
+            messageId: String(row.message_id),
+            cardId: String(row.card_id),
+            conversationKey: String(row.conversation_key),
+            ownerId: String(row.owner_id),
+            sequence: Number(row.sequence),
+            createdAt: Number(row.created_at),
+        }));
+    }
+    async upsertDeviceCard(card) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO device_cards
+          (message_id, card_id, conversation_key, owner_id, sequence, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(message_id) DO UPDATE SET
+           card_id = excluded.card_id,
+           conversation_key = excluded.conversation_key,
+           owner_id = excluded.owner_id,
+           sequence = excluded.sequence,
+           created_at = excluded.created_at`)
+            .run(card.messageId, card.cardId, card.conversationKey, card.ownerId, card.sequence, card.createdAt);
+        const overflow = this.listDeviceCards().slice(30);
+        for (const stale of overflow)
+            await this.removeDeviceCard(stale.messageId);
+    }
+    async removeDeviceCard(messageId) {
+        this.requireDatabase().prepare("DELETE FROM device_cards WHERE message_id = ?").run(messageId);
+    }
+    getLastDeviceRecoveryNotice(conversationKey) {
+        const row = this.requireDatabase()
+            .prepare("SELECT notified_at FROM device_recovery_notice WHERE conversation_key = ?")
+            .get(conversationKey);
+        return row?.notified_at;
+    }
+    async setLastDeviceRecoveryNotice(conversationKey, notifiedAt) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO device_recovery_notice (conversation_key, notified_at)
+         VALUES (?, ?)
+         ON CONFLICT(conversation_key) DO UPDATE SET notified_at = excluded.notified_at`)
+            .run(conversationKey, notifiedAt);
+    }
+    listProjectUsage(ownerId) {
+        const rows = this.requireDatabase()
+            .prepare(`SELECT owner_id, project_path, favorite, last_used_at, use_count
+         FROM project_usage WHERE owner_id = ?
+         ORDER BY favorite DESC, last_used_at DESC`)
+            .all(ownerId);
+        return rows.map((row) => ({
+            ownerId: String(row.owner_id),
+            projectPath: String(row.project_path),
+            favorite: Number(row.favorite) === 1,
+            ...(typeof row.last_used_at === "string" ? { lastUsedAt: row.last_used_at } : {}),
+            useCount: Number(row.use_count),
+        }));
+    }
+    async recordProjectUse(ownerId, projectPath, usedAt = new Date().toISOString()) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO project_usage
+          (owner_id, project_path, favorite, last_used_at, use_count)
+         VALUES (?, ?, 0, ?, 1)
+         ON CONFLICT(owner_id, project_path) DO UPDATE SET
+           last_used_at = excluded.last_used_at,
+           use_count = project_usage.use_count + 1`)
+            .run(ownerId, projectPath, usedAt);
+    }
+    async toggleProjectFavorite(ownerId, projectPath) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO project_usage
+          (owner_id, project_path, favorite, last_used_at, use_count)
+         VALUES (?, ?, 1, NULL, 0)
+         ON CONFLICT(owner_id, project_path) DO UPDATE SET
+           favorite = CASE project_usage.favorite WHEN 1 THEN 0 ELSE 1 END`)
+            .run(ownerId, projectPath);
+        const row = this.requireDatabase()
+            .prepare("SELECT favorite FROM project_usage WHERE owner_id = ? AND project_path = ?")
+            .get(ownerId, projectPath);
+        return row?.favorite === 1;
+    }
+    listConfirmations() {
+        return Object.values(this.state.confirmations).map((confirmation) => structuredClone(confirmation));
+    }
+    async upsertConfirmation(confirmation) {
+        this.state.confirmations[confirmation.id] = structuredClone(confirmation);
+        await this.persist();
+    }
+    async removeConfirmation(confirmationId) {
+        if (!(confirmationId in this.state.confirmations))
+            return;
+        delete this.state.confirmations[confirmationId];
+        await this.persist();
+    }
+    async enqueueOutbox(item) {
+        this.requireDatabase()
+            .prepare(`INSERT OR IGNORE INTO outbox
+          (id, kind, payload, attempts, created_at, next_attempt_at, last_error)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(item.id, item.kind, JSON.stringify(item.payload), item.attempts, item.createdAt, item.nextAttemptAt, item.lastError ?? null);
+    }
+    listDueOutbox(now = new Date().toISOString(), limit = 50) {
+        const rows = this.requireDatabase()
+            .prepare(`SELECT id, kind, payload, attempts, created_at, next_attempt_at, last_error
+         FROM outbox WHERE next_attempt_at <= ? ORDER BY created_at LIMIT ?`)
+            .all(now, limit);
+        return rows.flatMap((row) => {
+            if (row.kind !== "reply_text" || typeof row.payload !== "string")
+                return [];
+            try {
+                const payload = JSON.parse(row.payload);
+                return [
+                    {
+                        id: String(row.id),
+                        kind: "reply_text",
+                        payload,
+                        attempts: Number(row.attempts),
+                        createdAt: String(row.created_at),
+                        nextAttemptAt: String(row.next_attempt_at),
+                        ...(typeof row.last_error === "string" ? { lastError: row.last_error } : {}),
+                    },
+                ];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    async markOutboxSent(id) {
+        this.requireDatabase().prepare("DELETE FROM outbox WHERE id = ?").run(id);
+    }
+    async markOutboxFailed(id, error) {
+        const row = this.requireDatabase()
+            .prepare("SELECT attempts FROM outbox WHERE id = ?")
+            .get(id);
+        if (!row)
+            return;
+        const attempts = (row.attempts ?? 0) + 1;
+        const delayMs = Math.min(60_000, 1_000 * 2 ** Math.min(attempts, 6));
+        this.requireDatabase()
+            .prepare("UPDATE outbox SET attempts = ?, next_attempt_at = ?, last_error = ? WHERE id = ?")
+            .run(attempts, new Date(Date.now() + delayMs).toISOString(), error.slice(0, 1_000), id);
+    }
+    async appendAudit(event) {
+        this.requireDatabase()
+            .prepare(`INSERT INTO audit_log
+          (occurred_at, actor_id, action, resource_type, resource_id, outcome, detail)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(event.occurredAt, event.actorId, event.action.slice(0, 120), event.resourceType, event.resourceId.slice(0, 500), event.outcome, event.detail?.slice(0, 2_000) ?? null);
+        this.requireDatabase().exec("DELETE FROM audit_log WHERE id NOT IN (SELECT id FROM audit_log ORDER BY id DESC LIMIT 5000)");
+    }
+    listAudit(limit = 20, actorId) {
+        const safeLimit = Math.max(1, Math.min(200, Math.trunc(limit)));
+        const rows = actorId
+            ? this.requireDatabase()
+                .prepare(`SELECT id, occurred_at, actor_id, action, resource_type, resource_id, outcome, detail
+             FROM audit_log WHERE actor_id = ? ORDER BY id DESC LIMIT ?`)
+                .all(actorId, safeLimit)
+            : this.requireDatabase()
+                .prepare(`SELECT id, occurred_at, actor_id, action, resource_type, resource_id, outcome, detail
+             FROM audit_log ORDER BY id DESC LIMIT ?`)
+                .all(safeLimit);
+        return rows.map((row) => ({
+            id: Number(row.id),
+            occurredAt: String(row.occurred_at),
+            actorId: String(row.actor_id),
+            action: String(row.action),
+            resourceType: String(row.resource_type),
+            resourceId: String(row.resource_id),
+            outcome: String(row.outcome),
+            ...(typeof row.detail === "string" ? { detail: row.detail } : {}),
+        }));
+    }
+    async flush() {
+        if (!this.database)
+            return;
+        this.database.exec("PRAGMA wal_checkpoint(PASSIVE)");
+    }
+    close() {
+        if (!this.database)
+            return;
+        this.database.close();
+        this.database = null;
+    }
+    async persist() {
+        const database = this.requireDatabase();
+        database.exec("BEGIN IMMEDIATE");
+        try {
+            database
+                .prepare(`INSERT INTO bridge_state (id, version, payload, updated_at)
+           VALUES (1, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             version = excluded.version,
+             payload = excluded.payload,
+             updated_at = excluded.updated_at`)
+                .run(this.state.version, JSON.stringify(this.state), new Date().toISOString());
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    requireDatabase() {
+        if (!this.database)
+            throw new Error("StateStore.load() must be called first");
+        return this.database;
+    }
+}
+async function ensurePrivateDatabasePath(databaseFile) {
+    if (databaseFile === ":memory:")
+        return;
+    const directory = path.dirname(databaseFile);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const handle = await open(databaseFile, "a", 0o600);
+    await handle.close();
+    await chmod(databaseFile, 0o600);
+}
+async function secureSqliteFiles(databaseFile) {
+    if (databaseFile === ":memory:")
+        return;
+    await Promise.all([databaseFile, `${databaseFile}-wal`, `${databaseFile}-shm`].map(async (file) => {
+        try {
+            await chmod(file, 0o600);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }));
+}
+function databaseUserVersion(database) {
+    const row = database.prepare("PRAGMA user_version").get();
+    return Number(row?.user_version ?? 0);
+}
+function databaseObjectCount(database) {
+    const row = database
+        .prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'")
+        .get();
+    return Number(row?.count ?? 0);
+}
+function databaseStateVersion(database) {
+    try {
+        const row = database.prepare("SELECT version FROM bridge_state WHERE id = 1").get();
+        return typeof row?.version === "number" ? row.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function migrateState(value) {
+    if (isPersistedState(value)) {
+        return {
+            ...value,
+            tasks: sanitizeTasks(value.tasks),
+            projectCards: sanitizeProjectCards(value.projectCards),
+            confirmations: sanitizeConfirmations(value.confirmations),
+        };
+    }
+    if (isLegacyV5State(value)) {
+        return {
+            version: 6,
+            threads: value.threads,
+            projects: value.projects,
+            chats: value.chats,
+            seenEvents: value.seenEvents,
+            tasks: sanitizeTasks(value.tasks),
+            projectCards: sanitizeProjectCards(value.projectCards),
+            confirmations: sanitizeConfirmations(value.confirmations),
+            preferences: {},
+            device: value.device,
+        };
+    }
+    if (isLegacyV4State(value)) {
+        return {
+            version: 6,
+            threads: value.threads,
+            projects: value.projects,
+            chats: value.chats ?? {},
+            seenEvents: value.seenEvents,
+            tasks: sanitizeTasks(value.tasks),
+            projectCards: sanitizeProjectCards(value.projectCards),
+            confirmations: sanitizeConfirmations(value.confirmations ?? {}),
+            preferences: {},
+            device: { remoteReadyEnabled: false, updatedAt: new Date().toISOString() },
+        };
+    }
+    if (isLegacyV3State(value)) {
+        return {
+            version: 6,
+            threads: value.threads,
+            projects: value.projects,
+            chats: value.chats ?? {},
+            seenEvents: value.seenEvents,
+            tasks: sanitizeTasks(value.tasks),
+            projectCards: sanitizeProjectCards(value.projectCards),
+            confirmations: {},
+            preferences: {},
+            device: { remoteReadyEnabled: false, updatedAt: new Date().toISOString() },
+        };
+    }
+    if (isLegacyV2State(value)) {
+        return {
+            ...freshState(),
+            threads: value.threads,
+            projects: value.projects,
+            seenEvents: value.seenEvents,
+        };
+    }
+    if (isLegacyV1State(value)) {
+        return { ...freshState(), threads: value.threads, seenEvents: value.seenEvents };
+    }
+    throw new Error("unsupported state shape");
+}
+function sanitizeTasks(tasks) {
+    return Object.fromEntries(Object.entries(tasks).map(([id, task]) => [
+        id,
+        {
+            ...task,
+            ownerId: task.ownerId || "legacy",
+            controllerId: task.controllerId || task.ownerId || "legacy",
+            settings: task.settings ?? { sandboxMode: "workspace-write" },
+            attachments: task.attachments.map((attachment) => ({
+                kind: attachment.kind,
+                path: attachment.path,
+                name: attachment.name,
+                sizeBytes: attachment.sizeBytes,
+            })),
+        },
+    ]));
+}
+function sanitizeProjectCards(cards) {
+    return Object.fromEntries(Object.entries(cards).map(([id, card]) => [id, { ...card, ownerId: card.ownerId || "legacy" }]));
+}
+function sanitizeConfirmations(confirmations) {
+    return Object.fromEntries(Object.entries(confirmations).map(([id, confirmation]) => [
+        id,
+        { ...confirmation, ownerId: confirmation.ownerId || "legacy" },
+    ]));
+}
+function isPermissionLeaseScope(value) {
+    return value === "next-task" || value === "timed" || value === "session";
+}
+function permissionLeaseFromRow(row) {
+    return {
+        conversationKey: row.conversation_key,
+        ownerId: row.owner_id,
+        projectPath: row.project_path,
+        scope: row.scope,
+        remainingUses: row.remaining_uses,
+        expiresAt: row.expires_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...(row.thread_id ? { threadId: row.thread_id } : {}),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}