telecodex 0.1.1 → 0.1.2

package/README.md

@@ -28,6 +28,7 @@ The bot talks to local Codex through `@openai/codex-sdk`, which wraps the local
 - One topic maps to one Codex SDK thread.
 - Each topic has at most one active SDK run.
 - Follow-up messages during an active run are queued and processed in order.
+- The pending queue is in-memory only and is cleared on restart.
 - Text and image messages are mapped to Codex SDK input.
 - A run immediately creates a normal Telegram status message; progress edits that message.
 - telecodex does not use pinned messages for live state.
@@ -122,13 +123,18 @@ Optional security override:
 - The project root is bound once with `/project bind <absolute-path>`.
 - Each topic in that supergroup is one Codex thread.
 - Work happens by sending normal messages inside the topic.
+- `/thread list` shows the saved Codex threads already recorded for the bound project root or its subdirectories.
 - `/thread new <topic-name>` automatically creates a new topic; the first normal message inside it starts a fresh Codex thread.
 - `/thread resume <threadId>` automatically creates a new topic and binds it to an existing thread id.
+- On startup, telecodex probes stored topic bindings once and removes bindings whose Telegram topics no longer exist.
+- On first launch after upgrading from the old SQLite state format, telecodex imports the legacy state once and then deletes the old SQLite files (`state.sqlite` plus sidecars such as `-wal`/`-shm`).
 
 ## Stored state
 
 - Telegram bot token: stored in the system keychain when available. Plaintext local fallback is disabled by default and must be opted into explicitly.
-- Admin binding, project bindings, and topic/session state: stored in a local SQLite database under `~/.telecodex/`.
+- Codex thread history: read directly from Codex session files under `$CODEX_HOME/sessions` (or `~/.codex/sessions` by default).
+- Admin binding, project bindings, and durable Telegram topic configuration: stored as local JSON files under `~/.telecodex/state/`.
+- Legacy upgrade path: if `~/.telecodex/state.sqlite` exists from an older telecodex version, it is imported once into the JSON state files and then cleaned up together with any SQLite sidecar files that remain.
 - Runtime logs: written by `pino` to `~/.telecodex/logs/telecodex.log`.
 - Working directory: defaults to the directory where you ran `telecodex`.
 
@@ -149,8 +155,9 @@ Optional security override:
 - `/project bind <absolute-path>` - bind the current supergroup to a project root.
 - `/project unbind` - remove the current supergroup's project binding.
 - `/thread` - in a topic, show the current attached thread id.
+- `/thread list` - list saved Codex threads whose working directory is inside the current project root.
 - `/thread new <topic-name>` - create a new topic for a fresh Codex thread.
-- `/thread resume <threadId>` - create a new topic and bind it to an existing Codex thread id.
+- `/thread resume <threadId>` - create a new topic and bind it to an existing saved Codex thread id from the current project.
 - Normal text in a topic - send that message to the current Codex thread.
 - `/stop` - interrupt the active SDK run.
 - `/cwd <absolute-path>` - switch the topic working directory inside the current project root.
@@ -174,6 +181,6 @@ Optional security override:
 - Streaming updates are throttled before editing Telegram messages.
 - Final answers are rendered from Markdown to Telegram-safe HTML.
 - Project-scoped path checks resolve symlinks before enforcing the root boundary, so topic cwd changes cannot escape the bound project through symlink paths.
-- Because the SDK run is in-process, a telecodex restart cannot resume a partially streamed Telegram turn; the topic is reset and the user is asked to resend.
+- Because the SDK run and pending queue are in-process, a telecodex restart cannot resume a partially streamed Telegram turn and clears queued follow-up messages.
 - Authentication and provider switching remain owned by the local Codex installation; telecodex does not manage API keys or login state.
 - Interactive terminal stdin bridging and native Codex approval UI are intentionally not part of the Telegram contract. For unattended remote work, use the topic's sandbox/approval preset deliberately.

package/dist/bot/commandSupport.js

@@ -47,6 +47,7 @@ export function formatHelpText(ctx, projects) {
             "/project bind <absolute-path>",
             "",
             "Then manage threads in the group:",
+            "/thread list",
             "/thread new <topic-name>",
             "/thread resume <threadId>",
             "",
@@ -80,6 +81,7 @@ export function formatHelpText(ctx, projects) {
         "",
         "/project show the project binding",
         "/project bind <absolute-path> update the project root",
+        "/thread list show saved Codex threads already recorded for this project",
         "/thread new <topic-name> create a new topic; the first message starts a new thread",
         "/thread resume <threadId> create a topic bound to an existing thread",
         "send a normal message inside a topic to the current thread",
@@ -135,7 +137,7 @@ export function formatProjectStatus(project) {
         "Project status",
         `project: ${project.name}`,
         `root: ${project.cwd}`,
-        "This supergroup represents one project. Use /thread new or /thread resume to create topics.",
+        "This supergroup represents one project. Use /thread list, /thread new, or /thread resume to manage topics.",
     ].join("\n");
 }
 export function ensureTopicSession(input) {

package/dist/bot/createBot.js

@@ -3,9 +3,10 @@ import { MessageBuffer } from "../telegram/messageBuffer.js";
 import { authMiddleware } from "./auth.js";
 import { recoverActiveTopicSessions } from "./inputService.js";
 import { registerHandlers } from "./registerHandlers.js";
+import { cleanupMissingTopicBindings } from "./topicCleanup.js";
 export { handleUserText, refreshSessionIfActiveTurnIsStale } from "./inputService.js";
 export function wireBot(input) {
-    const { bot, config, store, projects, codex, bootstrapCode, logger, onAdminBound } = input;
+    const { bot, config, store, projects, codex, threadCatalog, bootstrapCode, logger, onAdminBound } = input;
     const buffers = new MessageBuffer(bot, config.updateIntervalMs, logger?.child("message-buffer"));
     bot.use(authMiddleware({
         store,
@@ -30,10 +31,23 @@ export function wireBot(input) {
         store,
         projects,
         codex,
+        threadCatalog,
         buffers,
         ...(logger ? { logger } : {}),
     });
-    void recoverActiveTopicSessions(store, codex, buffers, bot, logger);
+    void (async () => {
+        try {
+            await cleanupMissingTopicBindings({
+                bot,
+                store,
+                ...(logger ? { logger: logger.child("topic-cleanup") } : {}),
+            });
+            await recoverActiveTopicSessions(store, codex, buffers, bot, logger);
+        }
+        catch (error) {
+            logger?.error("startup topic reconciliation failed", error);
+        }
+    })();
     return {
         bot,
         buffers,

package/dist/bot/handlers/projectHandlers.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { contextLogFields, ensureTopicSession, formatPrivateProjectList, formatProjectStatus, formatTopicName, getProjectForContext, getScopedSession, hasTopicContext, isPrivateChat, isSupergroupChat, parseSubcommand, postTopicReadyMessage, resolveExistingDirectory, } from "../commandSupport.js";
 import { formatSessionRuntimeStatus } from "../../runtime/sessionRuntime.js";
 const PROJECT_REQUIRED_MESSAGE = "This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.";
@@ -82,12 +83,17 @@ export function registerProjectHandlers(deps) {
                     `queue: ${store.getQueuedInputCount(session.sessionKey)}`,
                     `cwd: ${session.cwd}`,
                     "Manage threads in this project:",
+                    "/thread list",
                     "/thread resume <threadId>",
                     "/thread new <topic-name>",
                 ].join("\n"));
                 return;
             }
-            await ctx.reply("Usage:\n/thread resume <threadId>\n/thread new <topic-name>");
+            await ctx.reply("Usage:\n/thread list\n/thread resume <threadId>\n/thread new <topic-name>");
+            return;
+        }
+        if (command === "list") {
+            await listProjectThreads(ctx, deps);
             return;
         }
         if (command === "resume") {
@@ -102,7 +108,7 @@ export function registerProjectHandlers(deps) {
             await createFreshThreadTopic(ctx, deps, args);
             return;
         }
-        await ctx.reply("Usage:\n/thread resume <threadId>\n/thread new <topic-name>");
+        await ctx.reply("Usage:\n/thread list\n/thread resume <threadId>\n/thread new <topic-name>");
     });
     bot.on(["message:forum_topic_created", "message:forum_topic_edited"], async (ctx) => {
         const threadId = ctx.message.message_thread_id;
@@ -119,13 +125,26 @@ export function registerProjectHandlers(deps) {
     });
 }
 async function resumeThreadIntoTopic(ctx, deps, threadId) {
-    const { bot, config, store, projects, logger } = deps;
+    const { bot, config, store, projects, logger, threadCatalog } = deps;
     const project = getProjectForContext(ctx, projects);
     if (!project) {
         await ctx.reply(PROJECT_REQUIRED_MESSAGE);
         return;
     }
-    const topicName = formatTopicName(`Resumed ${threadId.slice(0, 8)}`, "Resumed Thread");
+    const thread = await threadCatalog.findProjectThreadById({
+        projectRoot: project.cwd,
+        threadId,
+    });
+    if (!thread) {
+        await ctx.reply([
+            "Could not find a saved Codex thread with that id under this project.",
+            `project root: ${project.cwd}`,
+            `thread: ${threadId}`,
+            "Run /thread list to inspect the saved project threads first.",
+        ].join("\n"));
+        return;
+    }
+    const topicName = formatTopicName(thread.preview, `Resumed ${thread.id.slice(0, 8)}`);
     const forumTopic = await bot.api.createForumTopic(ctx.chat.id, topicName);
     const session = ensureTopicSession({
         store,
@@ -134,24 +153,25 @@ async function resumeThreadIntoTopic(ctx, deps, threadId) {
         chatId: ctx.chat.id,
         messageThreadId: forumTopic.message_thread_id,
         topicName: forumTopic.name,
-        threadId,
+        threadId: thread.id,
     });
     logger?.info("thread id bound into topic", {
         ...contextLogFields(ctx),
         sessionKey: session.sessionKey,
-        threadId,
+        threadId: thread.id,
         topicName: forumTopic.name,
     });
     await ctx.reply([
         "Created a topic and bound it to the existing thread id.",
         `topic: ${forumTopic.name}`,
         `topic id: ${forumTopic.message_thread_id}`,
-        `thread: ${threadId}`,
+        `thread: ${thread.id}`,
+        `cwd: ${thread.cwd}`,
         "Future messages in this topic will continue on that thread through the Codex SDK.",
     ].join("\n"));
     await postTopicReadyMessage(bot, session, [
         "This topic is now bound to an existing Codex thread id.",
-        `thread: ${threadId}`,
+        `thread: ${thread.id}`,
         "Send a message to continue.",
     ].join("\n"));
 }
@@ -190,3 +210,42 @@ async function createFreshThreadTopic(ctx, deps, requestedName) {
         `model: ${session.model}`,
     ].join("\n"));
 }
+async function listProjectThreads(ctx, deps) {
+    const { projects, store, threadCatalog } = deps;
+    const project = getProjectForContext(ctx, projects);
+    if (!project) {
+        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        return;
+    }
+    const threads = await threadCatalog.listProjectThreads({
+        projectRoot: project.cwd,
+        limit: 8,
+    });
+    if (threads.length === 0) {
+        await ctx.reply([
+            "No saved Codex threads were found for this project yet.",
+            `project root: ${project.cwd}`,
+        ].join("\n"));
+        return;
+    }
+    const lines = [
+        `Saved Codex threads for ${project.name}:`,
+        ...threads.flatMap((thread, index) => {
+            const relativeCwd = path.relative(project.cwd, thread.cwd) || ".";
+            const bound = store.getByThreadId(thread.id);
+            return [
+                `${index + 1}. ${thread.preview}`,
+                `   id: ${thread.id}`,
+                `   cwd: ${relativeCwd}`,
+                `   updated: ${thread.updatedAt}`,
+                `   source: ${thread.source ?? "unknown"}`,
+                ...(bound
+                    ? [`   bound: ${bound.telegramTopicName ?? bound.messageThreadId ?? bound.sessionKey}`]
+                    : []),
+            ];
+        }),
+        "",
+        "Resume one with /thread resume <threadId>",
+    ];
+    await ctx.reply(lines.join("\n"));
+}

package/dist/bot/topicCleanup.js

@@ -0,0 +1,80 @@
+import { GrammyError } from "grammy";
+import { sendTypingAction } from "../telegram/delivery.js";
+export async function cleanupMissingTopicBindings(input) {
+    const sessions = input.store.listTopicSessions();
+    const summary = {
+        total: sessions.length,
+        checked: 0,
+        kept: 0,
+        removed: 0,
+        skipped: 0,
+        failed: 0,
+    };
+    for (const session of sessions) {
+        const chatId = Number(session.chatId);
+        const messageThreadId = Number(session.messageThreadId);
+        if (!Number.isSafeInteger(chatId) || !Number.isSafeInteger(messageThreadId)) {
+            summary.skipped += 1;
+            input.logger?.warn("skipped topic binding cleanup for non-numeric telegram identifiers", {
+                sessionKey: session.sessionKey,
+                chatId: session.chatId,
+                messageThreadId: session.messageThreadId,
+            });
+            continue;
+        }
+        summary.checked += 1;
+        try {
+            await sendTypingAction(input.bot, {
+                chatId,
+                messageThreadId,
+            }, input.logger);
+            summary.kept += 1;
+        }
+        catch (error) {
+            if (!isMissingTopicBindingError(error)) {
+                summary.failed += 1;
+                input.logger?.warn("topic binding cleanup probe failed", {
+                    sessionKey: session.sessionKey,
+                    chatId,
+                    messageThreadId,
+                    error,
+                });
+                continue;
+            }
+            input.store.remove(session.sessionKey);
+            summary.removed += 1;
+            input.logger?.info("removed stale telegram topic binding", {
+                sessionKey: session.sessionKey,
+                chatId,
+                messageThreadId,
+                codexThreadId: session.codexThreadId,
+                topicName: session.telegramTopicName,
+            });
+        }
+    }
+    input.logger?.info("topic binding cleanup finished", summary);
+    return summary;
+}
+export function isMissingTopicBindingError(error) {
+    const description = describeError(error);
+    if (!description)
+        return false;
+    return [
+        "message thread not found",
+        "message thread was not found",
+        "forum topic not found",
+        "topic not found",
+        "thread not found",
+        "topic deleted",
+        "topic_deleted",
+    ].some((fragment) => description.includes(fragment));
+}
+function describeError(error) {
+    if (error instanceof GrammyError) {
+        return typeof error.description === "string" ? error.description.toLowerCase() : null;
+    }
+    if (error instanceof Error) {
+        return error.message.toLowerCase();
+    }
+    return typeof error === "string" ? error.toLowerCase() : null;
+}

package/dist/codex/sessionCatalog.js

@@ -0,0 +1,215 @@
+import { createReadStream, existsSync, opendirSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline";
+export class CodexSessionCatalog {
+    sessionsRoot;
+    constructor(input) {
+        this.sessionsRoot = input?.sessionsRoot ?? defaultSessionsRoot();
+        this.logger = input?.logger;
+    }
+    logger;
+    async listProjectThreads(input) {
+        const projectRoot = canonicalizePath(input.projectRoot);
+        const limit = Math.max(1, input.limit ?? 8);
+        const files = listSessionFiles(this.sessionsRoot)
+            .filter((entry) => entry.mtimeMs > 0)
+            .sort((left, right) => right.mtimeMs - left.mtimeMs);
+        const matches = [];
+        for (const file of files) {
+            const summary = await readSessionSummary(file.path, file.updatedAt);
+            if (!summary)
+                continue;
+            if (!isPathWithinRoot(summary.cwd, projectRoot))
+                continue;
+            matches.push(summary);
+            if (matches.length >= limit)
+                break;
+        }
+        return matches;
+    }
+    async findProjectThreadById(input) {
+        const projectRoot = canonicalizePath(input.projectRoot);
+        const threadId = input.threadId.trim();
+        if (!threadId)
+            return null;
+        const files = listSessionFiles(this.sessionsRoot).sort((left, right) => right.mtimeMs - left.mtimeMs);
+        for (const file of files) {
+            const summary = await readSessionSummary(file.path, file.updatedAt);
+            if (!summary)
+                continue;
+            if (summary.id !== threadId)
+                continue;
+            if (!isPathWithinRoot(summary.cwd, projectRoot))
+                return null;
+            return summary;
+        }
+        this.logger?.debug("codex thread not found in saved sessions", {
+            projectRoot,
+            threadId,
+            sessionsRoot: this.sessionsRoot,
+        });
+        return null;
+    }
+}
+function defaultSessionsRoot() {
+    const codexHome = process.env.CODEX_HOME?.trim();
+    const root = codexHome ? path.resolve(codexHome) : path.join(homedir(), ".codex");
+    return path.join(root, "sessions");
+}
+function listSessionFiles(root) {
+    if (!existsSync(root))
+        return [];
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let directory;
+        try {
+            directory = opendirSync(current);
+        }
+        catch {
+            continue;
+        }
+        for (let entry = directory.readSync(); entry != null; entry = directory.readSync()) {
+            const resolved = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(resolved);
+                continue;
+            }
+            if (!entry.isFile() || !resolved.endsWith(".jsonl"))
+                continue;
+            try {
+                const stat = statSync(resolved);
+                files.push({
+                    path: resolved,
+                    updatedAt: stat.mtime.toISOString(),
+                    mtimeMs: stat.mtimeMs,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        directory.closeSync();
+    }
+    return files;
+}
+async function readSessionSummary(filePath, updatedAt) {
+    const input = createReadStream(filePath, { encoding: "utf8" });
+    const reader = createInterface({
+        input,
+        crlfDelay: Infinity,
+    });
+    let meta = null;
+    let preview = "";
+    try {
+        for await (const line of reader) {
+            const parsed = parseJsonLine(line);
+            if (!parsed)
+                continue;
+            if (!meta) {
+                meta = parseSessionMeta(parsed);
+            }
+            if (!preview) {
+                preview = parseUserPreview(parsed);
+            }
+            if (meta && preview)
+                break;
+        }
+    }
+    finally {
+        reader.close();
+        input.destroy();
+    }
+    if (!meta?.id || !meta.cwd)
+        return null;
+    return {
+        id: meta.id,
+        cwd: canonicalizePath(meta.cwd),
+        createdAt: typeof meta.timestamp === "string" ? meta.timestamp : null,
+        updatedAt,
+        preview: preview || "(no user message preview)",
+        source: typeof meta.source === "string" ? meta.source : null,
+        modelProvider: typeof meta.model_provider === "string" ? meta.model_provider : null,
+        sessionPath: filePath,
+    };
+}
+function parseJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionMeta(parsed) {
+    if (parsed.type !== "session_meta")
+        return null;
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (!payload)
+        return null;
+    if (typeof payload.id !== "string" || typeof payload.cwd !== "string")
+        return null;
+    return {
+        id: payload.id,
+        cwd: payload.cwd,
+        ...(typeof payload.timestamp === "string" ? { timestamp: payload.timestamp } : {}),
+        ...(typeof payload.source === "string" ? { source: payload.source } : {}),
+        ...(typeof payload.model_provider === "string" ? { model_provider: payload.model_provider } : {}),
+    };
+}
+function parseUserPreview(parsed) {
+    if (parsed.type === "event_msg") {
+        const payload = isRecord(parsed.payload) ? parsed.payload : null;
+        if (payload?.type === "user_message" && typeof payload.message === "string") {
+            return normalizePreview(payload.message);
+        }
+    }
+    if (parsed.type !== "response_item")
+        return "";
+    const payload = isRecord(parsed.payload) ? parsed.payload : null;
+    if (!payload || payload.type !== "message" || payload.role !== "user")
+        return "";
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    for (const item of content) {
+        if (!isRecord(item) || item.type !== "input_text" || typeof item.text !== "string")
+            continue;
+        const preview = normalizePreview(item.text);
+        if (preview)
+            return preview;
+    }
+    return "";
+}
+function normalizePreview(value) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "";
+    if (normalized.startsWith("# AGENTS.md instructions") ||
+        normalized.startsWith("<environment_context>") ||
+        normalized.startsWith("<app-context>") ||
+        normalized.startsWith("<permissions instructions>")) {
+        return "";
+    }
+    if (normalized.length <= 96)
+        return normalized;
+    return `${normalized.slice(0, 93)}...`;
+}
+function isPathWithinRoot(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}
+function canonicalizePath(value) {
+    const resolved = path.resolve(value);
+    try {
+        return realpathSync.native(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/config.js

@@ -14,7 +14,6 @@ export function buildConfig(input) {
         telegramBotToken: input.telegramBotToken,
         defaultCwd,
         defaultModel: input.defaultModel?.trim() || "gpt-5.4",
-        dbPath: path.resolve(input.dbPath),
         codexBin: input.codexBin,
         updateIntervalMs: input.updateIntervalMs ?? 700,
     };

package/dist/runtime/appPaths.js

@@ -3,7 +3,10 @@ import path from "node:path";
 export function getAppHome() {
     return path.join(homedir(), ".telecodex");
 }
-export function getStateDbPath() {
+export function getStateDir() {
+    return path.join(getAppHome(), "state");
+}
+export function getLegacyStateDbPath() {
     return path.join(getAppHome(), "state.sqlite");
 }
 export function getLogsDir() {

package/dist/runtime/bootstrap.js

@@ -5,19 +5,24 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { Bot, GrammyError, HttpError } from "grammy";
 import { buildConfig } from "../config.js";
-import { openDatabase } from "../store/db.js";
+import { FileStateStorage } from "../store/fileState.js";
+import { migrateLegacySqliteState } from "../store/legacyMigration.js";
 import { ProjectStore } from "../store/projects.js";
 import { BINDING_CODE_MAX_ATTEMPTS, SessionStore } from "../store/sessions.js";
-import { getStateDbPath } from "./appPaths.js";
+import { getLegacyStateDbPath, getStateDir } from "./appPaths.js";
 import { generateBindingCode } from "./bindingCodes.js";
 import { PLAINTEXT_TOKEN_FALLBACK_ENV, SecretStore, } from "./secrets.js";
 const MAC_CODEX_BIN = "/Applications/Codex.app/Contents/Resources/codex";
 export async function bootstrapRuntime() {
     intro("telecodex");
-    const dbPath = getStateDbPath();
-    const db = openDatabase(dbPath);
-    const store = new SessionStore(db);
-    const projects = new ProjectStore(db);
+    const stateDir = getStateDir();
+    const storage = new FileStateStorage(stateDir);
+    migrateLegacySqliteState({
+        storage,
+        legacyDbPath: getLegacyStateDbPath(),
+    });
+    const store = new SessionStore(storage);
+    const projects = new ProjectStore(storage);
     const secrets = new SecretStore(store, {
         allowPlaintextFallback: process.env[PLAINTEXT_TOKEN_FALLBACK_ENV] === "1",
     });
@@ -30,7 +35,6 @@ export async function bootstrapRuntime() {
     const config = buildConfig({
         telegramBotToken: token,
         defaultCwd: process.cwd(),
-        dbPath,
         codexBin,
     });
     let bootstrapCode = null;

package/dist/runtime/startTelecodex.js

@@ -1,5 +1,6 @@
 import { run } from "@grammyjs/runner";
 import { createBot } from "../bot/createBot.js";
+import { CodexSessionCatalog } from "../codex/sessionCatalog.js";
 import { CodexSdkRuntime } from "../codex/sdkRuntime.js";
 import { bootstrapRuntime } from "./bootstrap.js";
 import { acquireInstanceLock } from "./instanceLock.js";
@@ -29,11 +30,15 @@ export async function startTelecodex() {
             logger: logger.child("codex-sdk"),
             ...(configOverrides ? { configOverrides } : {}),
         });
+        const threadCatalog = new CodexSessionCatalog({
+            logger: logger.child("codex-sessions"),
+        });
         const bot = createBot({
             config,
             store,
             projects,
             codex,
+            threadCatalog,
             bootstrapCode,
             logger: logger.child("bot"),
             onAdminBound: () => {