@seele00/seele 0.1.60

package/server/dist/conversations/store.js

@@ -0,0 +1,2376 @@
+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 = 8;
+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);
+}
+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 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);
+    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);
+    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 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();
+}
+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);
+}