telecodex 0.1.2 → 0.1.4

package/dist/bot/handlers/sessionConfigHandlers.js

@@ -1,299 +1,343 @@
 import { APPROVAL_POLICIES, MODE_PRESETS, REASONING_EFFORTS, SANDBOX_MODES, WEB_SEARCH_MODES, isSessionApprovalPolicy, isSessionModePreset, isSessionReasoningEffort, isSessionSandboxMode, isSessionWebSearchMode, presetFromProfile, profileFromPreset, } from "../../config.js";
-import { assertProjectScopedPath, formatProfileReply, formatReasoningEffort, getProjectForContext, getScopedSession, resolveExistingDirectory, } from "../commandSupport.js";
+import { parseCodexConfigOverrides } from "../../codex/configOverrides.js";
+import { assertProjectScopedPath, formatProfileReply, formatReasoningEffort, getProjectForContext, requireScopedSession, resolveExistingDirectory, } from "../commandSupport.js";
+import { codeField, replyDocument, replyError, replyNotice, replyUsage, textField } from "../../telegram/formatted.js";
 export function registerSessionConfigHandlers(deps) {
-    const { bot, config, store, projects, codex } = deps;
+    registerDirectoryHandlers(deps);
+    registerProfileHandlers(deps);
+    registerExecutionHandlers(deps);
+    registerAdvancedHandlers(deps);
+}
+function registerDirectoryHandlers(deps) {
+    const { bot, config, store, projects } = deps;
     bot.command("cwd", async (ctx) => {
         const project = getProjectForContext(ctx, projects);
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!project || !session)
             return;
         const cwd = ctx.match.trim();
         if (!cwd) {
-            await ctx.reply(`Current directory: ${session.cwd}\nProject root: ${project.cwd}`);
+            await replyCurrentSetting(ctx, "Current directory", [
+                codeField("cwd", session.cwd),
+                codeField("project root", project.cwd),
+            ]);
             return;
         }
         try {
             const allowed = assertProjectScopedPath(cwd, project.cwd);
             store.setCwd(session.sessionKey, allowed);
-            await ctx.reply(`Set cwd:\n${allowed}`);
+            await replyDocument(ctx, {
+                title: "Set cwd",
+                fields: [codeField("cwd", allowed)],
+            });
         }
         catch (error) {
-            await ctx.reply(error instanceof Error ? error.message : String(error));
+            await replyError(ctx, error instanceof Error ? error.message : String(error));
         }
     });
+}
+function registerProfileHandlers(deps) {
+    const { bot, config, store, projects } = deps;
     bot.command("mode", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const preset = ctx.match.trim();
         if (!preset) {
-            await ctx.reply([
-                `Current preset: ${presetFromProfile(session)}`,
-                `sandbox: ${session.sandboxMode}`,
-                `approval: ${session.approvalPolicy}`,
-                `Usage: /mode ${MODE_PRESETS.join("|")}`,
-            ].join("\n"));
+            await replyCurrentSetting(ctx, "Current preset", [
+                textField("preset", presetFromProfile(session)),
+                textField("sandbox", session.sandboxMode),
+                textField("approval", session.approvalPolicy),
+            ], `Usage: /mode ${MODE_PRESETS.join("|")}`);
             return;
         }
         if (!isSessionModePreset(preset)) {
-            await ctx.reply(`Invalid preset.\nUsage: /mode ${MODE_PRESETS.join("|")}`);
+            await replyInvalidValue(ctx, "Invalid preset.", `Usage: /mode ${MODE_PRESETS.join("|")}`);
             return;
         }
         const profile = profileFromPreset(preset);
         store.setSandboxMode(session.sessionKey, profile.sandboxMode);
         store.setApprovalPolicy(session.sessionKey, profile.approvalPolicy);
-        await ctx.reply(formatProfileReply("Preset updated.", profile.sandboxMode, profile.approvalPolicy));
+        await replyNotice(ctx, formatProfileReply("Preset updated.", profile.sandboxMode, profile.approvalPolicy));
     });
     bot.command("sandbox", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const sandboxMode = ctx.match.trim();
         if (!sandboxMode) {
-            await ctx.reply(`Current sandbox: ${session.sandboxMode}\nUsage: /sandbox ${SANDBOX_MODES.join("|")}`);
+            await replyCurrentSetting(ctx, "Current sandbox", [textField("sandbox", session.sandboxMode)], `Usage: /sandbox ${SANDBOX_MODES.join("|")}`);
             return;
         }
         if (!isSessionSandboxMode(sandboxMode)) {
-            await ctx.reply(`Invalid sandbox.\nUsage: /sandbox ${SANDBOX_MODES.join("|")}`);
+            await replyInvalidValue(ctx, "Invalid sandbox.", `Usage: /sandbox ${SANDBOX_MODES.join("|")}`);
             return;
         }
         store.setSandboxMode(session.sessionKey, sandboxMode);
-        await ctx.reply(formatProfileReply("Sandbox updated.", sandboxMode, session.approvalPolicy));
+        await replyNotice(ctx, formatProfileReply("Sandbox updated.", sandboxMode, session.approvalPolicy));
     });
     bot.command("approval", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const approvalPolicy = ctx.match.trim();
         if (!approvalPolicy) {
-            await ctx.reply(`Current approval: ${session.approvalPolicy}\nUsage: /approval ${APPROVAL_POLICIES.join("|")}`);
+            await replyCurrentSetting(ctx, "Current approval", [textField("approval", session.approvalPolicy)], `Usage: /approval ${APPROVAL_POLICIES.join("|")}`);
             return;
         }
         if (!isSessionApprovalPolicy(approvalPolicy)) {
-            await ctx.reply(`Invalid approval policy.\nUsage: /approval ${APPROVAL_POLICIES.join("|")}`);
+            await replyInvalidValue(ctx, "Invalid approval policy.", `Usage: /approval ${APPROVAL_POLICIES.join("|")}`);
             return;
         }
         store.setApprovalPolicy(session.sessionKey, approvalPolicy);
-        await ctx.reply(formatProfileReply("Approval policy updated.", session.sandboxMode, approvalPolicy));
+        await replyNotice(ctx, formatProfileReply("Approval policy updated.", session.sandboxMode, approvalPolicy));
     });
     bot.command("yolo", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const value = ctx.match.trim().toLowerCase();
         if (!value) {
             const enabled = session.sandboxMode === "danger-full-access" && session.approvalPolicy === "never";
-            await ctx.reply(`Current yolo: ${enabled ? "on" : "off"}\nUsage: /yolo on|off`);
+            await replyCurrentSetting(ctx, "Current yolo", [textField("yolo", enabled ? "on" : "off")], "Usage: /yolo on|off");
             return;
         }
         if (value !== "on" && value !== "off") {
-            await ctx.reply("Usage: /yolo on|off");
+            await replyUsage(ctx, "/yolo on|off");
             return;
         }
         const profile = profileFromPreset(value === "on" ? "yolo" : "write");
         store.setSandboxMode(session.sessionKey, profile.sandboxMode);
         store.setApprovalPolicy(session.sessionKey, profile.approvalPolicy);
-        await ctx.reply(formatProfileReply(value === "on" ? "YOLO enabled." : "YOLO disabled. Restored the write preset.", profile.sandboxMode, profile.approvalPolicy));
+        await replyNotice(ctx, formatProfileReply(value === "on" ? "YOLO enabled." : "YOLO disabled. Restored the write preset.", profile.sandboxMode, profile.approvalPolicy));
     });
+}
+function registerExecutionHandlers(deps) {
+    const { bot, config, store, projects } = deps;
     bot.command("model", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const model = ctx.match.trim();
         if (!model) {
-            await ctx.reply(`Current model: ${session.model}`);
+            await replyCurrentSetting(ctx, "Current model", [textField("model", session.model)]);
             return;
         }
         store.setModel(session.sessionKey, model);
-        await ctx.reply(`Set model: ${model}`);
+        await replyNotice(ctx, `Set model: ${model}`);
     });
     bot.command("effort", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const value = ctx.match.trim().toLowerCase();
         if (!value) {
-            await ctx.reply(`Current reasoning effort: ${formatReasoningEffort(session.reasoningEffort)}\nUsage: /effort default|${REASONING_EFFORTS.join("|")}`);
+            await replyCurrentSetting(ctx, "Current reasoning effort", [textField("effort", formatReasoningEffort(session.reasoningEffort))], `Usage: /effort default|${REASONING_EFFORTS.join("|")}`);
             return;
         }
         if (value !== "default" && !isSessionReasoningEffort(value)) {
-            await ctx.reply(`Invalid reasoning effort.\nUsage: /effort default|${REASONING_EFFORTS.join("|")}`);
+            await replyInvalidValue(ctx, "Invalid reasoning effort.", `Usage: /effort default|${REASONING_EFFORTS.join("|")}`);
             return;
         }
-        if (value === "default") {
-            store.setReasoningEffort(session.sessionKey, null);
-        }
-        else {
-            store.setReasoningEffort(session.sessionKey, value);
-        }
-        await ctx.reply(`Set reasoning effort: ${value === "default" ? "codex-default" : value}`);
+        store.setReasoningEffort(session.sessionKey, value === "default" ? null : value);
+        await replyNotice(ctx, `Set reasoning effort: ${value === "default" ? "codex-default" : value}`);
     });
     bot.command("web", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const value = ctx.match.trim().toLowerCase();
         if (!value) {
-            await ctx.reply(`Current web search: ${session.webSearchMode ?? "codex-default"}\nUsage: /web default|${WEB_SEARCH_MODES.join("|")}`);
+            await replyCurrentSetting(ctx, "Current web search", [textField("web", session.webSearchMode ?? "codex-default")], `Usage: /web default|${WEB_SEARCH_MODES.join("|")}`);
             return;
         }
         if (value !== "default" && !isSessionWebSearchMode(value)) {
-            await ctx.reply(`Invalid web search mode.\nUsage: /web default|${WEB_SEARCH_MODES.join("|")}`);
+            await replyInvalidValue(ctx, "Invalid web search mode.", `Usage: /web default|${WEB_SEARCH_MODES.join("|")}`);
             return;
         }
         store.setWebSearchMode(session.sessionKey, value === "default" ? null : value);
-        await ctx.reply(`Set web search: ${value === "default" ? "codex-default" : value}`);
+        await replyNotice(ctx, `Set web search: ${value === "default" ? "codex-default" : value}`);
     });
     bot.command("network", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const value = ctx.match.trim().toLowerCase();
         if (!value) {
-            await ctx.reply(`Current network access: ${session.networkAccessEnabled ? "on" : "off"}\nUsage: /network on|off`);
+            await replyCurrentSetting(ctx, "Current network access", [textField("network", session.networkAccessEnabled ? "on" : "off")], "Usage: /network on|off");
             return;
         }
         if (value !== "on" && value !== "off") {
-            await ctx.reply("Usage: /network on|off");
+            await replyUsage(ctx, "/network on|off");
             return;
         }
         store.setNetworkAccessEnabled(session.sessionKey, value === "on");
-        await ctx.reply(`Set network access: ${value}`);
+        await replyNotice(ctx, `Set network access: ${value}`);
     });
     bot.command("gitcheck", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const value = ctx.match.trim().toLowerCase();
         if (!value) {
-            await ctx.reply(`Current git repo check: ${session.skipGitRepoCheck ? "skip" : "enforce"}\nUsage: /gitcheck skip|enforce`);
+            await replyCurrentSetting(ctx, "Current git repo check", [textField("git check", session.skipGitRepoCheck ? "skip" : "enforce")], "Usage: /gitcheck skip|enforce");
             return;
         }
         if (value !== "skip" && value !== "enforce") {
-            await ctx.reply("Usage: /gitcheck skip|enforce");
+            await replyUsage(ctx, "/gitcheck skip|enforce");
             return;
         }
         store.setSkipGitRepoCheck(session.sessionKey, value === "skip");
-        await ctx.reply(`Set git repo check: ${value}`);
+        await replyNotice(ctx, `Set git repo check: ${value}`);
     });
+}
+function registerAdvancedHandlers(deps) {
+    const { bot, config, store, projects, codex } = deps;
     bot.command("adddir", async (ctx) => {
         const project = getProjectForContext(ctx, projects);
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!project || !session)
             return;
         const [command, ...rest] = ctx.match.trim().split(/\s+/).filter(Boolean);
         const args = rest.join(" ");
         if (!command || command === "list") {
-            await ctx.reply(session.additionalDirectories.length === 0
-                ? "additional directories: none\nUsage: /adddir add <path-inside-project> | /adddir add-external <absolute-path> | /adddir drop <index> | /adddir clear"
-                : [
-                    "additional directories:",
-                    ...session.additionalDirectories.map((directory, index) => `${index + 1}. ${directory}`),
-                    "Usage: /adddir add <path-inside-project> | /adddir add-external <absolute-path> | /adddir drop <index> | /adddir clear",
-                ].join("\n"));
+            await replyDocument(ctx, {
+                title: "Additional directories",
+                ...(session.additionalDirectories.length > 0
+                    ? {
+                        sections: [
+                            {
+                                title: "Directories",
+                                fields: session.additionalDirectories.map((directory, index) => codeField(String(index + 1), directory)),
+                            },
+                        ],
+                    }
+                    : {
+                        fields: [textField("directories", "none")],
+                    }),
+                footer: "Usage: /adddir add <path-inside-project> | /adddir add-external <absolute-path> | /adddir drop <index> | /adddir clear",
+            });
             return;
         }
         if (command === "add") {
             if (!args) {
-                await ctx.reply("Usage: /adddir add <path-inside-project>");
+                await replyUsage(ctx, "/adddir add <path-inside-project>");
                 return;
             }
             try {
                 const directory = assertProjectScopedPath(args, project.cwd);
                 const next = [...session.additionalDirectories.filter((entry) => entry !== directory), directory];
                 store.setAdditionalDirectories(session.sessionKey, next);
-                await ctx.reply(`Added additional directory:\n${directory}`);
+                await replyDocument(ctx, {
+                    title: "Added additional directory",
+                    fields: [codeField("directory", directory)],
+                });
             }
             catch (error) {
-                await ctx.reply(error instanceof Error ? error.message : String(error));
+                await replyError(ctx, error instanceof Error ? error.message : String(error));
             }
             return;
         }
         if (command === "add-external") {
             if (!args) {
-                await ctx.reply("Usage: /adddir add-external <absolute-path>");
+                await replyUsage(ctx, "/adddir add-external <absolute-path>");
                 return;
             }
             try {
                 const directory = resolveExistingDirectory(args);
                 const next = [...session.additionalDirectories.filter((entry) => entry !== directory), directory];
                 store.setAdditionalDirectories(session.sessionKey, next);
-                await ctx.reply([
-                    "Added external additional directory outside the project root.",
-                    directory,
-                    "Codex can now read files there during future runs.",
-                ].join("\n"));
+                await replyDocument(ctx, {
+                    title: "Added external additional directory outside the project root.",
+                    fields: [codeField("directory", directory)],
+                    footer: "Codex can now read files there during future runs.",
+                });
             }
             catch (error) {
-                await ctx.reply(error instanceof Error ? error.message : String(error));
+                await replyError(ctx, error instanceof Error ? error.message : String(error));
             }
             return;
         }
         if (command === "drop") {
             const index = Number(args);
             if (!Number.isInteger(index) || index <= 0 || index > session.additionalDirectories.length) {
-                await ctx.reply("Usage: /adddir drop <index>");
+                await replyUsage(ctx, "/adddir drop <index>");
                 return;
             }
             const next = session.additionalDirectories.filter((_entry, entryIndex) => entryIndex !== index - 1);
             store.setAdditionalDirectories(session.sessionKey, next);
-            await ctx.reply(`Removed additional directory #${index}.`);
+            await replyNotice(ctx, `Removed additional directory #${index}.`);
             return;
         }
         if (command === "clear") {
             store.setAdditionalDirectories(session.sessionKey, []);
-            await ctx.reply("Cleared additional directories.");
+            await replyNotice(ctx, "Cleared additional directories.");
             return;
         }
-        await ctx.reply("Usage: /adddir list | /adddir add <path-inside-project> | /adddir add-external <absolute-path> | /adddir drop <index> | /adddir clear");
+        await replyUsage(ctx, "/adddir list | /adddir add <path-inside-project> | /adddir add-external <absolute-path> | /adddir drop <index> | /adddir clear");
     });
     bot.command("schema", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const raw = ctx.match.trim();
         if (!raw || raw === "show") {
-            await ctx.reply(session.outputSchema ? `Current output schema:\n${session.outputSchema}` : "Current output schema: none\nUsage: /schema set <JSON object> | /schema clear");
+            await replyDocument(ctx, {
+                title: "Current output schema",
+                fields: session.outputSchema
+                    ? [codeField("schema", session.outputSchema)]
+                    : [textField("schema", "none")],
+                footer: "Usage: /schema set <JSON object> | /schema clear",
+            });
             return;
         }
         if (raw === "clear") {
             store.setOutputSchema(session.sessionKey, null);
-            await ctx.reply("Cleared output schema.");
+            await replyNotice(ctx, "Cleared output schema.");
             return;
         }
         if (!raw.startsWith("set ")) {
-            await ctx.reply("Usage: /schema show | /schema set <JSON object> | /schema clear");
+            await replyUsage(ctx, "/schema show | /schema set <JSON object> | /schema clear");
             return;
         }
         try {
             const parsed = JSON.parse(raw.slice(4).trim());
             if (!isPlainObject(parsed)) {
-                await ctx.reply("Output schema must be a JSON object.");
+                await replyError(ctx, "Output schema must be a JSON object.");
                 return;
             }
             const normalized = JSON.stringify(parsed);
             store.setOutputSchema(session.sessionKey, normalized);
-            await ctx.reply(`Set output schema:\n${normalized}`);
+            await replyDocument(ctx, {
+                title: "Set output schema",
+                fields: [codeField("schema", normalized)],
+            });
         }
         catch (error) {
-            await ctx.reply(`Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
+            await replyError(ctx, `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
         }
     });
     bot.command("codexconfig", async (ctx) => {
         const raw = ctx.match.trim();
         if (!raw || raw === "show") {
             const current = store.getAppState("codex_config_overrides");
-            await ctx.reply(current ? `Current Codex config overrides:\n${current}` : "Current Codex config overrides: none\nUsage: /codexconfig set <JSON object> | /codexconfig clear");
+            await replyDocument(ctx, {
+                title: "Current Codex config overrides",
+                fields: current
+                    ? [codeField("config", current)]
+                    : [textField("config", "none")],
+                footer: "Usage: /codexconfig set <JSON object> | /codexconfig clear",
+            });
             return;
         }
         if (raw === "clear") {
             store.deleteAppState("codex_config_overrides");
             codex.setConfigOverrides(undefined);
-            await ctx.reply("Cleared Codex config overrides. They will apply to future runs.");
+            await replyNotice(ctx, "Cleared Codex config overrides. They will apply to future runs.");
             return;
         }
         if (!raw.startsWith("set ")) {
-            await ctx.reply("Usage: /codexconfig show | /codexconfig set <JSON object> | /codexconfig clear");
+            await replyUsage(ctx, "/codexconfig show | /codexconfig set <JSON object> | /codexconfig clear");
             return;
         }
         try {
@@ -301,40 +345,26 @@ export function registerSessionConfigHandlers(deps) {
             const serialized = JSON.stringify(configOverrides);
             store.setAppState("codex_config_overrides", serialized);
             codex.setConfigOverrides(configOverrides);
-            await ctx.reply(`Set Codex config overrides. They will apply to future runs.\n${serialized}`);
+            await replyDocument(ctx, {
+                title: "Set Codex config overrides. They will apply to future runs.",
+                fields: [codeField("config", serialized)],
+            });
         }
         catch (error) {
-            await ctx.reply(error instanceof Error ? error.message : String(error));
+            await replyError(ctx, error instanceof Error ? error.message : String(error));
         }
     });
 }
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function parseCodexConfigOverrides(raw) {
-    const parsed = JSON.parse(raw);
-    if (!isPlainObject(parsed)) {
-        throw new Error("Codex config overrides must be a JSON object.");
-    }
-    assertCodexConfigValue(parsed, "config");
-    return parsed;
+async function replyCurrentSetting(ctx, title, fields, footer) {
+    await replyDocument(ctx, {
+        title,
+        fields,
+        ...(footer ? { footer } : {}),
+    });
 }
-function assertCodexConfigValue(value, path) {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
-        return;
-    if (Array.isArray(value)) {
-        for (let index = 0; index < value.length; index += 1) {
-            assertCodexConfigValue(value[index], `${path}[${index}]`);
-        }
-        return;
-    }
-    if (isPlainObject(value)) {
-        for (const [key, child] of Object.entries(value)) {
-            if (!key)
-                throw new Error("Codex config override key cannot be empty.");
-            assertCodexConfigValue(child, `${path}.${key}`);
-        }
-        return;
-    }
-    throw new Error(`${path} may only contain string, number, boolean, array, or object values.`);
+async function replyInvalidValue(ctx, message, usage) {
+    await replyError(ctx, message, usage);
 }

package/dist/bot/inputService.js

@@ -1,5 +1,5 @@
 import { applySessionRuntimeEvent } from "../runtime/sessionRuntime.js";
-import { sendPlainChunks } from "../telegram/delivery.js";
+import { sendReplyNotice } from "../telegram/formatted.js";
 import { isAbortError } from "../codex/sdkRuntime.js";
 import { numericChatId, numericMessageThreadId } from "./session.js";
 import { describeBusyStatus, formatIsoTimestamp, isSessionBusy, sessionBufferKey, sessionLogFields, truncateSingleLine, } from "./sessionFlow.js";
@@ -28,16 +28,15 @@ export async function handleUserInput(input) {
         }
         const queued = store.enqueueInput(session.sessionKey, prompt);
         const queueDepth = store.getQueuedInputCount(session.sessionKey);
-        await sendPlainChunks(bot, {
+        await sendReplyNotice(bot, {
             chatId: numericChatId(session),
             messageThreadId: numericMessageThreadId(session),
-            text: [
-                `The current Codex task is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
-                `queue position: ${queueDepth}`,
-                `queued at: ${formatIsoTimestamp(queued.createdAt)}`,
-                "It will be processed automatically after the current run finishes.",
-            ].join("\n"),
-        }, logger);
+        }, [
+            `The current Codex task is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
+            `queue position: ${queueDepth}`,
+            `queued at: ${formatIsoTimestamp(queued.createdAt)}`,
+            "It will be processed automatically after the current run finishes.",
+        ], logger);
         return {
             status: "queued",
             consumed: true,
@@ -138,11 +137,10 @@ export async function recoverActiveTopicSessions(store, codex, _buffers, bot, lo
     });
     for (const session of sessions) {
         const refreshed = await refreshSessionIfActiveTurnIsStale(session, store, codex, bot, logger);
-        await sendPlainChunks(bot, {
+        await sendReplyNotice(bot, {
             chatId: numericChatId(refreshed),
             messageThreadId: numericMessageThreadId(refreshed),
-            text: "telecodex restarted and cannot resume the previous streamed run state. Send the message again if you want to continue.",
-        }, logger).catch((error) => {
+        }, "telecodex restarted and cannot resume the previous streamed run state. Send the message again if you want to continue.", logger).catch((error) => {
             logger?.warn("failed to notify session about stale sdk recovery", {
                 ...sessionLogFields(refreshed),
                 error,
@@ -199,7 +197,7 @@ async function runSessionPrompt(input) {
                 networkAccessEnabled: session.networkAccessEnabled,
                 skipGitRepoCheck: session.skipGitRepoCheck,
                 additionalDirectories: session.additionalDirectories,
-                outputSchema: parseOutputSchema(session.outputSchema),
+                outputSchema: readOutputSchema(session, store, logger),
             },
             prompt: toSdkInput(prompt),
             callbacks: {
@@ -368,5 +366,23 @@ function toSdkInput(input) {
 function parseOutputSchema(value) {
     if (!value)
         return undefined;
-    return JSON.parse(value);
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`Invalid stored output schema: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function readOutputSchema(session, store, logger) {
+    try {
+        return parseOutputSchema(session.outputSchema);
+    }
+    catch (error) {
+        store.setOutputSchema(session.sessionKey, null);
+        logger?.warn("cleared invalid stored output schema", {
+            ...sessionLogFields(session),
+            error,
+        });
+        return undefined;
+    }
 }

package/dist/codex/configOverrides.js

@@ -0,0 +1,50 @@
+export function parseCodexConfigOverrides(raw) {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+        throw new Error("Codex config overrides must be a JSON object.");
+    }
+    assertCodexConfigValue(parsed, "config");
+    return parsed;
+}
+export function tryParseCodexConfigOverrides(raw) {
+    if (!raw) {
+        return {
+            value: undefined,
+            error: null,
+        };
+    }
+    try {
+        return {
+            value: parseCodexConfigOverrides(raw),
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            value: undefined,
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
+}
+function assertCodexConfigValue(value, path) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return;
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            assertCodexConfigValue(value[index], `${path}[${index}]`);
+        }
+        return;
+    }
+    if (isPlainObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            if (!key)
+                throw new Error("Codex config override key cannot be empty.");
+            assertCodexConfigValue(child, `${path}.${key}`);
+        }
+        return;
+    }
+    throw new Error(`${path} may only contain string, number, boolean, array, or object values.`);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}