@seele00/seele 0.1.63 → 0.1.64

package/server/dist/conversations/store.js

@@ -1,2466 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, } from "node:fs";
-import path from "node:path";
-import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
-import { openSqliteDatabase, runInTransaction, } from "../storage/sqlite.js";
-const conversations = new Map();
-const workspaceGroups = new Map();
-const workspaceDatabases = new Map();
-let workspaceRootPath = null;
-let centerDatabase = null;
-let defaultOwnerId = null;
-const DEFAULT_WORKSPACE_GROUP_ID = "default";
-const CENTER_SCHEMA_VERSION = 9;
-const WORKSPACE_SCHEMA_VERSION = 8;
-const WORKSPACE_MEMORY_ITEMS_SETTING_KEY = "workspace.memory.items";
-const WORKSPACE_RESPONSIBILITY_SETTING_KEY = "workspace.responsibility";
-const WORKSPACE_ENVIRONMENT_VALUE_PREFIX = "environment.";
-const WORKSPACE_ENVIRONMENT_DESCRIPTION_PREFIX = "environment_description.";
-const MAX_IN_MEMORY_EVENTS_PER_WORKSPACE = 500;
-const MAX_COMPACT_EVENT_TEXT_LENGTH = 4_000;
-const LEGACY_MIGRATED_DIR_NAME = "legacy-migrated";
-export function initializeConversationStore(input) {
-    workspaceRootPath = input.workspaceRoot;
-    defaultOwnerId = input.defaultOwnerId;
-    mkdirSync(input.workspaceRoot, { recursive: true });
-    centerDatabase = openCenterDatabase(input.centerDbPath);
-    conversations.clear();
-    workspaceGroups.clear();
-    for (const db of workspaceDatabases.values()) {
-        db.close();
-    }
-    workspaceDatabases.clear();
-    initializeCenterSchema(getCenterDatabase());
-    migrateLegacyWorkspaceGroups(input.workspaceRoot);
-    for (const entry of readdirSync(input.workspaceRoot)) {
-        const workspacePath = path.join(input.workspaceRoot, entry);
-        if (!statSync(workspacePath).isDirectory()) {
-            continue;
-        }
-        migrateLegacyWorkspace(input.workspaceRoot, workspacePath, input.defaultSandbox);
-    }
-    ensureDefaultWorkspaceGroup();
-    loadWorkspaceGroupsFromDatabase();
-    loadConversationsFromDatabase(input.defaultSandbox);
-    initializeWorkspaceUnreadBaselines();
-}
-export function closeConversationStore() {
-    for (const db of workspaceDatabases.values()) {
-        db.close();
-    }
-    workspaceDatabases.clear();
-    centerDatabase?.close();
-    centerDatabase = null;
-    workspaceRootPath = null;
-    defaultOwnerId = null;
-    conversations.clear();
-    workspaceGroups.clear();
-}
-export function listWorkspaceGroups() {
-    return [...workspaceGroups.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-}
-export function createWorkspaceGroup(title, ownerId) {
-    const now = new Date().toISOString();
-    const group = {
-        id: createWorkspaceGroupId(title),
-        ownerId,
-        title,
-        createdAt: now,
-        updatedAt: now,
-    };
-    workspaceGroups.set(group.id, group);
-    upsertWorkspaceGroup(group);
-    return group;
-}
-export function deleteWorkspaceGroup(id) {
-    if (id === DEFAULT_WORKSPACE_GROUP_ID || !workspaceGroups.has(id)) {
-        return false;
-    }
-    workspaceGroups.delete(id);
-    for (const conversation of conversations.values()) {
-        if (conversation.groupId === id) {
-            conversation.groupId = DEFAULT_WORKSPACE_GROUP_ID;
-            touch(conversation);
-        }
-    }
-    getCenterDatabase()
-        .prepare("delete from workspace_groups where id = ?")
-        .run(id);
-    return true;
-}
-export function setWorkspaceGroupTitle(id, title) {
-    const group = workspaceGroups.get(id);
-    if (!group) {
-        return null;
-    }
-    const updatedGroup = {
-        ...group,
-        title,
-        updatedAt: new Date().toISOString(),
-    };
-    upsertWorkspaceGroup(updatedGroup);
-    return updatedGroup;
-}
-export function hasWorkspaceGroup(id) {
-    return workspaceGroups.has(id);
-}
-export function listGlobalEnvironmentVariables() {
-    const rows = getCenterDatabase()
-        .prepare("select * from global_environment_variables order by key asc")
-        .all();
-    return rows.map(globalEnvironmentVariableFromRow);
-}
-export function getGlobalEnvironmentMap() {
-    return Object.fromEntries(listGlobalEnvironmentVariables().map((item) => [item.key, item.value]));
-}
-export function getGlobalEnvironmentDescriptions() {
-    return Object.fromEntries(listGlobalEnvironmentVariables().map((item) => [
-        item.key,
-        item.description,
-    ]));
-}
-export function listConversationEnvironmentVariables(conversation) {
-    const settings = readWorkspaceSettings(conversation.workspacePath);
-    const variables = Object.entries(settings)
-        .filter(([key]) => key.startsWith(WORKSPACE_ENVIRONMENT_VALUE_PREFIX))
-        .map(([settingKey, value]) => {
-        const key = settingKey.slice(WORKSPACE_ENVIRONMENT_VALUE_PREFIX.length);
-        const description = settings[`${WORKSPACE_ENVIRONMENT_DESCRIPTION_PREFIX}${key}`] ?? "";
-        const updatedAt = readWorkspaceSettingUpdatedAt(conversation.workspacePath, settingKey);
-        return {
-            key,
-            value,
-            description,
-            createdAt: updatedAt,
-            updatedAt,
-        };
-    })
-        .filter((item) => isValidStoredEnvironmentKey(item.key));
-    return variables.sort((left, right) => left.key.localeCompare(right.key));
-}
-export function getConversationEnvironmentMap(conversation) {
-    return Object.fromEntries(listConversationEnvironmentVariables(conversation).map((item) => [
-        item.key,
-        item.value,
-    ]));
-}
-export function getConversationEnvironmentDescriptions(conversation) {
-    return Object.fromEntries(listConversationEnvironmentVariables(conversation).map((item) => [
-        item.key,
-        item.description,
-    ]));
-}
-export function revealConversationEnvironmentVariable(conversation, key) {
-    return (listConversationEnvironmentVariables(conversation).find((item) => item.key === key) ?? null);
-}
-export function upsertConversationEnvironmentVariable(conversation, key, value, description = "") {
-    const existing = revealConversationEnvironmentVariable(conversation, key);
-    const normalizedValue = value.length > 0 ? value : existing?.value ?? "";
-    const valueSetting = upsertWorkspaceSetting(conversation, `${WORKSPACE_ENVIRONMENT_VALUE_PREFIX}${key}`, normalizedValue);
-    upsertWorkspaceSetting(conversation, `${WORKSPACE_ENVIRONMENT_DESCRIPTION_PREFIX}${key}`, description);
-    return {
-        key,
-        value: normalizedValue,
-        description,
-        createdAt: existing?.createdAt ?? valueSetting.updatedAt,
-        updatedAt: valueSetting.updatedAt,
-    };
-}
-export function deleteConversationEnvironmentVariable(conversation, key) {
-    const db = getWorkspaceDatabase(conversation.workspacePath);
-    const valueResult = db
-        .prepare("delete from workspace_settings where key = ?")
-        .run(`${WORKSPACE_ENVIRONMENT_VALUE_PREFIX}${key}`);
-    db.prepare("delete from workspace_settings where key = ?").run(`${WORKSPACE_ENVIRONMENT_DESCRIPTION_PREFIX}${key}`);
-    touch(conversation);
-    return valueResult.changes > 0;
-}
-export function revealGlobalEnvironmentVariable(key) {
-    return getGlobalEnvironmentVariable(key);
-}
-export function upsertGlobalEnvironmentVariable(key, value, description = "") {
-    const existing = getGlobalEnvironmentVariable(key);
-    const now = new Date().toISOString();
-    const variable = {
-        key,
-        value: value.length > 0 ? value : existing?.value ?? "",
-        description,
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now,
-    };
-    getCenterDatabase()
-        .prepare(`
-      insert into global_environment_variables (key, value, description, created_at, updated_at)
-      values (?, ?, ?, ?, ?)
-      on conflict(key) do update set
-        value = excluded.value,
-        description = excluded.description,
-        updated_at = excluded.updated_at
-    `)
-        .run(variable.key, variable.value, variable.description, variable.createdAt, variable.updatedAt);
-    return variable;
-}
-export function deleteGlobalEnvironmentVariable(key) {
-    const result = getCenterDatabase()
-        .prepare("delete from global_environment_variables where key = ?")
-        .run(key);
-    return result.changes > 0;
-}
-export function getAppSetting(key) {
-    const row = getCenterDatabase()
-        .prepare("select * from app_settings where key = ?")
-        .get(key);
-    return row ? appSettingFromRow(row) : null;
-}
-export function getAppSettingValue(key) {
-    return getAppSetting(key)?.value ?? null;
-}
-export function upsertAppSetting(key, value) {
-    const now = new Date().toISOString();
-    getCenterDatabase()
-        .prepare(`
-      insert into app_settings (key, value, updated_at)
-      values (?, ?, ?)
-      on conflict(key) do update set
-        value = excluded.value,
-        updated_at = excluded.updated_at
-    `)
-        .run(key, value, now);
-    return {
-        key,
-        value,
-        updatedAt: now,
-    };
-}
-export function setConversationMemory(conversation, memory) {
-    const value = memory.trim();
-    return setConversationMemoryItems(conversation, value
-        ? [
-            {
-                key: "default",
-                value,
-                updatedAt: new Date().toISOString(),
-            },
-        ]
-        : []);
-}
-export function setConversationMemoryItems(conversation, items) {
-    const normalized = normalizeMemoryItems(items);
-    conversation.memoryItems = normalized;
-    conversation.memory = formatMemoryItems(normalized);
-    upsertWorkspaceSetting(conversation, WORKSPACE_MEMORY_ITEMS_SETTING_KEY, JSON.stringify(normalized));
-    touch(conversation);
-    return conversation;
-}
-export function setConversationResponsibility(conversation, responsibility) {
-    const normalized = responsibility.trim();
-    conversation.responsibility = normalized;
-    upsertWorkspaceSetting(conversation, WORKSPACE_RESPONSIBILITY_SETTING_KEY, normalized);
-    touch(conversation);
-    return conversation;
-}
-export function setConversationWorkspaceSetting(conversation, key, value) {
-    const normalizedKey = key.trim();
-    if (!normalizedKey) {
-        throw new Error("workspace setting key is required");
-    }
-    return upsertWorkspaceSetting(conversation, normalizedKey, value);
-}
-export function deleteConversationWorkspaceSetting(conversation, key) {
-    const normalizedKey = key.trim();
-    if (!normalizedKey) {
-        return;
-    }
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare("delete from workspace_settings where key = ?")
-        .run(normalizedKey);
-    touch(conversation);
-}
-export function getConversationWorkspaceSettings(conversation) {
-    return readWorkspaceSettings(conversation.workspacePath);
-}
-export function listConversations() {
-    return [...conversations.values()]
-        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-        .map(toSummary);
-}
-export function countConversationUnreadTurns(conversation, userId) {
-    const baseline = getCenterDatabase()
-        .prepare(`
-      select terminal_turn_rowid
-      from workspace_unread_baselines
-      where workspace_id = ?
-    `)
-        .get(conversation.id);
-    const readState = getCenterDatabase()
-        .prepare(`
-      select last_read_turn_rowid
-      from workspace_read_states
-      where user_id = ? and workspace_id = ?
-    `)
-        .get(userId, conversation.id);
-    const cursor = Math.max(baseline?.terminal_turn_rowid ?? 0, readState?.last_read_turn_rowid ?? 0);
-    const row = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select count(*) as count
-      from turns
-      where rowid > ? and status in ('completed', 'failed')
-    `)
-        .get(cursor);
-    return row?.count ?? 0;
-}
-export function markConversationRead(conversation, userId) {
-    const lastReadTurnRowid = latestTerminalTurnRowid(conversation);
-    getCenterDatabase()
-        .prepare(`
-      insert into workspace_read_states (
-        user_id, workspace_id, last_read_turn_rowid, updated_at
-      ) values (?, ?, ?, ?)
-      on conflict(user_id, workspace_id) do update set
-        last_read_turn_rowid = excluded.last_read_turn_rowid,
-        updated_at = excluded.updated_at
-    `)
-        .run(userId, conversation.id, lastReadTurnRowid, new Date().toISOString());
-}
-export function getConversationStoreDiagnostics() {
-    return {
-        centerSchemaVersion: centerDatabase
-            ? readSchemaVersion(centerDatabase)
-            : null,
-        expectedCenterSchemaVersion: CENTER_SCHEMA_VERSION,
-        expectedWorkspaceSchemaVersion: WORKSPACE_SCHEMA_VERSION,
-        workspaceRoot: workspaceRootPath,
-        workspaces: conversations.size,
-        groups: workspaceGroups.size,
-        globalEnvironmentVariables: countRows(getCenterDatabase(), "global_environment_variables"),
-        appSettings: countRows(getCenterDatabase(), "app_settings"),
-        wakeups: countWakeupsByStatus(),
-        activeConversations: [...conversations.values()].filter((conversation) => conversation.status === "running").length,
-        workspaceDatabases: [...conversations.values()]
-            .sort((left, right) => left.id.localeCompare(right.id))
-            .map((conversation) => {
-            const db = getWorkspaceDatabase(conversation.workspacePath);
-            return {
-                id: conversation.id,
-                title: conversation.title,
-                workspacePath: conversation.workspacePath,
-                schemaVersion: readSchemaVersion(db),
-                messages: countRows(db, "messages"),
-                events: countRows(db, "events"),
-                turns: countRows(db, "turns"),
-                status: conversation.status,
-            };
-        }),
-    };
-}
-export function createWorkspaceWakeup(input) {
-    if (!conversations.has(input.workspaceId)) {
-        throw new Error(`workspace not found: ${input.workspaceId}`);
-    }
-    const now = new Date().toISOString();
-    const wakeup = {
-        id: randomUUID(),
-        workspaceId: input.workspaceId,
-        status: "scheduled",
-        wakeAt: input.wakeAt,
-        instruction: input.instruction,
-        createdBy: input.createdBy ?? "user",
-        createdTurnId: input.createdTurnId ?? null,
-        resultTurnId: null,
-        error: null,
-        attemptCount: 0,
-        maxAttempts: clampWakeupMaxAttempts(input.maxAttempts),
-        createdAt: now,
-        updatedAt: now,
-    };
-    upsertWorkspaceWakeup(wakeup);
-    return wakeup;
-}
-export function listDueWorkspaceWakeups(now) {
-    const rows = getCenterDatabase()
-        .prepare(`
-      select * from workspace_wakeups
-      where status = 'scheduled'
-        and wake_at <= ?
-      order by wake_at asc, created_at asc
-    `)
-        .all(now);
-    return rows.map(wakeupFromRow);
-}
-export function listWorkspaceWakeups(workspaceId, options = {}) {
-    const rows = getCenterDatabase()
-        .prepare(`
-      select * from workspace_wakeups
-      where workspace_id = ?
-      order by wake_at desc, created_at desc
-      limit ?
-    `)
-        .all(workspaceId, Math.max(1, Math.min(100, options.limit ?? 20)));
-    return rows.map(wakeupFromRow);
-}
-export function getNextScheduledWorkspaceWakeup(workspaceId) {
-    const row = getCenterDatabase()
-        .prepare(`
-      select * from workspace_wakeups
-      where workspace_id = ?
-        and status = 'scheduled'
-      order by wake_at asc, created_at asc
-      limit 1
-    `)
-        .get(workspaceId);
-    return row ? wakeupFromRow(row) : null;
-}
-export function updateWorkspaceWakeup(id, input) {
-    const existing = getWorkspaceWakeup(id);
-    if (!existing) {
-        return null;
-    }
-    const wakeup = {
-        ...existing,
-        status: input.status ?? existing.status,
-        resultTurnId: Object.prototype.hasOwnProperty.call(input, "resultTurnId")
-            ? input.resultTurnId ?? null
-            : existing.resultTurnId,
-        error: Object.prototype.hasOwnProperty.call(input, "error")
-            ? input.error ?? null
-            : existing.error,
-        attemptCount: typeof input.attemptCount === "number"
-            ? Math.max(0, Math.floor(input.attemptCount))
-            : existing.attemptCount,
-        maxAttempts: typeof input.maxAttempts === "number"
-            ? clampWakeupMaxAttempts(input.maxAttempts)
-            : existing.maxAttempts,
-        updatedAt: new Date().toISOString(),
-    };
-    upsertWorkspaceWakeup(wakeup);
-    return wakeup;
-}
-export function cancelWorkspaceWakeup(id, options = {}) {
-    const existing = getWorkspaceWakeup(id);
-    if (!existing ||
-        existing.status !== "scheduled" ||
-        (options.workspaceId && existing.workspaceId !== options.workspaceId)) {
-        return null;
-    }
-    return updateWorkspaceWakeup(id, {
-        status: "cancelled",
-        error: options.reason ?? "cancelled_by_user",
-    });
-}
-export function recoverInterruptedWakeupsOnStartup() {
-    const now = new Date().toISOString();
-    const rows = getCenterDatabase()
-        .prepare(`
-      select * from workspace_wakeups
-      where status = 'running'
-      order by updated_at asc
-    `)
-        .all();
-    if (rows.length === 0) {
-        return {
-            recoveredWakeupCount: 0,
-            recoveredWorkspaceIds: [],
-        };
-    }
-    runInTransaction(getCenterDatabase(), () => {
-        for (const row of rows) {
-            getCenterDatabase()
-                .prepare(`
-          update workspace_wakeups
-          set status = 'failed',
-            error = ?,
-            updated_at = ?
-          where id = ?
-        `)
-                .run("interrupted_by_server_restart", now, row.id);
-        }
-    });
-    for (const row of rows) {
-        const conversation = conversations.get(row.workspace_id);
-        if (!conversation) {
-            continue;
-        }
-        appendEvent(conversation, "server.wakeup.recovered_interrupted", {
-            wakeupId: row.id,
-            previousStatus: row.status,
-            reason: "server_restart",
-        }, { turnId: row.result_turn_id, createdAt: now });
-    }
-    return {
-        recoveredWakeupCount: rows.length,
-        recoveredWorkspaceIds: [...new Set(rows.map((row) => row.workspace_id))].sort(),
-    };
-}
-export function getConversation(id) {
-    return conversations.get(id) ?? null;
-}
-export function recoverInterruptedTurnsOnStartup() {
-    const now = new Date().toISOString();
-    const recoveredWorkspaceIds = [];
-    let recoveredTurnCount = 0;
-    for (const conversation of conversations.values()) {
-        const db = getWorkspaceDatabase(conversation.workspacePath);
-        const rows = db
-            .prepare(`
-        select * from turns
-        where status in ('queued', 'running', 'waiting_approval')
-        order by started_at asc
-      `)
-            .all();
-        if (rows.length === 0) {
-            continue;
-        }
-        runInTransaction(db, () => {
-            for (const row of rows) {
-                db.prepare(`
-          update turns
-          set status = 'failed',
-            finished_at = ?,
-            error = ?,
-            updated_at = ?
-          where id = ?
-        `).run(now, "interrupted_by_server_restart", now, row.id);
-                db.prepare(`
-          insert into events (id, turn_id, event, data_json, created_at)
-          values (?, ?, ?, ?, ?)
-        `).run(randomUUID(), row.id, "server.recovered_interrupted_turn", JSON.stringify({
-                    previousStatus: row.status,
-                    reason: "server_restart",
-                }), now);
-            }
-        });
-        conversation.status = "error";
-        conversation.updatedAt = now;
-        upsertConversationMetadata(conversation);
-        recoveredTurnCount += rows.length;
-        recoveredWorkspaceIds.push(conversation.id);
-    }
-    return {
-        recoveredTurnCount,
-        recoveredWorkspaceIds: recoveredWorkspaceIds.sort(),
-    };
-}
-export function getConversationHistoryPage(conversation, options = {}) {
-    const limit = clampPageLimit(options.limit ?? 12);
-    const turns = listTurnsFromDatabase(conversation, options.before, Math.max(1, Math.ceil(limit / 2)));
-    const messages = listMessagesForTurns(conversation, turns);
-    const oldestMessageCreatedAt = messages[0]?.createdAt ?? turns[0]?.startedAt ?? null;
-    const events = listEventsForTurns(conversation, turns.map((turn) => turn.id));
-    const hasMoreBefore = turns[0]?.startedAt === undefined
-        ? false
-        : hasTurnsBefore(conversation, turns[0].startedAt);
-    return {
-        messages,
-        events,
-        history: {
-            hasMoreBefore,
-            oldestMessageCreatedAt,
-            messageTotal: messages.length,
-            eventTotal: events.length,
-            loadedMessageCount: messages.length,
-            loadedEventCount: events.length,
-        },
-    };
-}
-export function getLatestConversationNotification(conversation, method) {
-    const row = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from events
-      where event = 'codex.notification'
-        and json_extract(data_json, '$.method') = ?
-      order by created_at desc, id desc
-      limit 1
-    `)
-        .get(method);
-    return row ? eventFromRow(row) : null;
-}
-export function listConversationTranscriptMessages(conversation, limit = 500) {
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from messages
-      order by created_at desc, id desc
-      limit ?
-    `)
-        .all(Math.max(1, Math.min(5_000, Math.trunc(limit))));
-    return rows
-        .reverse()
-        .map(messageFromRow);
-}
-export function listAllConversationVisibleMessages(conversation) {
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from messages
-      order by created_at asc, id asc
-    `)
-        .all();
-    return rows.map(messageFromRow);
-}
-export function listConversationTranscriptMessagesBefore(conversation, beforeMessageId, limit = 100) {
-    const db = getWorkspaceDatabase(conversation.workspacePath);
-    const normalizedLimit = Math.max(1, Math.min(500, Math.trunc(limit)));
-    const before = beforeMessageId
-        ? db
-            .prepare("select created_at from messages where id = ?")
-            .get(beforeMessageId)
-        : null;
-    const rows = before?.created_at
-        ? db
-            .prepare(`
-          select * from messages
-          where created_at < ?
-          order by created_at desc, id desc
-          limit ?
-        `)
-            .all(before.created_at, normalizedLimit)
-        : db
-            .prepare(`
-          select * from messages
-          order by created_at desc, id desc
-          limit ?
-        `)
-            .all(normalizedLimit);
-    return rows.reverse().map(messageFromRow);
-}
-export function listConversationTranscriptMessageRange(conversation, startMessageId, endMessageId, limit = 500) {
-    const db = getWorkspaceDatabase(conversation.workspacePath);
-    const start = db
-        .prepare("select created_at from messages where id = ?")
-        .get(startMessageId);
-    const end = db
-        .prepare("select created_at from messages where id = ?")
-        .get(endMessageId);
-    if (!start?.created_at || !end?.created_at) {
-        return [];
-    }
-    const from = start.created_at <= end.created_at ? start.created_at : end.created_at;
-    const to = start.created_at <= end.created_at ? end.created_at : start.created_at;
-    const rows = db
-        .prepare(`
-      select * from messages
-      where created_at >= ? and created_at <= ?
-      order by created_at asc, id asc
-      limit ?
-    `)
-        .all(from, to, Math.max(1, Math.min(2_000, Math.trunc(limit))));
-    return rows.map(messageFromRow);
-}
-export function recordRuntimeReset(conversation, input) {
-    const completedAt = input.completedAt ?? new Date().toISOString();
-    const record = {
-        id: randomUUID(),
-        oldCodexThreadId: input.oldCodexThreadId,
-        newCodexThreadId: input.newCodexThreadId,
-        mode: input.mode ?? "lossless-visible-history",
-        status: input.status,
-        injectedMessageCount: input.injectedMessageCount,
-        injectedUserMessageCount: input.injectedUserMessageCount,
-        injectedAssistantMessageCount: input.injectedAssistantMessageCount,
-        injectedMessages: input.injectedMessages ?? [],
-        error: input.error ?? null,
-        createdAt: input.createdAt ?? completedAt,
-        completedAt,
-    };
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert into runtime_resets (
-        id,
-        old_codex_thread_id,
-        new_codex_thread_id,
-        mode,
-        status,
-        injected_message_count,
-        injected_user_message_count,
-        injected_assistant_message_count,
-        injected_messages_json,
-        error,
-        created_at,
-        completed_at
-      )
-      values (
-        @id,
-        @oldCodexThreadId,
-        @newCodexThreadId,
-        @mode,
-        @status,
-        @injectedMessageCount,
-        @injectedUserMessageCount,
-        @injectedAssistantMessageCount,
-        @injectedMessagesJson,
-        @error,
-        @createdAt,
-        @completedAt
-      )
-    `)
-        .run({
-        ...record,
-        injectedMessagesJson: JSON.stringify(record.injectedMessages),
-    });
-    return record;
-}
-export function listRuntimeResets(conversation, limit = 10) {
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from runtime_resets
-      order by created_at desc, id desc
-      limit ?
-    `)
-        .all(Math.max(1, Math.min(50, Math.trunc(limit))));
-    return rows.map(runtimeResetFromRow);
-}
-export function upsertTranscriptRangeSummary(conversation, input) {
-    const now = new Date().toISOString();
-    const id = `summary-${input.startMessageId}-${input.endMessageId}`;
-    const summary = {
-        id,
-        startMessageId: input.startMessageId,
-        endMessageId: input.endMessageId,
-        title: input.title,
-        summary: input.summary,
-        createdAt: now,
-        updatedAt: now,
-    };
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert into transcript_range_summaries (
-        id,
-        start_message_id,
-        end_message_id,
-        title,
-        summary,
-        created_at,
-        updated_at
-      )
-      values (@id, @startMessageId, @endMessageId, @title, @summary, @createdAt, @updatedAt)
-      on conflict(id) do update set
-        title = excluded.title,
-        summary = excluded.summary,
-        updated_at = excluded.updated_at
-    `)
-        .run(summary);
-    return summary;
-}
-export function listTranscriptRangeSummaries(conversation) {
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from transcript_range_summaries
-      order by created_at asc, id asc
-    `)
-        .all();
-    return rows.map(transcriptRangeSummaryFromRow);
-}
-export function getConversationRevision(conversation) {
-    return {
-        id: conversation.id,
-        status: conversation.status,
-        updatedAt: conversation.updatedAt,
-        messageTotal: countWorkspaceRows(conversation.workspacePath, "messages"),
-        eventTotal: countWorkspaceRows(conversation.workspacePath, "events"),
-        nextWakeup: getNextScheduledWorkspaceWakeup(conversation.id),
-    };
-}
-export function listConversationTurnEvents(conversation, turnId) {
-    return listEventsForTurns(conversation, [turnId], {
-        compact: false,
-    });
-}
-export function listConversationEventsByType(conversation, eventTypes, limit = 100) {
-    if (eventTypes.length === 0) {
-        return [];
-    }
-    const placeholders = eventTypes.map(() => "?").join(", ");
-    const normalizedLimit = Math.max(1, Math.min(500, Math.floor(limit)));
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from events
-      where event in (${placeholders})
-      order by created_at desc, id desc
-      limit ?
-    `)
-        .all(...eventTypes, normalizedLimit);
-    return rows.map(eventFromRow);
-}
-export function getConversationTurn(conversation, turnId) {
-    return getTurn(conversation, turnId);
-}
-export function deleteConversation(id) {
-    const conversation = conversations.get(id);
-    if (!conversation) {
-        return null;
-    }
-    ensureWorkspacePathIsManaged(conversation.workspacePath);
-    moveWorkspaceToRecycle(conversation);
-    conversations.delete(id);
-    getCenterDatabase().prepare("delete from workspaces where id = ?").run(id);
-    getCenterDatabase()
-        .prepare("delete from workspace_read_states where workspace_id = ?")
-        .run(id);
-    getCenterDatabase()
-        .prepare("delete from workspace_unread_baselines where workspace_id = ?")
-        .run(id);
-    const workspaceDb = workspaceDatabases.get(conversation.workspacePath);
-    if (workspaceDb) {
-        workspaceDb.close();
-        workspaceDatabases.delete(conversation.workspacePath);
-    }
-    return conversation;
-}
-export function createConversation(input) {
-    const now = new Date().toISOString();
-    const id = createWorkspaceId();
-    const workspacePath = path.join(input.workspaceRoot, id);
-    mkdirSync(workspacePath, { recursive: true });
-    const contextVersion = {
-        id: randomUUID(),
-        codexThreadId: null,
-        source: "initial",
-        summary: null,
-        createdAt: now,
-    };
-    const conversation = {
-        id,
-        ownerId: input.ownerId,
-        title: input.title ?? "New workspace",
-        groupId: normalizeWorkspaceGroupId(input.groupId),
-        memory: "",
-        memoryItems: [],
-        responsibility: "",
-        codexThreadId: null,
-        workspaceKind: "directory",
-        workspacePath,
-        sandbox: input.sandbox,
-        contextVersions: [contextVersion],
-        status: "idle",
-        messages: [],
-        events: [],
-        createdAt: now,
-        updatedAt: now,
-    };
-    conversations.set(conversation.id, conversation);
-    initializeWorkspaceDatabase(workspacePath);
-    upsertConversationMetadata(conversation);
-    getCenterDatabase()
-        .prepare(`
-      insert into workspace_unread_baselines (
-        workspace_id, terminal_turn_rowid
-      ) values (?, 0)
-    `)
-        .run(conversation.id);
-    upsertContextVersion(conversation, contextVersion);
-    return conversation;
-}
-function createWorkspaceId() {
-    for (let attempts = 0; attempts < 8; attempts += 1) {
-        const id = randomInt(36 ** 6).toString(36).padStart(6, "0");
-        if (!conversations.has(id)) {
-            return id;
-        }
-    }
-    return randomUUID();
-}
-export function appendMessage(conversation, role, content, turnId = null) {
-    const createdAt = new Date().toISOString();
-    const message = {
-        id: createMessageId(createdAt),
-        role,
-        content,
-        createdAt,
-        turnId,
-    };
-    conversation.messages.push(message);
-    insertMessage(conversation, message);
-    touch(conversation);
-    return message;
-}
-export function createConversationTurn(conversation, input) {
-    const now = new Date().toISOString();
-    const turn = {
-        id: input.id,
-        userMessageId: input.userMessageId ?? null,
-        codexTurnId: null,
-        status: input.status ?? "queued",
-        startedAt: now,
-        finishedAt: null,
-        error: null,
-        createdAt: now,
-        updatedAt: now,
-    };
-    upsertTurn(conversation, turn);
-    return turn;
-}
-export function updateConversationTurn(conversation, turnId, input) {
-    const existing = getTurn(conversation, turnId);
-    const now = new Date().toISOString();
-    const turn = {
-        id: turnId,
-        userMessageId: existing?.userMessageId ?? null,
-        codexTurnId: Object.prototype.hasOwnProperty.call(input, "codexTurnId")
-            ? input.codexTurnId ?? null
-            : existing?.codexTurnId ?? null,
-        status: input.status ?? existing?.status ?? "running",
-        startedAt: existing?.startedAt ?? now,
-        finishedAt: Object.prototype.hasOwnProperty.call(input, "finishedAt")
-            ? input.finishedAt ?? null
-            : existing?.finishedAt ?? null,
-        error: Object.prototype.hasOwnProperty.call(input, "error")
-            ? input.error ?? null
-            : existing?.error ?? null,
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now,
-    };
-    upsertTurn(conversation, turn);
-}
-export function appendEvent(conversation, event, data, options = {}) {
-    const record = {
-        id: randomUUID(),
-        turnId: options.turnId ?? null,
-        event,
-        data,
-        createdAt: options.createdAt ?? new Date().toISOString(),
-    };
-    conversation.events.push(record);
-    trimInMemoryEvents(conversation);
-    insertEvent(conversation, record, options.turnId ?? null);
-    touch(conversation, { persistMetadata: false });
-    return record;
-}
-export function setConversationStatus(conversation, status) {
-    conversation.status = status;
-    touch(conversation);
-}
-export function setConversationTitle(conversation, title) {
-    conversation.title = title;
-    touch(conversation);
-}
-export function setConversationSandbox(conversation, sandbox) {
-    conversation.sandbox = sandbox;
-    touch(conversation);
-}
-export function setConversationGroup(conversation, groupId) {
-    conversation.groupId = normalizeWorkspaceGroupId(groupId);
-    touch(conversation);
-}
-export function setConversationThread(conversation, codexThreadId) {
-    conversation.codexThreadId = codexThreadId;
-    touch(conversation);
-}
-export function appendConversationContextVersion(conversation, input) {
-    const contextVersion = {
-        id: randomUUID(),
-        codexThreadId: input.codexThreadId,
-        source: input.source,
-        summary: input.summary,
-        createdAt: new Date().toISOString(),
-    };
-    conversation.contextVersions.push(contextVersion);
-    upsertContextVersion(conversation, contextVersion);
-    return contextVersion;
-}
-function clampPageLimit(value) {
-    if (!Number.isFinite(value)) {
-        return 12;
-    }
-    return Math.max(1, Math.min(40, Math.floor(value)));
-}
-function toSummary(conversation) {
-    return {
-        id: conversation.id,
-        ownerId: conversation.ownerId,
-        title: conversation.title,
-        groupId: conversation.groupId,
-        memory: conversation.memory,
-        memoryItems: conversation.memoryItems,
-        responsibility: conversation.responsibility,
-        status: conversation.status,
-        codexThreadId: conversation.codexThreadId,
-        workspaceKind: conversation.workspaceKind,
-        workspacePath: conversation.workspacePath,
-        sandbox: conversation.sandbox,
-        contextVersionCount: conversation.contextVersions.length,
-        nextWakeup: getNextScheduledWorkspaceWakeup(conversation.id),
-        createdAt: conversation.createdAt,
-        updatedAt: conversation.updatedAt,
-    };
-}
-export function isConversationSandbox(value) {
-    return (value === "read-only" ||
-        value === "workspace-write" ||
-        value === "danger-full-access");
-}
-function normalizeSandbox(value, fallback) {
-    return isConversationSandbox(value) ? value : fallback;
-}
-function normalizeWorkspaceGroupId(value) {
-    return typeof value === "string" && workspaceGroups.has(value)
-        ? value
-        : DEFAULT_WORKSPACE_GROUP_ID;
-}
-function createWorkspaceGroupId(title) {
-    const base = title
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 24) || "group";
-    let id = base === DEFAULT_WORKSPACE_GROUP_ID ? `${base}-2` : base;
-    let suffix = 2;
-    while (workspaceGroups.has(id)) {
-        id = `${base}-${suffix}`;
-        suffix += 1;
-    }
-    return id;
-}
-function touch(conversation, options = {}) {
-    conversation.updatedAt = new Date().toISOString();
-    if (options.persistMetadata !== false) {
-        updateConversationMetadata(conversation);
-    }
-}
-function openCenterDatabase(databasePath) {
-    mkdirSync(path.dirname(databasePath), { recursive: true });
-    const db = openSqliteDatabase(databasePath);
-    db.exec("pragma journal_mode = WAL; pragma foreign_keys = ON");
-    return db;
-}
-function getCenterDatabase() {
-    if (!centerDatabase) {
-        throw new Error("conversation store is not initialized");
-    }
-    return centerDatabase;
-}
-function initializeCenterSchema(db) {
-    db.exec(`
-    create table if not exists schema_migrations (
-      id integer primary key check (id = 1),
-      version integer not null,
-      updated_at text not null
-    );
-
-    create table if not exists workspace_groups (
-      id text primary key,
-      owner_id text,
-      title text not null,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists global_environment_variables (
-      key text primary key,
-      value text not null,
-      description text not null default '',
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists app_settings (
-      key text primary key,
-      value text not null,
-      updated_at text not null
-    );
-
-    create table if not exists workspaces (
-      id text primary key,
-      owner_id text,
-      title text not null,
-      group_id text not null,
-      codex_thread_id text,
-      workspace_kind text not null,
-      workspace_path text not null unique,
-      sandbox text not null,
-      status text not null,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create index if not exists idx_workspaces_group_updated
-      on workspaces(group_id, updated_at);
-
-    create table if not exists workspace_wakeups (
-      id text primary key,
-      workspace_id text not null,
-      status text not null,
-      wake_at text not null,
-      instruction text not null,
-      created_by text not null,
-      created_turn_id text,
-      result_turn_id text,
-      error text,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists workspace_unread_baselines (
-      workspace_id text primary key,
-      terminal_turn_rowid integer not null
-    );
-
-    create table if not exists workspace_read_states (
-      user_id text not null,
-      workspace_id text not null,
-      last_read_turn_rowid integer not null,
-      updated_at text not null,
-      primary key (user_id, workspace_id)
-    );
-
-    create index if not exists idx_workspace_read_states_workspace
-      on workspace_read_states(workspace_id);
-
-    create index if not exists idx_workspace_wakeups_status_wake_at
-      on workspace_wakeups(status, wake_at);
-    create index if not exists idx_workspace_wakeups_workspace_wake_at
-      on workspace_wakeups(workspace_id, wake_at);
-  `);
-    migrateCenterWorkspaceRuntimeSchema(db);
-    ensureColumn(db, "global_environment_variables", "description", "text not null default ''");
-    ensureColumn(db, "workspace_wakeups", "attempt_count", "integer not null default 0");
-    ensureColumn(db, "workspace_wakeups", "max_attempts", "integer not null default 3");
-    ensureColumn(db, "workspace_groups", "owner_id", "text");
-    ensureColumn(db, "workspaces", "owner_id", "text");
-    if (!defaultOwnerId) {
-        throw new Error("default workspace owner is not initialized");
-    }
-    db.prepare("update workspaces set owner_id = ? where owner_id is null or owner_id = ''")
-        .run(defaultOwnerId);
-    db.prepare("update workspaces set owner_id = ? where owner_id = 'local-admin'")
-        .run(defaultOwnerId);
-    db.prepare("update workspace_groups set owner_id = ? where id <> ? and owner_id is null")
-        .run(defaultOwnerId, DEFAULT_WORKSPACE_GROUP_ID);
-    db.prepare("update workspace_groups set owner_id = ? where owner_id = 'local-admin'")
-        .run(defaultOwnerId);
-    setSchemaVersion(db, CENTER_SCHEMA_VERSION);
-}
-function initializeWorkspaceSchema(db) {
-    db.exec(`
-    create table if not exists schema_migrations (
-      id integer primary key check (id = 1),
-      version integer not null,
-      updated_at text not null
-    );
-
-    create table if not exists context_versions (
-      id text primary key,
-      codex_thread_id text,
-      source text not null,
-      summary text,
-      created_at text not null
-    );
-
-    create table if not exists messages (
-      id text primary key,
-      role text not null,
-      content text not null,
-      turn_id text,
-      created_at text not null
-    );
-
-    create table if not exists events (
-      id text primary key,
-      turn_id text,
-      event text not null,
-      data_json text not null,
-      created_at text not null
-    );
-
-    create table if not exists turns (
-      id text primary key,
-      user_message_id text,
-      codex_turn_id text,
-      status text not null,
-      started_at text not null,
-      finished_at text,
-      error text,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists workspace_settings (
-      key text primary key,
-      value text not null,
-      updated_at text not null
-    );
-
-    create table if not exists workspace_knowledge (
-      id text primary key,
-      data_json text not null,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists transcript_range_summaries (
-      id text primary key,
-      start_message_id text not null,
-      end_message_id text not null,
-      title text not null,
-      summary text not null,
-      created_at text not null,
-      updated_at text not null
-    );
-
-    create table if not exists runtime_resets (
-      id text primary key,
-      old_codex_thread_id text,
-      new_codex_thread_id text,
-      mode text not null,
-      status text not null,
-      injected_message_count integer not null,
-      injected_user_message_count integer not null,
-      injected_assistant_message_count integer not null,
-      injected_messages_json text not null default '[]',
-      error text,
-      created_at text not null,
-      completed_at text not null
-    );
-
-    create index if not exists idx_messages_created_at on messages(created_at);
-    create index if not exists idx_events_created_at on events(created_at);
-    create index if not exists idx_turns_user_message on turns(user_message_id);
-    create index if not exists idx_turns_status_updated_at on turns(status, updated_at);
-    create index if not exists idx_workspace_knowledge_updated_at
-      on workspace_knowledge(updated_at);
-    create index if not exists idx_transcript_range_summaries_start
-      on transcript_range_summaries(start_message_id);
-    create index if not exists idx_transcript_range_summaries_updated_at
-      on transcript_range_summaries(updated_at);
-    create index if not exists idx_runtime_resets_created_at
-      on runtime_resets(created_at);
-  `);
-    ensureColumn(db, "messages", "turn_id", "text");
-    ensureColumn(db, "events", "turn_id", "text");
-    ensureColumn(db, "runtime_resets", "injected_messages_json", "text not null default '[]'");
-    db.exec(`
-    create index if not exists idx_messages_turn_created_at on messages(turn_id, created_at);
-    create index if not exists idx_events_turn_created_at on events(turn_id, created_at);
-    create index if not exists idx_transcript_range_summaries_start
-      on transcript_range_summaries(start_message_id);
-    create index if not exists idx_transcript_range_summaries_updated_at
-      on transcript_range_summaries(updated_at);
-    create index if not exists idx_runtime_resets_created_at
-      on runtime_resets(created_at);
-  `);
-    setSchemaVersion(db, WORKSPACE_SCHEMA_VERSION);
-}
-export function getConversationWorkspaceDatabase(conversation) {
-    return getWorkspaceDatabase(conversation.workspacePath);
-}
-function setSchemaVersion(db, version) {
-    db.prepare(`
-    insert into schema_migrations (id, version, updated_at)
-    values (1, ?, ?)
-    on conflict(id) do update set
-      version = excluded.version,
-      updated_at = excluded.updated_at
-  `).run(version, new Date().toISOString());
-}
-function readSchemaVersion(db) {
-    const table = db
-        .prepare("select name from sqlite_master where type = ? and name = ?")
-        .get("table", "schema_migrations");
-    if (!table) {
-        return null;
-    }
-    const row = db
-        .prepare("select version from schema_migrations where id = 1")
-        .get();
-    return typeof row?.version === "number" ? row.version : null;
-}
-function ensureColumn(db, table, column, definition) {
-    const columns = db.prepare(`pragma table_info(${table})`).all();
-    if (columns.some((entry) => entry.name === column)) {
-        return;
-    }
-    db.prepare(`alter table ${table} add column ${column} ${definition}`).run();
-}
-function tableHasColumn(db, table, column) {
-    const columns = db.prepare(`pragma table_info(${table})`).all();
-    return columns.some((entry) => entry.name === column);
-}
-function migrateCenterWorkspaceRuntimeSchema(db) {
-    if (!tableHasColumn(db, "workspaces", "current_context_version_id")) {
-        return;
-    }
-    runInTransaction(db, () => {
-        db.exec(`
-      drop index if exists idx_workspaces_group_updated;
-
-      create table workspaces_next (
-        id text primary key,
-        title text not null,
-        group_id text not null,
-        codex_thread_id text,
-        workspace_kind text not null,
-        workspace_path text not null unique,
-        sandbox text not null,
-        status text not null,
-        created_at text not null,
-        updated_at text not null
-      );
-
-      insert into workspaces_next (
-        id,
-        title,
-        group_id,
-        codex_thread_id,
-        workspace_kind,
-        workspace_path,
-        sandbox,
-        status,
-        created_at,
-        updated_at
-      )
-      select
-        id,
-        title,
-        group_id,
-        codex_thread_id,
-        workspace_kind,
-        workspace_path,
-        sandbox,
-        status,
-        created_at,
-        updated_at
-      from workspaces;
-
-      drop table workspaces;
-      alter table workspaces_next rename to workspaces;
-
-      create index if not exists idx_workspaces_group_updated
-        on workspaces(group_id, updated_at);
-    `);
-    });
-}
-function upsertWorkspaceSetting(conversation, key, value) {
-    return upsertWorkspaceSettingByPath(conversation.workspacePath, key, value);
-}
-function upsertWorkspaceSettingByPath(workspacePath, key, value) {
-    const now = new Date().toISOString();
-    getWorkspaceDatabase(workspacePath)
-        .prepare(`
-      insert into workspace_settings (key, value, updated_at)
-      values (?, ?, ?)
-      on conflict(key) do update set
-        value = excluded.value,
-        updated_at = excluded.updated_at
-    `)
-        .run(key, value, now);
-    return { key, value, updatedAt: now };
-}
-function migrateMessageIds(db) {
-    const rows = db
-        .prepare(`
-      select id, role, content, created_at
-      from messages
-      order by created_at asc, id asc
-    `)
-        .all();
-    if (rows.length === 0) {
-        return;
-    }
-    const usedIds = new Set(rows.map((row) => row.id));
-    const replacements = new Map();
-    for (let index = 0; index < rows.length; index += 1) {
-        const row = rows[index];
-        if (isCanonicalMessageId(row.id)) {
-            continue;
-        }
-        usedIds.delete(row.id);
-        let nextId = createStableMessageId(row.created_at, `${row.id}:${index}:${row.role}:${row.content}`);
-        for (let attempt = 1; usedIds.has(nextId); attempt += 1) {
-            nextId = createStableMessageId(row.created_at, `${row.id}:${index}:${row.role}:${row.content}:${attempt}`);
-        }
-        usedIds.add(nextId);
-        replacements.set(row.id, nextId);
-    }
-    if (replacements.size === 0) {
-        return;
-    }
-    const updateMessage = db.prepare("update messages set id = ? where id = ?");
-    const updateTurn = db.prepare(`
-    update turns
-    set user_message_id = ?
-    where user_message_id = ?
-  `);
-    const updateSummaryStart = db.prepare(`
-    update transcript_range_summaries
-    set start_message_id = ?
-    where start_message_id = ?
-  `);
-    const updateSummaryEnd = db.prepare(`
-    update transcript_range_summaries
-    set end_message_id = ?
-    where end_message_id = ?
-  `);
-    runInTransaction(db, () => {
-        for (const [oldId, nextId] of replacements) {
-            updateMessage.run(nextId, oldId);
-            updateTurn.run(nextId, oldId);
-            updateSummaryStart.run(nextId, oldId);
-            updateSummaryEnd.run(nextId, oldId);
-        }
-    });
-}
-function migrateMessageTurnIds(db) {
-    runInTransaction(db, () => {
-        db.exec(`
-      update messages
-      set turn_id = (
-        select turns.id
-        from turns
-        where turns.user_message_id = messages.id
-        limit 1
-      )
-      where turn_id is null
-        and role = 'user'
-        and exists (
-          select 1 from turns where turns.user_message_id = messages.id
-        );
-
-      update messages
-      set turn_id = (
-        select events.turn_id
-        from events
-        where events.event = 'server.steer'
-          and events.turn_id is not null
-          and json_extract(events.data_json, '$.messageId') = messages.id
-        order by events.created_at asc
-        limit 1
-      )
-      where role = 'user'
-        and exists (
-          select 1
-          from events
-          where events.event = 'server.steer'
-            and events.turn_id is not null
-            and json_extract(events.data_json, '$.messageId') = messages.id
-        );
-
-      update messages
-      set turn_id = (
-        select turns.id
-        from turns
-        where turns.finished_at is not null
-          and turns.finished_at >= messages.created_at
-        order by turns.finished_at asc
-        limit 1
-      )
-      where turn_id is null
-        and role = 'assistant';
-
-      delete from turns
-      where id like 'legacy-msg_%'
-        and exists (
-          select 1
-          from messages
-          where messages.id = turns.user_message_id
-            and messages.turn_id is not null
-            and messages.turn_id != turns.id
-        );
-    `);
-    });
-}
-function migrateWorkspaceTurns(db) {
-    const userMessages = db
-        .prepare(`
-      select id, created_at
-      from messages
-      where role = 'user' and turn_id is null
-      order by created_at asc, id asc
-    `)
-        .all();
-    if (userMessages.length === 0) {
-        return;
-    }
-    const existingTurnByMessageId = new Map();
-    for (const row of db
-        .prepare(`
-      select id, user_message_id
-      from turns
-      where user_message_id is not null
-    `)
-        .all()) {
-        existingTurnByMessageId.set(row.user_message_id, row.id);
-    }
-    const insertLegacyTurn = db.prepare(`
-    insert or ignore into turns (
-      id,
-      user_message_id,
-      codex_turn_id,
-      status,
-      started_at,
-      finished_at,
-      error,
-      created_at,
-      updated_at
-    )
-    values (?, ?, null, 'completed', ?, ?, null, ?, ?)
-  `);
-    const updateEventsWithEnd = db.prepare(`
-    update events
-    set turn_id = ?
-    where turn_id is null
-      and created_at >= ?
-      and created_at < ?
-  `);
-    const updateEventsWithoutEnd = db.prepare(`
-    update events
-    set turn_id = ?
-    where turn_id is null
-      and created_at >= ?
-  `);
-    const maxCreatedAtWithEnd = db.prepare(`
-    select max(created_at) as value
-    from (
-      select created_at from messages where created_at >= ? and created_at < ?
-      union all
-      select created_at from events where created_at >= ? and created_at < ?
-    )
-  `);
-    const maxCreatedAtWithoutEnd = db.prepare(`
-    select max(created_at) as value
-    from (
-      select created_at from messages where created_at >= ?
-      union all
-      select created_at from events where created_at >= ?
-    )
-  `);
-    runInTransaction(db, () => {
-        for (let index = 0; index < userMessages.length; index += 1) {
-            const message = userMessages[index];
-            const nextMessage = userMessages[index + 1] ?? null;
-            const turnId = existingTurnByMessageId.get(message.id) ?? `legacy-${message.id}`;
-            const finishedAt = nextMessage
-                ? maxCreatedAtWithEnd.get(message.created_at, nextMessage.created_at, message.created_at, nextMessage.created_at).value
-                : maxCreatedAtWithoutEnd.get(message.created_at, message.created_at).value;
-            const completedAt = finishedAt ?? message.created_at;
-            insertLegacyTurn.run(turnId, message.id, message.created_at, completedAt, message.created_at, completedAt);
-            if (nextMessage) {
-                updateEventsWithEnd.run(turnId, message.created_at, nextMessage.created_at);
-            }
-            else {
-                updateEventsWithoutEnd.run(turnId, message.created_at);
-            }
-        }
-    });
-}
-function initializeWorkspaceDatabase(workspacePath) {
-    const db = getWorkspaceDatabase(workspacePath);
-    initializeWorkspaceSchema(db);
-    migrateMessageIds(db);
-    migrateMessageTurnIds(db);
-    migrateWorkspaceTurns(db);
-    return db;
-}
-function getWorkspaceDatabase(workspacePath) {
-    const existing = workspaceDatabases.get(workspacePath);
-    if (existing) {
-        return existing;
-    }
-    const databasePath = getWorkspaceDatabasePath(workspacePath);
-    mkdirSync(path.dirname(databasePath), { recursive: true });
-    const db = openSqliteDatabase(databasePath);
-    db.exec("pragma journal_mode = WAL");
-    initializeWorkspaceSchema(db);
-    migrateMessageIds(db);
-    migrateMessageTurnIds(db);
-    migrateWorkspaceTurns(db);
-    workspaceDatabases.set(workspacePath, db);
-    return db;
-}
-function migrateLegacyWorkspaceGroups(workspaceRoot) {
-    const groupsPath = getWorkspaceGroupsPath(workspaceRoot);
-    if (existsSync(groupsPath)) {
-        const data = JSON.parse(readFileSync(groupsPath, "utf8"));
-        for (const group of data.groups ?? []) {
-            if (group &&
-                typeof group.id === "string" &&
-                typeof group.title === "string" &&
-                group.id &&
-                group.title.trim()) {
-                upsertWorkspaceGroup({
-                    id: group.id,
-                    ownerId: defaultOwnerId,
-                    title: group.title.trim(),
-                    createdAt: typeof group.createdAt === "string"
-                        ? group.createdAt
-                        : new Date().toISOString(),
-                    updatedAt: typeof group.updatedAt === "string"
-                        ? group.updatedAt
-                        : new Date().toISOString(),
-                });
-            }
-        }
-        archiveLegacyFile(groupsPath);
-    }
-    ensureDefaultWorkspaceGroup();
-}
-function migrateLegacyWorkspace(workspaceRoot, workspacePath, defaultSandbox) {
-    const metadataPath = getWorkspaceMetadataPath(workspacePath);
-    if (!existsSync(metadataPath)) {
-        return;
-    }
-    const data = JSON.parse(readFileSync(metadataPath, "utf8"));
-    if (!data.conversation) {
-        return;
-    }
-    const legacy = data.conversation;
-    if (workspaceExistsInCenter(legacy.id, workspacePath)) {
-        archiveLegacyFile(metadataPath);
-        return;
-    }
-    const conversation = {
-        ...legacy,
-        ownerId: legacy.ownerId || requireDefaultOwnerId(),
-        groupId: normalizeWorkspaceGroupId(legacy.groupId),
-        memory: typeof legacy.memory === "string" ? legacy.memory : "",
-        responsibility: typeof legacy.responsibility === "string" ? legacy.responsibility : "",
-        workspacePath,
-        sandbox: normalizeSandbox(legacy.sandbox, defaultSandbox),
-        status: legacy.status === "running" ? "error" : legacy.status,
-        messages: normalizeLegacyMessages(legacy.messages),
-        events: Array.isArray(legacy.events) ? legacy.events : [],
-        contextVersions: Array.isArray(legacy.contextVersions)
-            ? legacy.contextVersions
-            : [],
-    };
-    if (!conversation.contextVersions.length) {
-        const now = conversation.createdAt || new Date().toISOString();
-        const contextVersion = {
-            id: randomUUID(),
-            codexThreadId: conversation.codexThreadId,
-            source: "initial",
-            summary: null,
-            createdAt: now,
-        };
-        conversation.contextVersions = [contextVersion];
-    }
-    if (!path.resolve(workspacePath).startsWith(path.resolve(workspaceRoot))) {
-        return;
-    }
-    upsertConversationMetadata(conversation);
-    const workspaceDb = initializeWorkspaceDatabase(workspacePath);
-    if (countRows(workspaceDb, "context_versions") === 0) {
-        for (const version of conversation.contextVersions) {
-            upsertContextVersion(conversation, version);
-        }
-    }
-    if (countRows(workspaceDb, "messages") === 0) {
-        for (const message of conversation.messages) {
-            insertMessage(conversation, message);
-        }
-    }
-    if (countRows(workspaceDb, "events") === 0) {
-        for (const event of conversation.events) {
-            insertEvent(conversation, event);
-        }
-    }
-    migrateWorkspaceTurns(workspaceDb);
-    migrateMessageTurnIds(workspaceDb);
-    archiveLegacyFile(metadataPath);
-}
-function archiveLegacyFile(filePath) {
-    if (!existsSync(filePath)) {
-        return;
-    }
-    const archiveDir = path.join(path.dirname(filePath), LEGACY_MIGRATED_DIR_NAME);
-    mkdirSync(archiveDir, { recursive: true });
-    const archivePath = path.join(archiveDir, path.basename(filePath));
-    if (existsSync(archivePath)) {
-        const parsed = path.parse(filePath);
-        renameSync(filePath, path.join(archiveDir, `${parsed.name}-${new Date().toISOString().replace(/[:.]/g, "")}${parsed.ext}`));
-        return;
-    }
-    renameSync(filePath, archivePath);
-}
-function workspaceExistsInCenter(id, workspacePath) {
-    if (typeof id !== "string" || !id) {
-        return false;
-    }
-    const row = getCenterDatabase()
-        .prepare("select id from workspaces where id = ? or workspace_path = ? limit 1")
-        .get(id, workspacePath);
-    return Boolean(row);
-}
-function normalizeLegacyMessages(messages) {
-    if (!Array.isArray(messages)) {
-        return [];
-    }
-    return messages
-        .map((message, index) => {
-        if (!isLegacyMessageRecord(message)) {
-            return null;
-        }
-        const role = message.role === "assistant" ? "assistant" : "user";
-        const content = typeof message.content === "string" ? message.content : "";
-        const createdAt = typeof message.createdAt === "string" && message.createdAt.trim()
-            ? message.createdAt
-            : new Date(0).toISOString();
-        const id = typeof message.id === "string" && message.id.trim()
-            ? normalizeMessageId(message.id, createdAt, `${index}:${role}:${content}`)
-            : createStableMessageId(createdAt, `${index}:${role}:${content}`);
-        return {
-            id,
-            role,
-            content,
-            createdAt,
-            turnId: null,
-        };
-    })
-        .filter((message) => message !== null);
-}
-function isLegacyMessageRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeMessageId(id, createdAt, seed) {
-    const trimmed = id.trim();
-    return isCanonicalMessageId(trimmed)
-        ? trimmed
-        : createStableMessageId(createdAt, `${trimmed}:${seed}`);
-}
-function createMessageId(createdAt) {
-    return `msg_${formatMessageIdTimestamp(createdAt)}_${randomMessageSuffix()}`;
-}
-function createStableMessageId(createdAt, seed) {
-    return `msg_${formatMessageIdTimestamp(createdAt)}_${shortHash(seed)}`;
-}
-function isCanonicalMessageId(id) {
-    return /^msg_\d{8}_\d{6}_[0-9a-f]{6}$/.test(id);
-}
-function formatMessageIdTimestamp(value) {
-    const date = new Date(value);
-    const safeDate = Number.isNaN(date.getTime()) ? new Date() : date;
-    const pad = (input) => String(input).padStart(2, "0");
-    return [
-        safeDate.getFullYear(),
-        pad(safeDate.getMonth() + 1),
-        pad(safeDate.getDate()),
-        "_",
-        pad(safeDate.getHours()),
-        pad(safeDate.getMinutes()),
-        pad(safeDate.getSeconds()),
-    ].join("");
-}
-function randomMessageSuffix() {
-    return randomBytes(3).toString("hex");
-}
-function shortHash(value) {
-    return createHash("sha256").update(value).digest("hex").slice(0, 6);
-}
-function loadWorkspaceGroupsFromDatabase() {
-    workspaceGroups.clear();
-    const rows = getCenterDatabase()
-        .prepare("select * from workspace_groups order by created_at asc")
-        .all();
-    for (const row of rows) {
-        workspaceGroups.set(row.id, {
-            id: row.id,
-            ownerId: row.owner_id,
-            title: row.title,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        });
-    }
-}
-function getGlobalEnvironmentVariable(key) {
-    const row = getCenterDatabase()
-        .prepare("select * from global_environment_variables where key = ?")
-        .get(key);
-    return row ? globalEnvironmentVariableFromRow(row) : null;
-}
-function globalEnvironmentVariableFromRow(row) {
-    return {
-        key: row.key,
-        value: row.value,
-        description: row.description ?? "",
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function appSettingFromRow(row) {
-    return {
-        key: row.key,
-        value: row.value,
-        updatedAt: row.updated_at,
-    };
-}
-function loadConversationsFromDatabase(defaultSandbox) {
-    conversations.clear();
-    const rows = getCenterDatabase()
-        .prepare("select * from workspaces order by updated_at desc")
-        .all();
-    for (const row of rows) {
-        if (!existsSync(row.workspace_path)) {
-            continue;
-        }
-        let contextVersions = loadContextVersions(row.workspace_path);
-        if (!contextVersions.length) {
-            const contextVersion = {
-                id: randomUUID(),
-                codexThreadId: row.codex_thread_id,
-                source: "initial",
-                summary: null,
-                createdAt: row.created_at,
-            };
-            contextVersions = [contextVersion];
-        }
-        const memoryItems = readWorkspaceMemoryItems(row.workspace_path);
-        conversations.set(row.id, {
-            id: row.id,
-            ownerId: row.owner_id,
-            title: row.title,
-            groupId: normalizeWorkspaceGroupId(row.group_id),
-            memory: formatMemoryItems(memoryItems),
-            memoryItems,
-            responsibility: readWorkspaceResponsibility(row.workspace_path),
-            codexThreadId: row.codex_thread_id,
-            workspaceKind: row.workspace_kind,
-            workspacePath: row.workspace_path,
-            sandbox: normalizeSandbox(row.sandbox, defaultSandbox),
-            contextVersions,
-            status: row.status === "running" ? "error" : row.status,
-            messages: [],
-            events: [],
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        });
-    }
-}
-function readWorkspaceMemoryItems(workspacePath) {
-    return parseMemoryItems(readWorkspaceSettings(workspacePath)[WORKSPACE_MEMORY_ITEMS_SETTING_KEY]);
-}
-function readWorkspaceResponsibility(workspacePath) {
-    return readWorkspaceSettings(workspacePath)[WORKSPACE_RESPONSIBILITY_SETTING_KEY] ?? "";
-}
-function readWorkspaceSettings(workspacePath) {
-    const rows = getWorkspaceDatabase(workspacePath)
-        .prepare("select key, value from workspace_settings")
-        .all();
-    return Object.fromEntries(rows
-        .filter((row) => typeof row.key === "string")
-        .map((row) => [row.key, typeof row.value === "string" ? row.value : ""]));
-}
-function readWorkspaceSettingUpdatedAt(workspacePath, key) {
-    const row = getWorkspaceDatabase(workspacePath)
-        .prepare("select updated_at from workspace_settings where key = ?")
-        .get(key);
-    return typeof row?.updated_at === "string"
-        ? row.updated_at
-        : new Date().toISOString();
-}
-function initializeWorkspaceUnreadBaselines() {
-    const insert = getCenterDatabase().prepare(`
-    insert or ignore into workspace_unread_baselines (
-      workspace_id, terminal_turn_rowid
-    ) values (?, ?)
-  `);
-    runInTransaction(getCenterDatabase(), () => {
-        for (const conversation of conversations.values()) {
-            insert.run(conversation.id, latestTerminalTurnRowid(conversation));
-        }
-    });
-}
-function latestTerminalTurnRowid(conversation) {
-    const row = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select coalesce(max(rowid), 0) as rowid
-      from turns
-      where status in ('completed', 'failed')
-    `)
-        .get();
-    return row?.rowid ?? 0;
-}
-export function parseMemoryItems(value) {
-    if (!value?.trim()) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(value);
-        if (!Array.isArray(parsed)) {
-            return [];
-        }
-        return normalizeMemoryItems(parsed.map((item) => {
-            const record = item && typeof item === "object" ? item : {};
-            return {
-                key: "key" in record && typeof record.key === "string"
-                    ? record.key
-                    : "",
-                value: "value" in record && typeof record.value === "string"
-                    ? record.value
-                    : "",
-                updatedAt: "updatedAt" in record && typeof record.updatedAt === "string"
-                    ? record.updatedAt
-                    : new Date().toISOString(),
-            };
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-export function normalizeMemoryItems(items) {
-    const byKey = new Map();
-    for (const item of items) {
-        const key = normalizeMemoryKey(item.key);
-        const value = item.value.trim();
-        if (!key || !value) {
-            continue;
-        }
-        byKey.set(key, {
-            key,
-            value,
-            updatedAt: item.updatedAt || new Date().toISOString(),
-        });
-    }
-    return [...byKey.values()].sort((left, right) => left.key.localeCompare(right.key));
-}
-export function formatMemoryItems(items) {
-    return normalizeMemoryItems(items)
-        .map((item) => `${item.key}: ${item.value}`)
-        .join("\n");
-}
-function normalizeMemoryKey(key) {
-    return key
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, "-")
-        .replace(/[^a-z0-9_.-]/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^[^a-z_]+/, "")
-        .replace(/[-.]+$/g, "");
-}
-function isValidStoredEnvironmentKey(key) {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
-}
-function loadContextVersions(workspacePath) {
-    const rows = getWorkspaceDatabase(workspacePath)
-        .prepare("select * from context_versions order by created_at asc")
-        .all();
-    return rows.map((row) => ({
-        id: row.id,
-        codexThreadId: row.codex_thread_id,
-        source: row.source,
-        summary: row.summary,
-        createdAt: row.created_at,
-    }));
-}
-function ensureDefaultWorkspaceGroup() {
-    const row = getCenterDatabase()
-        .prepare("select id from workspace_groups where id = ?")
-        .get(DEFAULT_WORKSPACE_GROUP_ID);
-    if (row) {
-        return;
-    }
-    const now = new Date().toISOString();
-    upsertWorkspaceGroup({
-        id: DEFAULT_WORKSPACE_GROUP_ID,
-        ownerId: null,
-        title: "Default",
-        createdAt: now,
-        updatedAt: now,
-    });
-}
-function requireDefaultOwnerId() {
-    if (!defaultOwnerId) {
-        throw new Error("default workspace owner is not initialized");
-    }
-    return defaultOwnerId;
-}
-function upsertWorkspaceGroup(group) {
-    getCenterDatabase()
-        .prepare(`
-      insert into workspace_groups (id, owner_id, title, created_at, updated_at)
-      values (@id, @ownerId, @title, @createdAt, @updatedAt)
-      on conflict(id) do update set
-        owner_id = excluded.owner_id,
-        title = excluded.title,
-        updated_at = excluded.updated_at
-    `)
-        .run(group);
-    workspaceGroups.set(group.id, group);
-}
-function upsertConversationMetadata(conversation) {
-    getCenterDatabase()
-        .prepare(`
-      insert into workspaces (
-        id,
-        owner_id,
-        title,
-        group_id,
-        codex_thread_id,
-        workspace_kind,
-        workspace_path,
-        sandbox,
-        status,
-        created_at,
-        updated_at
-      )
-      values (
-        @id,
-        @ownerId,
-        @title,
-        @groupId,
-        @codexThreadId,
-        @workspaceKind,
-        @workspacePath,
-        @sandbox,
-        @status,
-        @createdAt,
-        @updatedAt
-      )
-      on conflict(id) do update set
-        title = excluded.title,
-        owner_id = excluded.owner_id,
-        group_id = excluded.group_id,
-        codex_thread_id = excluded.codex_thread_id,
-        workspace_kind = excluded.workspace_kind,
-        workspace_path = excluded.workspace_path,
-        sandbox = excluded.sandbox,
-        status = excluded.status,
-        updated_at = excluded.updated_at
-    `)
-        .run(conversation);
-}
-function upsertWorkspaceWakeup(wakeup) {
-    getCenterDatabase()
-        .prepare(`
-      insert into workspace_wakeups (
-        id,
-        workspace_id,
-        status,
-        wake_at,
-        instruction,
-        created_by,
-        created_turn_id,
-        result_turn_id,
-        error,
-        attempt_count,
-        max_attempts,
-        created_at,
-        updated_at
-      )
-      values (
-        @id,
-        @workspaceId,
-        @status,
-        @wakeAt,
-        @instruction,
-        @createdBy,
-        @createdTurnId,
-        @resultTurnId,
-        @error,
-        @attemptCount,
-        @maxAttempts,
-        @createdAt,
-        @updatedAt
-      )
-      on conflict(id) do update set
-        status = excluded.status,
-        wake_at = excluded.wake_at,
-        instruction = excluded.instruction,
-        result_turn_id = excluded.result_turn_id,
-        error = excluded.error,
-        attempt_count = excluded.attempt_count,
-        max_attempts = excluded.max_attempts,
-        updated_at = excluded.updated_at
-    `)
-        .run(wakeup);
-}
-function getWorkspaceWakeup(id) {
-    const row = getCenterDatabase()
-        .prepare("select * from workspace_wakeups where id = ?")
-        .get(id);
-    return row ? wakeupFromRow(row) : null;
-}
-function countWakeupsByStatus() {
-    const counts = {
-        scheduled: 0,
-        running: 0,
-        completed: 0,
-        cancelled: 0,
-        failed: 0,
-    };
-    const rows = getCenterDatabase()
-        .prepare("select status, count(*) as count from workspace_wakeups group by status")
-        .all();
-    for (const row of rows) {
-        if (row.status in counts) {
-            counts[row.status] = row.count;
-        }
-    }
-    return counts;
-}
-function updateConversationMetadata(conversation) {
-    upsertConversationMetadata(conversation);
-}
-function upsertContextVersion(conversation, contextVersion) {
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert into context_versions (id, codex_thread_id, source, summary, created_at)
-      values (@id, @codexThreadId, @source, @summary, @createdAt)
-      on conflict(id) do update set
-        codex_thread_id = excluded.codex_thread_id,
-        source = excluded.source,
-        summary = excluded.summary
-    `)
-        .run(contextVersion);
-}
-function insertMessage(conversation, message) {
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert or ignore into messages (id, role, content, turn_id, created_at)
-      values (@id, @role, @content, @turnId, @createdAt)
-    `)
-        .run(message);
-}
-function upsertTurn(conversation, turn) {
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert into turns (
-        id,
-        user_message_id,
-        codex_turn_id,
-        status,
-        started_at,
-        finished_at,
-        error,
-        created_at,
-        updated_at
-      )
-      values (
-        @id,
-        @userMessageId,
-        @codexTurnId,
-        @status,
-        @startedAt,
-        @finishedAt,
-        @error,
-        @createdAt,
-        @updatedAt
-      )
-      on conflict(id) do update set
-        user_message_id = excluded.user_message_id,
-        codex_turn_id = excluded.codex_turn_id,
-        status = excluded.status,
-        started_at = excluded.started_at,
-        finished_at = excluded.finished_at,
-        error = excluded.error,
-        updated_at = excluded.updated_at
-    `)
-        .run(turn);
-}
-function getTurn(conversation, turnId) {
-    const row = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare("select * from turns where id = ?")
-        .get(turnId);
-    return row ? turnFromRow(row) : null;
-}
-function countWorkspaceRows(workspacePath, table) {
-    const row = getWorkspaceDatabase(workspacePath)
-        .prepare(`select count(*) as count from ${table}`)
-        .get();
-    return row?.count ?? 0;
-}
-function insertEvent(conversation, event, turnId = null) {
-    getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      insert or ignore into events (id, turn_id, event, data_json, created_at)
-      values (@id, @turnId, @event, @dataJson, @createdAt)
-    `)
-        .run({
-        id: event.id,
-        turnId,
-        event: event.event,
-        dataJson: JSON.stringify(event.data),
-        createdAt: event.createdAt,
-    });
-}
-function listTurnsFromDatabase(conversation, before, limit) {
-    const db = getWorkspaceDatabase(conversation.workspacePath);
-    const rows = before
-        ? db
-            .prepare(`
-          select * from turns
-          where started_at < ?
-          order by started_at desc
-          limit ?
-        `)
-            .all(before, limit)
-        : db
-            .prepare(`
-          select * from turns
-          order by started_at desc
-          limit ?
-        `)
-            .all(limit);
-    return rows.reverse().map(turnFromRow);
-}
-function listMessagesForTurns(conversation, turns) {
-    if (turns.length === 0) {
-        return [];
-    }
-    const windowClauses = turns
-        .map(() => "(created_at >= ? and created_at <= ?)")
-        .join(" or ");
-    const now = new Date().toISOString();
-    const windowParams = turns.flatMap((turn, index) => {
-        const nextTurn = turns[index + 1] ?? null;
-        return [
-            turn.startedAt,
-            turn.finishedAt ?? nextTurn?.startedAt ?? now,
-        ];
-    });
-    const userMessageIds = turns
-        .map((turn) => turn.userMessageId)
-        .filter((id) => typeof id === "string" && id.length > 0);
-    const userMessageClause = userMessageIds.length > 0
-        ? `id in (${userMessageIds.map(() => "?").join(", ")}) or `
-        : "";
-    const turnIds = turns.map((turn) => turn.id);
-    const turnPlaceholders = turnIds.map(() => "?").join(", ");
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from messages
-      where turn_id in (${turnPlaceholders})
-        or (
-          turn_id is null
-          and (${userMessageClause}${windowClauses})
-        )
-      order by created_at asc, id asc
-    `)
-        .all(...turnIds, ...userMessageIds, ...windowParams);
-    return rows.map(messageFromRow);
-}
-function listEventsForTurns(conversation, turnIds, options = {}) {
-    if (turnIds.length === 0) {
-        return [];
-    }
-    const placeholders = turnIds.map(() => "?").join(", ");
-    const rows = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare(`
-      select * from events
-      where turn_id in (${placeholders})
-      order by created_at asc, id asc
-    `)
-        .all(...turnIds);
-    const events = rows.map(eventFromRow);
-    if (options.compact === false) {
-        return events;
-    }
-    return events
-        .map(compactHistoryEvent)
-        .filter((event) => event !== null);
-}
-function eventFromRow(row) {
-    return {
-        id: row.id,
-        turnId: row.turn_id,
-        event: row.event,
-        data: parseEventData(row.data_json),
-        createdAt: row.created_at,
-    };
-}
-function compactHistoryEvent(event) {
-    if (event.event === "server.thread") {
-        return null;
-    }
-    if (event.event === "codex.notification") {
-        const notification = readEventObject(event.data);
-        const method = notification.method;
-        const params = readEventObject(notification.params);
-        if (method === "account/rateLimits/updated") {
-            return event;
-        }
-        if (method === "item/agentMessage/delta" ||
-            method === "item/agentMessage/thinking_delta" ||
-            method === "item/commandExecution/outputDelta" ||
-            (typeof method === "string" && method.startsWith("hook/"))) {
-            return null;
-        }
-        if (method === "item/started" || method === "item/completed") {
-            const item = readEventObject(params.item);
-            if (item.type === "agentMessage" || item.type === "userMessage") {
-                return null;
-            }
-            if (item.type === "commandExecution") {
-                return null;
-            }
-            return event;
-        }
-        return null;
-    }
-    if (event.event === "codex.stderr") {
-        return null;
-    }
-    return event;
-}
-function compactCommandExecutionItem(item) {
-    return {
-        ...item,
-        aggregatedOutput: typeof item.aggregatedOutput === "string"
-            ? truncateHistoryText(item.aggregatedOutput)
-            : item.aggregatedOutput,
-    };
-}
-function truncateHistoryText(value) {
-    if (value.length <= MAX_COMPACT_EVENT_TEXT_LENGTH) {
-        return value;
-    }
-    return `${value.slice(0, MAX_COMPACT_EVENT_TEXT_LENGTH)}\n... [truncated in history view]`;
-}
-function readEventObject(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-function turnFromRow(row) {
-    return {
-        id: row.id,
-        userMessageId: row.user_message_id,
-        codexTurnId: row.codex_turn_id,
-        status: row.status,
-        startedAt: row.started_at,
-        finishedAt: row.finished_at,
-        error: row.error,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function messageFromRow(row) {
-    return {
-        id: row.id,
-        role: row.role,
-        content: row.content,
-        createdAt: row.created_at,
-        turnId: row.turn_id,
-    };
-}
-function wakeupFromRow(row) {
-    return {
-        id: row.id,
-        workspaceId: row.workspace_id,
-        status: row.status,
-        wakeAt: row.wake_at,
-        instruction: row.instruction,
-        createdBy: row.created_by,
-        createdTurnId: row.created_turn_id,
-        resultTurnId: row.result_turn_id,
-        error: row.error,
-        attemptCount: row.attempt_count,
-        maxAttempts: row.max_attempts,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function transcriptRangeSummaryFromRow(row) {
-    return {
-        id: row.id,
-        startMessageId: row.start_message_id,
-        endMessageId: row.end_message_id,
-        title: row.title,
-        summary: row.summary,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function runtimeResetFromRow(row) {
-    return {
-        id: row.id,
-        oldCodexThreadId: row.old_codex_thread_id,
-        newCodexThreadId: row.new_codex_thread_id,
-        mode: row.mode,
-        status: row.status,
-        injectedMessageCount: row.injected_message_count,
-        injectedUserMessageCount: row.injected_user_message_count,
-        injectedAssistantMessageCount: row.injected_assistant_message_count,
-        injectedMessages: parseRuntimeResetMessages(row.injected_messages_json ?? "[]"),
-        error: row.error,
-        createdAt: row.created_at,
-        completedAt: row.completed_at,
-    };
-}
-function parseRuntimeResetMessages(dataJson) {
-    try {
-        const value = JSON.parse(dataJson);
-        if (!Array.isArray(value)) {
-            return [];
-        }
-        return value.filter(isConversationMessage);
-    }
-    catch {
-        return [];
-    }
-}
-function isConversationMessage(value) {
-    if (!value || typeof value !== "object") {
-        return false;
-    }
-    const item = value;
-    return (typeof item.id === "string" &&
-        (item.role === "user" || item.role === "assistant") &&
-        typeof item.content === "string" &&
-        typeof item.createdAt === "string");
-}
-function clampWakeupMaxAttempts(value) {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return 3;
-    }
-    return Math.max(1, Math.min(20, Math.floor(value)));
-}
-function hasTurnsBefore(conversation, timestamp) {
-    const row = getWorkspaceDatabase(conversation.workspacePath)
-        .prepare("select 1 as found from turns where started_at < ? limit 1")
-        .get(timestamp);
-    return Boolean(row);
-}
-function countRows(db, table) {
-    const row = db.prepare(`select count(*) as count from ${table}`).get();
-    return row.count;
-}
-function parseEventData(dataJson) {
-    try {
-        return JSON.parse(dataJson);
-    }
-    catch {
-        return null;
-    }
-}
-function trimInMemoryEvents(conversation) {
-    if (conversation.events.length <= MAX_IN_MEMORY_EVENTS_PER_WORKSPACE) {
-        return;
-    }
-    conversation.events.splice(0, conversation.events.length - MAX_IN_MEMORY_EVENTS_PER_WORKSPACE);
-}
-function getWorkspaceMetadataPath(workspacePath) {
-    return path.join(workspacePath, ".seele", "workspace.json");
-}
-function getWorkspaceDatabasePath(workspacePath) {
-    return path.join(workspacePath, ".seele", "workspace.db");
-}
-function getWorkspaceGroupsPath(workspaceRoot) {
-    return path.join(workspaceRoot, ".seele", "groups.json");
-}
-function ensureWorkspacePathIsManaged(workspacePath) {
-    if (!workspaceRootPath) {
-        throw new Error("workspace store is not initialized");
-    }
-    const resolvedRoot = path.resolve(workspaceRootPath);
-    const resolvedWorkspace = path.resolve(workspacePath);
-    const relativePath = path.relative(resolvedRoot, resolvedWorkspace);
-    if (relativePath === "" ||
-        relativePath.startsWith("..") ||
-        path.isAbsolute(relativePath)) {
-        throw new Error(`refusing to delete unmanaged workspace: ${workspacePath}`);
-    }
-}
-function moveWorkspaceToRecycle(conversation) {
-    if (!workspaceRootPath) {
-        throw new Error("workspace store is not initialized");
-    }
-    const recycleRoot = path.join(path.dirname(workspaceRootPath), "recycle");
-    mkdirSync(recycleRoot, { recursive: true });
-    const timestamp = new Date()
-        .toISOString()
-        .replaceAll(":", "")
-        .replaceAll(".", "");
-    let recyclePath = path.join(recycleRoot, `${conversation.id}-${timestamp}`);
-    for (let attempt = 1; existsSync(recyclePath); attempt += 1) {
-        recyclePath = path.join(recycleRoot, `${conversation.id}-${timestamp}-${attempt}`);
-    }
-    renameSync(conversation.workspacePath, recyclePath);
-}