telecodex 0.1.4 → 0.1.6

package/dist/bot/handlers/messageHandlers.js

@@ -2,9 +2,10 @@ import { contextLogFields, requireScopedSession, } from "../commandSupport.js";
 import { handleUserInput, handleUserText } from "../inputService.js";
 import { telegramImageMessageToCodexInput } from "../../telegram/attachments.js";
 import { replyError, replyNotice } from "../../telegram/formatted.js";
+import { wrapUserFacingHandler } from "../userFacingErrors.js";
 export function registerMessageHandlers(deps) {
     const { bot, config, store, projects, codex, buffers, logger } = deps;
-    bot.on("message:text", async (ctx) => {
+    bot.on("message:text", wrapUserFacingHandler("message:text", logger, async (ctx) => {
         const text = ctx.message.text;
         logger?.info("received telegram text message", {
             ...contextLogFields(ctx),
@@ -30,8 +31,8 @@ export function registerMessageHandlers(deps) {
             bot,
             ...(logger ? { logger } : {}),
         });
-    });
-    bot.on(["message:photo", "message:document"], async (ctx) => {
+    }));
+    bot.on(["message:photo", "message:document"], wrapUserFacingHandler("message:attachment", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session) {
             logger?.warn("ignored telegram attachment because no scoped session was available", {
@@ -68,5 +69,5 @@ export function registerMessageHandlers(deps) {
             });
             await replyError(ctx, error instanceof Error ? error.message : String(error));
         }
-    });
+    }));
 }

package/dist/bot/handlers/operationalHandlers.js

@@ -5,12 +5,13 @@ import { refreshSessionIfActiveTurnIsStale } from "../inputService.js";
 import { contextLogFields, formatHelpText, formatPrivateStatus, formatProjectStatus, formatReasoningEffort, getProjectForContext, hasTopicContext, isPrivateChat, parseSubcommand, requireScopedSession, } from "../commandSupport.js";
 import { formatIsoTimestamp, sessionLogFields } from "../sessionFlow.js";
 import { codeField, replyDocument, replyError, replyNotice, replyUsage, textField } from "../../telegram/formatted.js";
+import { wrapUserFacingHandler } from "../userFacingErrors.js";
 export function registerOperationalHandlers(deps) {
     const { bot, config, store, projects, codex, logger } = deps;
-    bot.command(["start", "help"], async (ctx) => {
+    bot.command(["start", "help"], wrapUserFacingHandler("help", logger, async (ctx) => {
         await replyNotice(ctx, formatHelpText(ctx, projects));
-    });
-    bot.command("admin", async (ctx) => {
+    }));
+    bot.command("admin", wrapUserFacingHandler("admin", logger, async (ctx) => {
         if (!isPrivateChat(ctx)) {
             await replyNotice(ctx, "Use /admin in the bot private chat.");
             return;
@@ -62,8 +63,8 @@ export function registerOperationalHandlers(deps) {
             return;
         }
         await replyUsage(ctx, "/admin | /admin rebind | /admin cancel");
-    });
-    bot.command("status", async (ctx) => {
+    }));
+    bot.command("status", wrapUserFacingHandler("status", logger, async (ctx) => {
         if (isPrivateChat(ctx)) {
             await replyNotice(ctx, formatPrivateStatus(store, projects));
             return;
@@ -93,7 +94,6 @@ export function registerOperationalHandlers(deps) {
                 textField("state", formatSessionRuntimeStatus(latestSession.runtimeStatus)),
                 textField("state detail", latestSession.runtimeStatusDetail ?? "none"),
                 textField("state updated", formatIsoTimestamp(latestSession.runtimeStatusUpdatedAt)),
-                codeField("active turn", latestSession.activeTurnId ?? "none"),
                 textField("active run", activeRun ? formatIsoTimestamp(activeRun.startedAt) : "none"),
                 codeField("active run thread", activeRun?.threadId ?? "none"),
                 textField("active run last event", activeRun?.lastEventType ?? "none"),
@@ -113,8 +113,8 @@ export function registerOperationalHandlers(deps) {
                 textField("effort", formatReasoningEffort(latestSession.reasoningEffort)),
             ],
         });
-    });
-    bot.command("queue", async (ctx) => {
+    }));
+    bot.command("queue", wrapUserFacingHandler("queue", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -126,7 +126,6 @@ export function registerOperationalHandlers(deps) {
                 title: "Queue",
                 fields: [
                     textField("state", formatSessionRuntimeStatus(session.runtimeStatus)),
-                    codeField("active turn", session.activeTurnId ?? "none"),
                     textField("queue", queueDepth),
                 ],
                 sections: [
@@ -155,8 +154,8 @@ export function registerOperationalHandlers(deps) {
             return;
         }
         await replyUsage(ctx, "/queue | /queue drop <id> | /queue clear");
-    });
-    bot.command("stop", async (ctx) => {
+    }));
+    bot.command("stop", wrapUserFacingHandler("stop", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -177,7 +176,7 @@ export function registerOperationalHandlers(deps) {
             });
             await replyError(ctx, `Interrupt failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-    });
+    }));
 }
 function formatQueuedPreview(items) {
     if (items.length === 0)

package/dist/bot/handlers/projectHandlers.js

@@ -2,10 +2,11 @@ import path from "node:path";
 import { contextLogFields, ensureTopicSession, formatPrivateProjectList, formatProjectStatus, formatTopicName, getProjectForContext, hasTopicContext, isPrivateChat, isSupergroupChat, parseSubcommand, postTopicReadyMessage, requireScopedSession, resolveExistingDirectory, } from "../commandSupport.js";
 import { formatSessionRuntimeStatus } from "../../runtime/sessionRuntime.js";
 import { codeField, replyDocument, replyError, replyNotice, replyUsage, textField } from "../../telegram/formatted.js";
+import { wrapUserFacingHandler } from "../userFacingErrors.js";
 const PROJECT_REQUIRED_MESSAGE = "This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.";
 export function registerProjectHandlers(deps) {
     const { bot, config, store, projects, logger } = deps;
-    bot.command("project", async (ctx) => {
+    bot.command("project", wrapUserFacingHandler("project", logger, async (ctx) => {
         const { command, args } = parseSubcommand(ctx.match.trim());
         if (isPrivateChat(ctx)) {
             if (!command || command === "list" || command === "status") {
@@ -67,8 +68,8 @@ export function registerProjectHandlers(deps) {
             return;
         }
         await replyUsage(ctx, ["/project", "/project bind <absolute-path>", "/project unbind"]);
-    });
-    bot.command("thread", async (ctx) => {
+    }));
+    bot.command("thread", wrapUserFacingHandler("thread", logger, async (ctx) => {
         if (isPrivateChat(ctx)) {
             await replyNotice(ctx, "The thread command is only available inside project supergroups.");
             return;
@@ -112,7 +113,7 @@ export function registerProjectHandlers(deps) {
             return;
         }
         await replyUsage(ctx, ["/thread list", "/thread resume <threadId>", "/thread new <topic-name>"]);
-    });
+    }));
     bot.on(["message:forum_topic_created", "message:forum_topic_edited"], async (ctx) => {
         const threadId = ctx.message.message_thread_id;
         if (threadId == null)

package/dist/bot/handlers/sessionConfigHandlers.js

@@ -2,6 +2,7 @@ import { APPROVAL_POLICIES, MODE_PRESETS, REASONING_EFFORTS, SANDBOX_MODES, WEB_
 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";
+import { wrapUserFacingHandler } from "../userFacingErrors.js";
 export function registerSessionConfigHandlers(deps) {
     registerDirectoryHandlers(deps);
     registerProfileHandlers(deps);
@@ -9,8 +10,8 @@ export function registerSessionConfigHandlers(deps) {
     registerAdvancedHandlers(deps);
 }
 function registerDirectoryHandlers(deps) {
-    const { bot, config, store, projects } = deps;
-    bot.command("cwd", async (ctx) => {
+    const { bot, config, store, projects, logger } = deps;
+    bot.command("cwd", wrapUserFacingHandler("cwd", logger, async (ctx) => {
         const project = getProjectForContext(ctx, projects);
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!project || !session)
@@ -34,11 +35,11 @@ function registerDirectoryHandlers(deps) {
         catch (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 { bot, config, store, projects, logger } = deps;
+    bot.command("mode", wrapUserFacingHandler("mode", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -59,8 +60,8 @@ function registerProfileHandlers(deps) {
         store.setSandboxMode(session.sessionKey, profile.sandboxMode);
         store.setApprovalPolicy(session.sessionKey, profile.approvalPolicy);
         await replyNotice(ctx, formatProfileReply("Preset updated.", profile.sandboxMode, profile.approvalPolicy));
-    });
-    bot.command("sandbox", async (ctx) => {
+    }));
+    bot.command("sandbox", wrapUserFacingHandler("sandbox", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -75,8 +76,8 @@ function registerProfileHandlers(deps) {
         }
         store.setSandboxMode(session.sessionKey, sandboxMode);
         await replyNotice(ctx, formatProfileReply("Sandbox updated.", sandboxMode, session.approvalPolicy));
-    });
-    bot.command("approval", async (ctx) => {
+    }));
+    bot.command("approval", wrapUserFacingHandler("approval", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -91,8 +92,8 @@ function registerProfileHandlers(deps) {
         }
         store.setApprovalPolicy(session.sessionKey, approvalPolicy);
         await replyNotice(ctx, formatProfileReply("Approval policy updated.", session.sandboxMode, approvalPolicy));
-    });
-    bot.command("yolo", async (ctx) => {
+    }));
+    bot.command("yolo", wrapUserFacingHandler("yolo", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -110,11 +111,11 @@ function registerProfileHandlers(deps) {
         store.setSandboxMode(session.sessionKey, profile.sandboxMode);
         store.setApprovalPolicy(session.sessionKey, 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 { bot, config, store, projects, logger } = deps;
+    bot.command("model", wrapUserFacingHandler("model", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -125,8 +126,8 @@ function registerExecutionHandlers(deps) {
         }
         store.setModel(session.sessionKey, model);
         await replyNotice(ctx, `Set model: ${model}`);
-    });
-    bot.command("effort", async (ctx) => {
+    }));
+    bot.command("effort", wrapUserFacingHandler("effort", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -141,8 +142,8 @@ function registerExecutionHandlers(deps) {
         }
         store.setReasoningEffort(session.sessionKey, value === "default" ? null : value);
         await replyNotice(ctx, `Set reasoning effort: ${value === "default" ? "codex-default" : value}`);
-    });
-    bot.command("web", async (ctx) => {
+    }));
+    bot.command("web", wrapUserFacingHandler("web", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -157,8 +158,8 @@ function registerExecutionHandlers(deps) {
         }
         store.setWebSearchMode(session.sessionKey, value === "default" ? null : value);
         await replyNotice(ctx, `Set web search: ${value === "default" ? "codex-default" : value}`);
-    });
-    bot.command("network", async (ctx) => {
+    }));
+    bot.command("network", wrapUserFacingHandler("network", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -173,8 +174,8 @@ function registerExecutionHandlers(deps) {
         }
         store.setNetworkAccessEnabled(session.sessionKey, value === "on");
         await replyNotice(ctx, `Set network access: ${value}`);
-    });
-    bot.command("gitcheck", async (ctx) => {
+    }));
+    bot.command("gitcheck", wrapUserFacingHandler("gitcheck", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -189,11 +190,11 @@ function registerExecutionHandlers(deps) {
         }
         store.setSkipGitRepoCheck(session.sessionKey, value === "skip");
         await replyNotice(ctx, `Set git repo check: ${value}`);
-    });
+    }));
 }
 function registerAdvancedHandlers(deps) {
-    const { bot, config, store, projects, codex } = deps;
-    bot.command("adddir", async (ctx) => {
+    const { bot, config, store, projects, codex, logger } = deps;
+    bot.command("adddir", wrapUserFacingHandler("adddir", logger, async (ctx) => {
         const project = getProjectForContext(ctx, projects);
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!project || !session)
@@ -275,8 +276,8 @@ function registerAdvancedHandlers(deps) {
             return;
         }
         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) => {
+    }));
+    bot.command("schema", wrapUserFacingHandler("schema", logger, async (ctx) => {
         const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
@@ -316,8 +317,8 @@ function registerAdvancedHandlers(deps) {
         catch (error) {
             await replyError(ctx, `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`);
         }
-    });
-    bot.command("codexconfig", async (ctx) => {
+    }));
+    bot.command("codexconfig", wrapUserFacingHandler("codexconfig", logger, async (ctx) => {
         const raw = ctx.match.trim();
         if (!raw || raw === "show") {
             const current = store.getAppState("codex_config_overrides");
@@ -353,7 +354,7 @@ function registerAdvancedHandlers(deps) {
         catch (error) {
             await replyError(ctx, error instanceof Error ? error.message : String(error));
         }
-    });
+    }));
 }
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/bot/inputService.js

@@ -32,7 +32,7 @@ export async function handleUserInput(input) {
             chatId: numericChatId(session),
             messageThreadId: numericMessageThreadId(session),
         }, [
-            `The current Codex task is still ${describeBusyStatus(session.runtimeStatus)}. Your message was added to the queue.`,
+            `Codex 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.",
@@ -48,7 +48,7 @@ export async function handleUserInput(input) {
         sessionKey: session.sessionKey,
         event: {
             type: "turn.preparing",
-            detail: "starting codex sdk run",
+            detail: "waiting for first Codex SDK event",
         },
         logger,
     });
@@ -78,17 +78,6 @@ export async function handleUserInput(input) {
         };
     }
     store.setOutputMessage(session.sessionKey, outputMessageId);
-    const turnId = createLocalTurnId();
-    await applySessionRuntimeEvent({
-        bot,
-        store,
-        sessionKey: session.sessionKey,
-        event: {
-            type: "turn.started",
-            turnId,
-        },
-        logger,
-    });
     void runSessionPrompt({
         sessionKey: session.sessionKey,
         prompt,
@@ -96,7 +85,6 @@ export async function handleUserInput(input) {
         codex,
         buffers,
         bot,
-        turnId,
         bufferKey,
         ...(logger ? { logger } : {}),
     });
@@ -118,7 +106,6 @@ export async function refreshSessionIfActiveTurnIsStale(session, store, codex, b
         sessionKey: latest.sessionKey,
         event: {
             type: "turn.failed",
-            turnId: latest.activeTurnId,
             message: "The previous run was lost. Send the message again.",
         },
         logger,
@@ -179,10 +166,13 @@ export async function processNextQueuedInputForSession(sessionKey, store, codex,
     }
 }
 async function runSessionPrompt(input) {
-    const { sessionKey, prompt, store, codex, buffers, bot, turnId, bufferKey, logger } = input;
+    const { sessionKey, prompt, store, codex, buffers, bot, bufferKey, logger } = input;
     const session = store.get(sessionKey);
     if (!session)
         return;
+    logger?.info("starting codex sdk run", {
+        ...sessionLogFields(session),
+    });
     try {
         const result = await codex.run({
             profile: {
@@ -203,8 +193,19 @@ async function runSessionPrompt(input) {
             callbacks: {
                 onThreadStarted: async (threadId) => {
                     store.bindThread(sessionKey, threadId);
+                    logger?.info("codex sdk thread started", {
+                        sessionKey,
+                        threadId,
+                    });
                 },
                 onEvent: async (event) => {
+                    await applyRuntimeStateForSdkEvent({
+                        event,
+                        sessionKey,
+                        store,
+                        bot,
+                        logger,
+                    });
                     await projectEventToTelegramBuffer(buffers, bufferKey, event);
                 },
             },
@@ -219,11 +220,14 @@ async function runSessionPrompt(input) {
                 sessionKey,
                 event: {
                     type: "turn.completed",
-                    turnId,
                 },
                 logger,
             });
         }
+        logger?.info("codex sdk run completed", {
+            sessionKey,
+            threadId: result.threadId,
+        });
         await buffers.complete(bufferKey, result.finalResponse || undefined);
     }
     catch (error) {
@@ -237,16 +241,18 @@ async function runSessionPrompt(input) {
                 event: isAbortError(error)
                     ? {
                         type: "turn.interrupted",
-                        turnId,
                     }
                     : {
                         type: "turn.failed",
-                        turnId,
                         message: error instanceof Error ? error.message : String(error),
                     },
                 logger,
             });
         }
+        logger?.warn("codex sdk run failed", {
+            sessionKey,
+            error,
+        });
         if (isAbortError(error)) {
             await buffers.fail(bufferKey, "Current run interrupted.");
         }
@@ -258,13 +264,33 @@ async function runSessionPrompt(input) {
         await processNextQueuedInputForSession(sessionKey, store, codex, buffers, bot, logger);
     }
 }
+async function applyRuntimeStateForSdkEvent(input) {
+    if (input.event.type !== "turn.started") {
+        return;
+    }
+    const session = input.store.get(input.sessionKey);
+    if (!session)
+        return;
+    if (session.runtimeStatus === "running") {
+        return;
+    }
+    await applySessionRuntimeEvent({
+        bot: input.bot,
+        store: input.store,
+        sessionKey: input.sessionKey,
+        event: {
+            type: "turn.started",
+        },
+        logger: input.logger,
+    });
+}
 async function projectEventToTelegramBuffer(buffers, key, event) {
     switch (event.type) {
         case "thread.started":
             buffers.note(key, `thread started: ${event.thread_id}`);
             return;
         case "turn.started":
-            buffers.note(key, "started processing");
+            buffers.markTurnStarted(key);
             return;
         case "turn.completed":
             buffers.note(key, `token usage: in ${event.usage.input_tokens}, out ${event.usage.output_tokens}, cached ${event.usage.cached_input_tokens}`);
@@ -357,9 +383,6 @@ function projectTodoList(buffers, key, item) {
         buffers.setPlan(key, lines.join("\n"));
     }
 }
-function createLocalTurnId() {
-    return `sdk-turn-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
 function toSdkInput(input) {
     return input;
 }

package/dist/bot/sessionFlow.js

@@ -31,11 +31,10 @@ export function sessionLogFields(session) {
         runtimeStatus: session.runtimeStatus,
         runtimeStatusDetail: session.runtimeStatusDetail,
         codexThreadId: session.codexThreadId,
-        activeTurnId: session.activeTurnId,
     };
 }
 export function isSessionBusy(session) {
-    return session.runtimeStatus === "preparing" || session.runtimeStatus === "running" || session.activeTurnId != null;
+    return session.runtimeStatus === "preparing" || session.runtimeStatus === "running";
 }
 export function describeBusyStatus(status) {
     switch (status) {

package/dist/bot/userFacingErrors.js

@@ -0,0 +1,59 @@
+import { GrammyError, HttpError } from "grammy";
+import { replyError } from "../telegram/formatted.js";
+import { contextLogFields } from "./commandSupport.js";
+export function wrapUserFacingHandler(handlerName, logger, handler) {
+    return async (ctx) => {
+        try {
+            await handler(ctx);
+        }
+        catch (error) {
+            logger?.error("telegram handler failed", {
+                handler: handlerName,
+                ...contextLogFields(ctx),
+                error,
+            });
+            await safeReplyError(ctx, describeUserFacingError(error), logger, handlerName, error);
+        }
+    };
+}
+async function safeReplyError(ctx, message, logger, handlerName, originalError) {
+    try {
+        await replyError(ctx, message);
+    }
+    catch (replyFailure) {
+        logger?.error("failed to send telegram handler error reply", {
+            handler: handlerName,
+            ...contextLogFields(ctx),
+            error: replyFailure,
+            originalError,
+        });
+    }
+}
+function describeUserFacingError(error) {
+    if (error instanceof GrammyError) {
+        return describeTelegramError(error);
+    }
+    if (error instanceof HttpError) {
+        return "Telegram request failed before it reached the API. Check the local network and try again.";
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function describeTelegramError(error) {
+    const description = error.description || error.message;
+    const normalized = description.toLowerCase();
+    if (error.method === "createForumTopic") {
+        if (normalized.includes("not enough rights")) {
+            return "Telegram rejected topic creation because the bot lacks permission to create topics. Promote the bot to admin and grant topic management, then try again.";
+        }
+        if (normalized.includes("forum is disabled") ||
+            normalized.includes("chat is not a forum") ||
+            normalized.includes("topics are not enabled")) {
+            return "This supergroup does not currently allow forum topics. Enable topics for the group and try again.";
+        }
+        return `Failed to create the Telegram topic: ${description}`;
+    }
+    return description;
+}

package/dist/codex/sdkRuntime.js

@@ -86,7 +86,12 @@ export class CodexSdkRuntime {
         let finalResponse = "";
         let usage = null;
         let threadId = input.initialThreadId;
-        for await (const event of streamed.events) {
+        const iterator = streamed.events[Symbol.asyncIterator]();
+        while (true) {
+            const next = await iterator.next();
+            if (next.done)
+                break;
+            const event = next.value;
             const activeRun = this.activeRuns.get(input.sessionKey);
             if (activeRun) {
                 activeRun.lastEventAt = new Date().toISOString();

package/dist/runtime/sessionRuntime.js

@@ -13,14 +13,12 @@ export function reduceSessionRuntimeState(session, event, updatedAt = new Date()
                 status: "preparing",
                 detail: event.detail ?? null,
                 updatedAt,
-                activeTurnId: null,
             };
         case "turn.started":
             return {
                 status: "running",
                 detail: null,
                 updatedAt,
-                activeTurnId: event.turnId,
             };
         case "turn.completed":
         case "turn.interrupted":
@@ -28,14 +26,12 @@ export function reduceSessionRuntimeState(session, event, updatedAt = new Date()
                 status: "idle",
                 detail: null,
                 updatedAt,
-                activeTurnId: null,
             };
         case "turn.failed":
             return {
                 status: "failed",
                 detail: event.message?.trim() || null,
                 updatedAt,
-                activeTurnId: null,
             };
     }
 }

package/dist/store/sessions.js

@@ -320,7 +320,6 @@ function mapStoredSession(stored, runtimeState, outputMessageId) {
         status: "idle",
         detail: null,
         updatedAt: stored.updatedAt,
-        activeTurnId: null,
     };
     return {
         ...stored,
@@ -328,7 +327,6 @@ function mapStoredSession(stored, runtimeState, outputMessageId) {
         runtimeStatus: runtime.status,
         runtimeStatusDetail: runtime.detail,
         runtimeStatusUpdatedAt: runtime.updatedAt,
-        activeTurnId: runtime.activeTurnId,
         outputMessageId: outputMessageId ?? null,
     };
 }

package/dist/telegram/delivery.js

@@ -1,13 +1,25 @@
-import { GrammyError } from "grammy";
+import { GrammyError, HttpError } from "grammy";
 import { renderPlainChunksForTelegram } from "./renderer.js";
 import { splitTelegramHtml } from "./splitMessage.js";
 const telegramCooldownByClient = new WeakMap();
+const MAX_TELEGRAM_RETRY_ATTEMPTS = 5;
+const TELEGRAM_NETWORK_RETRY_BASE_MS = 100;
+const TELEGRAM_NETWORK_RETRY_MAX_MS = 1_000;
+const RETRYABLE_NETWORK_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EPIPE",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+]);
 export async function sendHtmlMessage(bot, input, logger) {
     return retryTelegramCall(bot.api, () => bot.api.sendMessage(input.chatId, input.text, {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
-    }), logger, "telegram send rate limited", {
+    }), logger, "telegram send retry scheduled", {
         chatId: input.chatId,
         messageThreadId: input.messageThreadId,
     });
@@ -29,9 +41,11 @@ export async function sendPlainChunks(bot, input, logger) {
 export async function sendTypingAction(bot, input, logger) {
     await retryTelegramCall(bot.api, () => bot.api.sendChatAction(input.chatId, "typing", {
         ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
-    }), logger, "telegram chat action rate limited", {
+    }), logger, "telegram chat action retry scheduled", {
         chatId: input.chatId,
         messageThreadId: input.messageThreadId,
+    }, {
+        allowNetworkRetry: true,
     });
 }
 export async function replaceOrSendHtmlChunks(bot, input, logger) {
@@ -84,9 +98,11 @@ export async function editHtmlMessage(bot, input, logger) {
     await retryTelegramCall(bot.api, () => bot.api.editMessageText(input.chatId, input.messageId, input.text, {
         parse_mode: "HTML",
         link_preview_options: { is_disabled: true },
-    }), logger, "telegram edit rate limited", {
+    }), logger, "telegram edit retry scheduled", {
         chatId: input.chatId,
         messageId: input.messageId,
+    }, {
+        allowNetworkRetry: true,
     });
 }
 export function isMessageNotModifiedError(error) {
@@ -113,29 +129,90 @@ function retryAfterMs(error) {
     }
     return null;
 }
+function retryPlan(error, attempt) {
+    const rateLimitDelayMs = retryAfterMs(error);
+    if (rateLimitDelayMs != null) {
+        return {
+            kind: "rate-limit",
+            delayMs: rateLimitDelayMs + 250,
+        };
+    }
+    if (isRetryableNetworkError(error)) {
+        return {
+            kind: "network",
+            delayMs: Math.min(TELEGRAM_NETWORK_RETRY_BASE_MS * 2 ** attempt, TELEGRAM_NETWORK_RETRY_MAX_MS),
+        };
+    }
+    return null;
+}
 function descriptionOf(error) {
     return typeof error.description === "string" ? error.description : null;
 }
-export async function retryTelegramCall(cooldownKey, operation, logger, message, context) {
+function isRetryableNetworkError(error) {
+    if (!(error instanceof HttpError))
+        return false;
+    return isRetryableNetworkCause(error.error);
+}
+function isRetryableNetworkCause(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return false;
+    }
+    const code = readErrorCode(error);
+    if (code && RETRYABLE_NETWORK_ERROR_CODES.has(code)) {
+        return true;
+    }
+    const message = readErrorMessage(error);
+    if (!message)
+        return false;
+    return (message.includes("socket hang up") ||
+        message.includes("connection reset") ||
+        message.includes("network request failed") ||
+        message.includes("fetch failed") ||
+        message.includes("timed out") ||
+        message.includes("timeout"));
+}
+function readErrorCode(error) {
+    if (typeof error !== "object" || error == null || !("code" in error))
+        return null;
+    const code = error.code;
+    return typeof code === "string" && code ? code : null;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message.toLowerCase();
+    }
+    if (typeof error === "string") {
+        return error.toLowerCase();
+    }
+    return null;
+}
+export async function retryTelegramCall(cooldownKey, operation, logger, message, context, options) {
     for (let attempt = 0;; attempt += 1) {
         await waitForTelegramCooldown(cooldownKey);
         try {
             return await operation();
         }
         catch (error) {
-            const waitMs = retryAfterMs(error);
-            if (waitMs == null || attempt >= 5) {
+            const rateLimitDelayMs = retryAfterMs(error);
+            const retry = options?.allowNetworkRetry === true
+                ? retryPlan(error, attempt)
+                : rateLimitDelayMs == null
+                    ? null
+                    : {
+                        kind: "rate-limit",
+                        delayMs: rateLimitDelayMs + 250,
+                    };
+            if (retry == null || attempt >= MAX_TELEGRAM_RETRY_ATTEMPTS) {
                 throw error;
             }
-            const cooldownMs = waitMs + 250;
             logger?.warn(message, {
                 ...context,
                 attempt: attempt + 1,
-                retryAfterMs: waitMs,
-                sharedCooldownMs: cooldownMs,
+                retryKind: retry.kind,
+                retryDelayMs: retry.delayMs,
                 error,
             });
-            await applyTelegramCooldown(cooldownKey, cooldownMs);
+            await applyTelegramCooldown(cooldownKey, retry.delayMs);
         }
     }
 }

package/dist/telegram/messageBuffer.js

@@ -1,15 +1,20 @@
 import { editHtmlMessage, isMessageNotModifiedError, replaceOrSendHtmlChunks, sendHtmlMessage, sendTypingAction, shouldFallbackToNewMessage, } from "./delivery.js";
 import { renderMarkdownForTelegram, renderPlainChunksForTelegram, renderPlainForTelegram } from "./renderer.js";
-const ACTIVITY_PULSE_INTERVAL_MS = 4_000;
+const DEFAULT_ACTIVITY_PULSE_INTERVAL_MS = 4_000;
+const DEFAULT_ACTIVITY_IDLE_MS = 60_000;
 export class MessageBuffer {
     bot;
     updateIntervalMs;
     logger;
     states = new Map();
-    constructor(bot, updateIntervalMs, logger) {
+    activityPulseIntervalMs;
+    activityIdleMs;
+    constructor(bot, updateIntervalMs, logger, input) {
         this.bot = bot;
         this.updateIntervalMs = updateIntervalMs;
         this.logger = logger;
+        this.activityPulseIntervalMs = input?.activityPulseIntervalMs ?? DEFAULT_ACTIVITY_PULSE_INTERVAL_MS;
+        this.activityIdleMs = input?.activityIdleMs ?? DEFAULT_ACTIVITY_IDLE_MS;
     }
     async create(key, input) {
         const previous = this.states.get(key);
@@ -22,12 +27,13 @@ export class MessageBuffer {
         const message = await sendHtmlMessage(this.bot, {
             chatId: input.chatId,
             messageThreadId: input.messageThreadId,
-            text: "Codex is working...",
+            text: "Starting Codex...",
         }, this.logger);
         const state = {
             chatId: input.chatId,
             messageThreadId: input.messageThreadId,
             messageId: message.message_id,
+            phase: "starting",
             text: "",
             progressLines: [],
             planText: "",
@@ -36,6 +42,7 @@ export class MessageBuffer {
             timer: null,
             activityTimer: null,
             activityInFlight: false,
+            lastActivityAt: Date.now(),
             lastSentText: "",
             queue: Promise.resolve(),
         };
@@ -51,6 +58,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.text = text;
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     note(key, line) {
@@ -68,6 +76,17 @@ export class MessageBuffer {
         if (state.progressLines.length > 8) {
             state.progressLines.splice(0, state.progressLines.length - 8);
         }
+        this.touchActivity(state);
+        this.scheduleFlush(key, state);
+    }
+    markTurnStarted(key) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        if (state.phase === "running")
+            return;
+        state.phase = "running";
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setPlan(key, text) {
@@ -75,6 +94,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.planText = text.trim();
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setReasoningSummary(key, text) {
@@ -82,6 +102,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.reasoningSummaryText = text.trim();
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     setToolOutput(key, text) {
@@ -89,6 +110,7 @@ export class MessageBuffer {
         if (!state)
             return;
         state.toolOutputText = truncateTail(text.replace(/\r/g, "").trim(), 2000);
+        this.touchActivity(state);
         this.scheduleFlush(key, state);
     }
     rename(from, to) {
@@ -144,7 +166,7 @@ export class MessageBuffer {
             const latest = this.states.get(key);
             if (!latest)
                 return;
-            const text = renderPlainForTelegram(truncateForEdit(composePendingText(latest)));
+            const text = renderPlainForTelegram(truncateForEdit(composePendingText(latest), latest.phase));
             if (text === latest.lastSentText)
                 return;
             await this.safeEdit(latest, text);
@@ -193,10 +215,12 @@ export class MessageBuffer {
         }
     }
     startActivityPulse(state) {
+        if (state.activityTimer)
+            return;
         void this.sendActivityPulse(state);
         const timer = setInterval(() => {
             void this.sendActivityPulse(state);
-        }, ACTIVITY_PULSE_INTERVAL_MS);
+        }, this.activityPulseIntervalMs);
         timer.unref?.();
         state.activityTimer = timer;
     }
@@ -207,6 +231,10 @@ export class MessageBuffer {
         state.activityTimer = null;
     }
     async sendActivityPulse(state) {
+        if (Date.now() - state.lastActivityAt >= this.activityIdleMs) {
+            this.stopActivityPulse(state);
+            return;
+        }
         if (state.activityInFlight)
             return;
         state.activityInFlight = true;
@@ -227,6 +255,12 @@ export class MessageBuffer {
             state.activityInFlight = false;
         }
     }
+    touchActivity(state) {
+        state.lastActivityAt = Date.now();
+        if (!state.activityTimer) {
+            this.startActivityPulse(state);
+        }
+    }
     async replaceWithChunks(state, chunks) {
         const messageId = await replaceOrSendHtmlChunks(this.bot, {
             chatId: state.chatId,
@@ -248,13 +282,13 @@ export class MessageBuffer {
         await run;
     }
 }
-function truncateForEdit(text) {
+function truncateForEdit(text, phase) {
     if (text.length <= 3800)
-        return text || "Codex is working...";
+        return text || pendingBanner(phase);
     return `${text.slice(0, 3800)}\n\n...`;
 }
 function composePendingText(state) {
-    const sections = ["Codex is working..."];
+    const sections = [pendingBanner(state.phase)];
     if (state.planText) {
         sections.push(`[Plan]\n${state.planText}`);
     }
@@ -275,6 +309,9 @@ function composePendingText(state) {
     }
     return sections.join("\n\n");
 }
+function pendingBanner(phase) {
+    return phase === "running" ? "Codex is working..." : "Starting Codex...";
+}
 function truncateTail(text, maxLength) {
     if (text.length <= maxLength)
         return text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telecodex",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Telegram bridge for local Codex.",
   "license": "MIT",
   "type": "module",
@@ -52,7 +52,7 @@
     "@grammyjs/parse-mode": "^2.3.0",
     "@grammyjs/runner": "^2.0.3",
     "@napi-rs/keyring": "^1.2.0",
-    "@openai/codex-sdk": "^0.120.0",
+    "@openai/codex-sdk": "^0.121.0",
     "clipboardy": "^4.0.0",
     "grammy": "^1.42.0",
     "markdown-it": "^14.1.0",