telecodex 0.1.2 → 0.1.4

package/dist/bot/handlers/operationalHandlers.js

@@ -2,34 +2,37 @@ import { presetFromProfile } from "../../config.js";
 import { generateBindingCode } from "../../runtime/bindingCodes.js";
 import { formatSessionRuntimeStatus } from "../../runtime/sessionRuntime.js";
 import { refreshSessionIfActiveTurnIsStale } from "../inputService.js";
-import { contextLogFields, formatHelpText, formatPrivateStatus, formatProjectStatus, formatReasoningEffort, getProjectForContext, getScopedSession, hasTopicContext, isPrivateChat, parseSubcommand, } from "../commandSupport.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";
 export function registerOperationalHandlers(deps) {
     const { bot, config, store, projects, codex, logger } = deps;
     bot.command(["start", "help"], async (ctx) => {
-        await ctx.reply(formatHelpText(ctx, projects));
+        await replyNotice(ctx, formatHelpText(ctx, projects));
     });
     bot.command("admin", async (ctx) => {
         if (!isPrivateChat(ctx)) {
-            await ctx.reply("Use /admin in the bot private chat.");
+            await replyNotice(ctx, "Use /admin in the bot private chat.");
             return;
         }
         const authorizedUserId = store.getAuthorizedUserId();
         if (authorizedUserId == null) {
-            await ctx.reply("Admin binding is not completed yet.");
+            await replyNotice(ctx, "Admin binding is not completed yet.");
             return;
         }
         const { command } = parseSubcommand(ctx.match.trim());
         const binding = store.getBindingCodeState();
         if (!command || command === "status") {
-            await ctx.reply([
-                "Admin status",
-                `authorized telegram user id: ${authorizedUserId}`,
-                binding?.mode === "rebind"
-                    ? `pending handoff: active until ${formatIsoTimestamp(binding.expiresAt)} (${binding.maxAttempts - binding.attempts} attempts remaining)`
-                    : "pending handoff: none",
-                "Usage: /admin | /admin rebind | /admin cancel",
-            ].join("\n"));
+            await replyDocument(ctx, {
+                title: "Admin status",
+                fields: [
+                    textField("authorized telegram user id", authorizedUserId),
+                    textField("pending handoff", binding?.mode === "rebind"
+                        ? `active until ${formatIsoTimestamp(binding.expiresAt)} (${binding.maxAttempts - binding.attempts} attempts remaining)`
+                        : "none"),
+                ],
+                footer: "Usage: /admin | /admin rebind | /admin cancel",
+            });
             return;
         }
         if (command === "rebind") {
@@ -38,124 +41,133 @@ export function registerOperationalHandlers(deps) {
                 mode: "rebind",
                 issuedByUserId: authorizedUserId,
             });
-            await ctx.reply([
-                "Admin handoff code created.",
-                `expires at: ${formatIsoTimestamp(next.expiresAt)}`,
-                `max failed attempts: ${next.maxAttempts}`,
-                "",
-                next.code,
-                "",
-                "Send this code from the target Telegram account in this bot's private chat to transfer control.",
-            ].join("\n"));
+            await replyDocument(ctx, {
+                title: "Admin handoff code created.",
+                fields: [
+                    textField("expires at", formatIsoTimestamp(next.expiresAt)),
+                    textField("max failed attempts", next.maxAttempts),
+                    codeField("code", next.code),
+                ],
+                footer: "Send this code from the target Telegram account in this bot's private chat to transfer control.",
+            });
             return;
         }
         if (command === "cancel") {
             if (binding?.mode !== "rebind") {
-                await ctx.reply("No pending admin handoff.");
+                await replyNotice(ctx, "No pending admin handoff.");
                 return;
             }
             store.clearBindingCode();
-            await ctx.reply("Cancelled the pending admin handoff.");
+            await replyNotice(ctx, "Cancelled the pending admin handoff.");
             return;
         }
-        await ctx.reply("Usage: /admin | /admin rebind | /admin cancel");
+        await replyUsage(ctx, "/admin | /admin rebind | /admin cancel");
     });
     bot.command("status", async (ctx) => {
         if (isPrivateChat(ctx)) {
-            await ctx.reply(formatPrivateStatus(store, projects));
+            await replyNotice(ctx, formatPrivateStatus(store, projects));
             return;
         }
         const project = getProjectForContext(ctx, projects);
         if (!project) {
-            await ctx.reply("This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.");
+            await replyNotice(ctx, "This supergroup has no project bound yet.\nRun /project bind <absolute-path> first.");
             return;
         }
         if (!hasTopicContext(ctx)) {
-            await ctx.reply(formatProjectStatus(project));
+            await replyNotice(ctx, formatProjectStatus(project));
             return;
         }
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const latestSession = await refreshSessionIfActiveTurnIsStale(session, store, codex, bot, logger);
         const queueDepth = store.getQueuedInputCount(latestSession.sessionKey);
         const queuedPreview = store.listQueuedInputs(latestSession.sessionKey, 3);
         const activeRun = codex.getActiveRun(latestSession.sessionKey);
-        await ctx.reply([
-            "Status",
-            `project: ${project.name}`,
-            `root: ${project.cwd}`,
-            `thread: ${latestSession.codexThreadId ?? "not created"}`,
-            `state: ${formatSessionRuntimeStatus(latestSession.runtimeStatus)}`,
-            `state detail: ${latestSession.runtimeStatusDetail ?? "none"}`,
-            `state updated: ${formatIsoTimestamp(latestSession.runtimeStatusUpdatedAt)}`,
-            `active turn: ${latestSession.activeTurnId ?? "none"}`,
-            `active run: ${activeRun ? formatIsoTimestamp(activeRun.startedAt) : "none"}`,
-            `active run thread: ${activeRun?.threadId ?? "none"}`,
-            `active run last event: ${activeRun?.lastEventType ?? "none"}`,
-            `active run last update: ${activeRun ? formatIsoTimestamp(activeRun.lastEventAt) : "none"}`,
-            `queue: ${queueDepth}`,
-            `queue next: ${formatQueuedPreview(queuedPreview)}`,
-            `cwd: ${latestSession.cwd}`,
-            `preset: ${presetFromProfile(latestSession)}`,
-            `sandbox: ${latestSession.sandboxMode}`,
-            `approval: ${latestSession.approvalPolicy}`,
-            `network: ${latestSession.networkAccessEnabled ? "on" : "off"}`,
-            `web: ${latestSession.webSearchMode ?? "codex-default"}`,
-            `git check: ${latestSession.skipGitRepoCheck ? "skip" : "enforce"}`,
-            `add dirs: ${latestSession.additionalDirectories.length}`,
-            `schema: ${latestSession.outputSchema ? "set" : "none"}`,
-            `model: ${latestSession.model}`,
-            `effort: ${formatReasoningEffort(latestSession.reasoningEffort)}`,
-        ].join("\n"));
+        await replyDocument(ctx, {
+            title: "Status",
+            fields: [
+                codeField("project", project.name),
+                codeField("root", project.cwd),
+                codeField("thread", latestSession.codexThreadId ?? "not created"),
+                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"),
+                textField("active run last update", activeRun ? formatIsoTimestamp(activeRun.lastEventAt) : "none"),
+                textField("queue", queueDepth),
+                textField("queue next", formatQueuedPreview(queuedPreview)),
+                codeField("cwd", latestSession.cwd),
+                textField("preset", presetFromProfile(latestSession)),
+                textField("sandbox", latestSession.sandboxMode),
+                textField("approval", latestSession.approvalPolicy),
+                textField("network", latestSession.networkAccessEnabled ? "on" : "off"),
+                textField("web", latestSession.webSearchMode ?? "codex-default"),
+                textField("git check", latestSession.skipGitRepoCheck ? "skip" : "enforce"),
+                textField("add dirs", latestSession.additionalDirectories.length),
+                textField("schema", latestSession.outputSchema ? "set" : "none"),
+                textField("model", latestSession.model),
+                textField("effort", formatReasoningEffort(latestSession.reasoningEffort)),
+            ],
+        });
     });
     bot.command("queue", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const { command, args } = parseSubcommand(ctx.match.trim());
         if (!command) {
             const queued = store.listQueuedInputs(session.sessionKey, 5);
             const queueDepth = store.getQueuedInputCount(session.sessionKey);
-            await ctx.reply([
-                "Queue",
-                `state: ${formatSessionRuntimeStatus(session.runtimeStatus)}`,
-                `active turn: ${session.activeTurnId ?? "none"}`,
-                `queue: ${queueDepth}`,
-                queued.length > 0 ? `items:\n${formatQueuedItems(queued)}` : "items: none",
-                "Usage: /queue | /queue drop <id> | /queue clear",
-            ].join("\n"));
+            await replyDocument(ctx, {
+                title: "Queue",
+                fields: [
+                    textField("state", formatSessionRuntimeStatus(session.runtimeStatus)),
+                    codeField("active turn", session.activeTurnId ?? "none"),
+                    textField("queue", queueDepth),
+                ],
+                sections: [
+                    {
+                        title: "Items",
+                        lines: queued.length > 0 ? [formatQueuedItems(queued)] : ["none"],
+                    },
+                ],
+                footer: "Usage: /queue | /queue drop <id> | /queue clear",
+            });
             return;
         }
         if (command === "clear") {
             const removed = store.clearQueuedInputs(session.sessionKey);
-            await ctx.reply(`Cleared the queue and removed ${removed} pending message(s).`);
+            await replyNotice(ctx, `Cleared the queue and removed ${removed} pending message(s).`);
             return;
         }
         if (command === "drop") {
             const id = Number(args);
             if (!Number.isInteger(id) || id <= 0) {
-                await ctx.reply("Usage: /queue drop <id>");
+                await replyUsage(ctx, "/queue drop <id>");
                 return;
             }
             const removed = store.removeQueuedInputForSession(session.sessionKey, id);
-            await ctx.reply(removed ? `Removed queued item #${id}.` : `Queued item #${id} was not found.`);
+            await replyNotice(ctx, removed ? `Removed queued item #${id}.` : `Queued item #${id} was not found.`);
             return;
         }
-        await ctx.reply("Usage: /queue | /queue drop <id> | /queue clear");
+        await replyUsage(ctx, "/queue | /queue drop <id> | /queue clear");
     });
     bot.command("stop", async (ctx) => {
-        const session = getScopedSession(ctx, store, projects, config);
+        const session = await requireScopedSession(ctx, store, projects, config);
         if (!session)
             return;
         const latest = store.get(session.sessionKey) ?? session;
         if (!codex.isRunning(session.sessionKey)) {
-            await ctx.reply("There is no active Codex SDK turn right now.");
+            await replyNotice(ctx, "There is no active Codex SDK turn right now.");
             return;
         }
         try {
             codex.interrupt(session.sessionKey);
-            await ctx.reply("Interrupt requested for the current run. Waiting for Codex SDK to stop.");
+            await replyNotice(ctx, "Interrupt requested for the current run. Waiting for Codex SDK to stop.");
         }
         catch (error) {
             logger?.warn("interrupt turn failed", {
@@ -163,7 +175,7 @@ export function registerOperationalHandlers(deps) {
                 ...sessionLogFields(latest),
                 error,
             });
-            await ctx.reply(`Interrupt failed: ${error instanceof Error ? error.message : String(error)}`);
+            await replyError(ctx, `Interrupt failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     });
 }

package/dist/bot/handlers/projectHandlers.js

@@ -1,6 +1,7 @@
 import path from "node:path";
-import { contextLogFields, ensureTopicSession, formatPrivateProjectList, formatProjectStatus, formatTopicName, getProjectForContext, getScopedSession, hasTopicContext, isPrivateChat, isSupergroupChat, parseSubcommand, postTopicReadyMessage, resolveExistingDirectory, } from "../commandSupport.js";
+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";
 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;
@@ -8,24 +9,24 @@ export function registerProjectHandlers(deps) {
         const { command, args } = parseSubcommand(ctx.match.trim());
         if (isPrivateChat(ctx)) {
             if (!command || command === "list" || command === "status") {
-                await ctx.reply(formatPrivateProjectList(projects));
+                await replyNotice(ctx, formatPrivateProjectList(projects));
                 return;
             }
-            await ctx.reply("Use /project bind inside a supergroup with topics enabled. Private chat is only for admin entry points.");
+            await replyNotice(ctx, "Use /project bind inside a supergroup with topics enabled. Private chat is only for admin entry points.");
             return;
         }
         if (!isSupergroupChat(ctx)) {
-            await ctx.reply("Use telecodex inside a supergroup with forum topics enabled.");
+            await replyNotice(ctx, "Use telecodex inside a supergroup with forum topics enabled.");
             return;
         }
         if (!command || command === "status") {
             const project = getProjectForContext(ctx, projects);
-            await ctx.reply(project ? formatProjectStatus(project) : PROJECT_REQUIRED_MESSAGE);
+            await replyNotice(ctx, project ? formatProjectStatus(project) : PROJECT_REQUIRED_MESSAGE);
             return;
         }
         if (command === "bind") {
             if (!args) {
-                await ctx.reply("Usage: /project bind <absolute-path>");
+                await replyUsage(ctx, "/project bind <absolute-path>");
                 return;
             }
             try {
@@ -39,19 +40,21 @@ export function registerProjectHandlers(deps) {
                     project: project.name,
                     cwd: project.cwd,
                 });
-                const session = getScopedSession(ctx, store, projects, config, { requireTopic: false });
+                const session = await requireScopedSession(ctx, store, projects, config, { requireTopic: false });
                 if (session && session.cwd !== project.cwd) {
                     store.setCwd(session.sessionKey, project.cwd);
                 }
-                await ctx.reply([
-                    "Project binding updated.",
-                    `project: ${project.name}`,
-                    `root: ${project.cwd}`,
-                    "This supergroup now represents one project, and each topic maps to one Codex thread.",
-                ].join("\n"));
+                await replyDocument(ctx, {
+                    title: "Project binding updated.",
+                    fields: [
+                        codeField("project", project.name),
+                        codeField("root", project.cwd),
+                    ],
+                    footer: "This supergroup now represents one project, and each topic maps to one Codex thread.",
+                });
             }
             catch (error) {
-                await ctx.reply(error instanceof Error ? error.message : String(error));
+                await replyError(ctx, error instanceof Error ? error.message : String(error));
             }
             return;
         }
@@ -60,36 +63,36 @@ export function registerProjectHandlers(deps) {
                 ...contextLogFields(ctx),
             });
             projects.remove(String(ctx.chat.id));
-            await ctx.reply("Removed the project binding for this supergroup.");
+            await replyNotice(ctx, "Removed the project binding for this supergroup.");
             return;
         }
-        await ctx.reply("Usage:\n/project\n/project bind <absolute-path>\n/project unbind");
+        await replyUsage(ctx, ["/project", "/project bind <absolute-path>", "/project unbind"]);
     });
     bot.command("thread", async (ctx) => {
         if (isPrivateChat(ctx)) {
-            await ctx.reply("The thread command is only available inside project supergroups.");
+            await replyNotice(ctx, "The thread command is only available inside project supergroups.");
             return;
         }
         const { command, args } = parseSubcommand(ctx.match.trim());
         if (!command) {
             if (hasTopicContext(ctx)) {
-                const session = getScopedSession(ctx, store, projects, config);
+                const session = await requireScopedSession(ctx, store, projects, config);
                 if (!session)
                     return;
-                await ctx.reply([
-                    `Current thread: ${session.codexThreadId ?? "not created"}`,
-                    `state: ${formatSessionRuntimeStatus(session.runtimeStatus)}`,
-                    `state detail: ${session.runtimeStatusDetail ?? "none"}`,
-                    `queue: ${store.getQueuedInputCount(session.sessionKey)}`,
-                    `cwd: ${session.cwd}`,
-                    "Manage threads in this project:",
-                    "/thread list",
-                    "/thread resume <threadId>",
-                    "/thread new <topic-name>",
-                ].join("\n"));
+                await replyDocument(ctx, {
+                    title: "Current thread",
+                    fields: [
+                        codeField("thread", session.codexThreadId ?? "not created"),
+                        textField("state", formatSessionRuntimeStatus(session.runtimeStatus)),
+                        textField("state detail", session.runtimeStatusDetail ?? "none"),
+                        textField("queue", store.getQueuedInputCount(session.sessionKey)),
+                        codeField("cwd", session.cwd),
+                    ],
+                    footer: ["Manage threads in this project:", "/thread list", "/thread resume <threadId>", "/thread new <topic-name>"],
+                });
                 return;
             }
-            await ctx.reply("Usage:\n/thread list\n/thread resume <threadId>\n/thread new <topic-name>");
+            await replyUsage(ctx, ["/thread list", "/thread resume <threadId>", "/thread new <topic-name>"]);
             return;
         }
         if (command === "list") {
@@ -98,7 +101,7 @@ export function registerProjectHandlers(deps) {
         }
         if (command === "resume") {
             if (!args) {
-                await ctx.reply("Usage: /thread resume <threadId>");
+                await replyUsage(ctx, "/thread resume <threadId>");
                 return;
             }
             await resumeThreadIntoTopic(ctx, deps, args);
@@ -108,7 +111,7 @@ export function registerProjectHandlers(deps) {
             await createFreshThreadTopic(ctx, deps, args);
             return;
         }
-        await ctx.reply("Usage:\n/thread list\n/thread resume <threadId>\n/thread new <topic-name>");
+        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;
@@ -128,7 +131,7 @@ async function resumeThreadIntoTopic(ctx, deps, threadId) {
     const { bot, config, store, projects, logger, threadCatalog } = deps;
     const project = getProjectForContext(ctx, projects);
     if (!project) {
-        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        await replyNotice(ctx, PROJECT_REQUIRED_MESSAGE);
         return;
     }
     const thread = await threadCatalog.findProjectThreadById({
@@ -136,12 +139,14 @@ async function resumeThreadIntoTopic(ctx, deps, threadId) {
         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"));
+        await replyDocument(ctx, {
+            title: "Could not find a saved Codex thread with that id under this project.",
+            fields: [
+                codeField("project root", project.cwd),
+                codeField("thread", threadId),
+            ],
+            footer: "Run /thread list to inspect the saved project threads first.",
+        });
         return;
     }
     const topicName = formatTopicName(thread.preview, `Resumed ${thread.id.slice(0, 8)}`);
@@ -161,14 +166,16 @@ async function resumeThreadIntoTopic(ctx, deps, 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: ${thread.id}`,
-        `cwd: ${thread.cwd}`,
-        "Future messages in this topic will continue on that thread through the Codex SDK.",
-    ].join("\n"));
+    await replyDocument(ctx, {
+        title: "Created a topic and bound it to the existing thread id.",
+        fields: [
+            textField("topic", forumTopic.name),
+            textField("topic id", forumTopic.message_thread_id),
+            codeField("thread", thread.id),
+            codeField("cwd", thread.cwd),
+        ],
+        footer: "Future messages in this topic will continue on that thread through the Codex SDK.",
+    });
     await postTopicReadyMessage(bot, session, [
         "This topic is now bound to an existing Codex thread id.",
         `thread: ${thread.id}`,
@@ -179,7 +186,7 @@ async function createFreshThreadTopic(ctx, deps, requestedName) {
     const { bot, config, store, projects, logger } = deps;
     const project = getProjectForContext(ctx, projects);
     if (!project) {
-        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        await replyNotice(ctx, PROJECT_REQUIRED_MESSAGE);
         return;
     }
     const topicName = formatTopicName(requestedName, "New Thread");
@@ -197,12 +204,14 @@ async function createFreshThreadTopic(ctx, deps, requestedName) {
         sessionKey: session.sessionKey,
         topicName: forumTopic.name,
     });
-    await ctx.reply([
-        "Created a new topic.",
-        `topic: ${forumTopic.name}`,
-        `topic id: ${forumTopic.message_thread_id}`,
-        "Your first normal message will start a new Codex SDK thread.",
-    ].join("\n"));
+    await replyDocument(ctx, {
+        title: "Created a new topic.",
+        fields: [
+            textField("topic", forumTopic.name),
+            textField("topic id", forumTopic.message_thread_id),
+        ],
+        footer: "Your first normal message will start a new Codex SDK thread.",
+    });
     await postTopicReadyMessage(bot, session, [
         "New topic created.",
         "Send a message to start a new Codex thread.",
@@ -214,7 +223,7 @@ async function listProjectThreads(ctx, deps) {
     const { projects, store, threadCatalog } = deps;
     const project = getProjectForContext(ctx, projects);
     if (!project) {
-        await ctx.reply(PROJECT_REQUIRED_MESSAGE);
+        await replyNotice(ctx, PROJECT_REQUIRED_MESSAGE);
         return;
     }
     const threads = await threadCatalog.listProjectThreads({
@@ -222,30 +231,35 @@ async function listProjectThreads(ctx, deps) {
         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"));
+        await replyDocument(ctx, {
+            title: "No saved Codex threads were found for this project yet.",
+            fields: [codeField("project root", project.cwd)],
+        });
         return;
     }
-    const lines = [
-        `Saved Codex threads for ${project.name}:`,
-        ...threads.flatMap((thread, index) => {
+    await replyDocument(ctx, {
+        title: "Saved Codex threads",
+        fields: [
+            codeField("project", project.name),
+            codeField("root", project.cwd),
+        ],
+        sections: threads.map((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}`]
-                    : []),
-            ];
+            return {
+                title: `${index + 1}. ${thread.preview}`,
+                fields: [
+                    codeField("id", thread.id),
+                    codeField("resume", `/thread resume ${thread.id}`),
+                    codeField("cwd", relativeCwd),
+                    textField("updated", thread.updatedAt),
+                    textField("source", thread.source ?? "unknown"),
+                    ...(bound
+                        ? [textField("bound", bound.telegramTopicName ?? bound.messageThreadId ?? bound.sessionKey)]
+                        : []),
+                ],
+            };
         }),
-        "",
-        "Resume one with /thread resume <threadId>",
-    ];
-    await ctx.reply(lines.join("\n"));
+        footer: "Copy an id or resume command from the code-formatted fields above.",
+    });
 }