pi-telegram-plus 0.0.1 → 0.0.3

package/lib/commands/info.ts

@@ -1,8 +1,83 @@
 import { existsSync } from "node:fs";
 import type { CommandRegistry } from "./register.ts";
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { escapeHtml } from "../html.ts";
-import type { CapturedAgentSession } from "../types.ts";
+import type { CapturedAgentSession, TelegramTransport } from "../types.ts";
+
+function formatFooterLikeTokenCount(value: number): string {
+  if (value < 1_000) return value.toString();
+  if (value < 10_000) return `${(value / 1_000).toFixed(1)}k`;
+  if (value < 1_000_000) return `${Math.round(value / 1_000)}k`;
+  if (value < 10_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(value / 1_000_000)}M`;
+}
+
+const STATUS_TEXT_LIMIT = 200;
+
+function truncateStatusText(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  if (value.length <= STATUS_TEXT_LIMIT) return value;
+  return `${value.slice(0, STATUS_TEXT_LIMIT - 1)}…`;
+}
+
+/**
+ * @internal Exported for tests; not part of the public module API.
+ * Keeps the rendered snapshot under Telegram's 4096-byte (and `splitTelegramText`'s
+ * 3600-byte single-chunk) limit by capping free-form text fields up front.
+ */
+export function buildStatusSnapshot(session: CapturedAgentSession): string {
+  const stats = session.getSessionStats();
+  const usage = session.getContextUsage();
+  const model = session.model;
+  const safeCwd = truncateStatusText(session.sessionManager.getCwd()) ?? "";
+  const safeSessionId = truncateStatusText(stats.sessionId) ?? "";
+  const safeSessionFile = truncateStatusText(stats.sessionFile);
+  const safeSessionName = truncateStatusText(session.sessionManager.getSessionName());
+  const contextWindow = usage?.contextWindow ?? 0;
+  const contextPercent = usage?.percent;
+
+  const stateBadge = session.isStreaming
+    ? "🟢 active"
+    : session.pendingMessageCount > 0
+      ? "🟡 queueing"
+      : "⚪ idle";
+
+  const contextDisplay = contextPercent === null || contextPercent === undefined
+    ? `?/${contextWindow}`
+    : `${contextPercent.toFixed(1)}%/${contextWindow}`;
+
+  // Labels are hard-coded, so escaping is unnecessary; only the value is dynamic.
+  const line = (label: string, value: string): string =>
+    `  <b>${label}</b>  ${escapeHtml(value)}`;
+
+  return [
+    "<b>🛰 TUI Status</b>",
+    "━━━━━━━━━━━━━━━━━━━━",
+    "<b>📂 Workspace</b>",
+    line("cwd", safeCwd),
+    line("session", safeSessionId + (safeSessionName ? ` • ${safeSessionName}` : "")),
+    line("file", safeSessionFile ?? "ephemeral"),
+    "",
+    "<b>🤖 Model</b>",
+    line("model", model ? `${model.provider}/${model.id}` : "(none)"),
+    line("thinking", session.thinkingLevel),
+    line("state", stateBadge),
+    line("queued", String(session.pendingMessageCount)),
+    "",
+    "<b>📊 Context &amp; Tokens</b>",
+    line("context", contextDisplay),
+    line("in", formatFooterLikeTokenCount(stats.tokens.input)),
+    line("out", formatFooterLikeTokenCount(stats.tokens.output)),
+    line("cache R", formatFooterLikeTokenCount(stats.tokens.cacheRead)),
+    line("cache W", formatFooterLikeTokenCount(stats.tokens.cacheWrite)),
+    line("total", formatFooterLikeTokenCount(stats.tokens.total)),
+    line("cost", `$${stats.cost.toFixed(4)}`),
+    "",
+    "<b>💬 Messages</b>",
+    line("user", String(stats.userMessages)),
+    line("assistant", String(stats.assistantMessages)),
+    line("tool calls", String(stats.toolCalls)),
+  ].join("\n");
+}
 
 /**
  * All command handlers capture ctx.ui at entry and use the captured reference.
@@ -10,7 +85,13 @@ import type { CapturedAgentSession } from "../types.ts";
  */
 export function registerInfoCommands(
   registry: CommandRegistry,
-  deps: { getSession: () => CapturedAgentSession | undefined },
+  deps: {
+    getSession: () => CapturedAgentSession | undefined;
+    /** Optional transport for direct sends (bypasses ui.notify wrapping). */
+    getTransport?: () => TelegramTransport | undefined;
+    /** Optional active chat id used for direct sends. */
+    getActiveChatId?: () => number | undefined;
+  },
 ): void {
   // ── /copy ──────────────────────────────────────────────────────────────
   registry.registerCommand("copy", {
@@ -27,6 +108,31 @@ export function registerInfoCommands(
     },
   });
 
+  // ── /status ───────────────────────────────────────────────────────────
+  registry.registerCommand("status", {
+    description: "Show runtime snapshot (workspace, model, context, messages)",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+
+      const html = buildStatusSnapshot(session);
+      const transport = deps.getTransport?.();
+      const chatId = deps.getActiveChatId?.();
+      if (transport && chatId !== undefined) {
+        await transport.sendText(chatId, html).catch(() => {
+          // Fall back to the standard notify path if the direct send fails.
+          ui.notify(html.replace(/<[^>]+>/g, ""), "info");
+        });
+        return;
+      }
+      ui.notify(html, "info");
+    },
+  });
+
   // ── /export ────────────────────────────────────────────────────────────
   registry.registerCommand("export", {
     description: "Export session to HTML or JSONL",

package/lib/commands/register.ts

@@ -1,4 +1,4 @@
-import type { CapturedAgentSession } from "../types.ts";
+import type { CapturedAgentSession, TelegramTransport } from "../types.ts";
 import { registerModelCommands } from "./model.ts";
 import { registerSessionCommands } from "./session.ts";
 import { registerAuthCommands } from "./auth.ts";
@@ -29,12 +29,24 @@ export type TgConfigDeps = SessionDeps & {
   persistConfig: (c: import("../types.ts").TelegramConfig) => Promise<void>;
 };
 
-export function registerAllCommands(registry: CommandRegistry, sessionDeps: SessionDeps, sessionNameDeps: SessionNameDeps, tgConfigDeps?: TgConfigDeps): void {
+/** Optional deps for commands that need to send preformatted HTML directly. */
+export type InfoDeps = {
+  getTransport?: () => TelegramTransport | undefined;
+  getActiveChatId?: () => number | undefined;
+};
+
+export function registerAllCommands(
+  registry: CommandRegistry,
+  sessionDeps: SessionDeps,
+  sessionNameDeps: SessionNameDeps,
+  tgConfigDeps?: TgConfigDeps,
+  infoDeps?: InfoDeps,
+): void {
   registerSettingsCommands(registry, sessionDeps);
   registerModelCommands(registry, sessionDeps);
   registerSessionCommands(registry, sessionNameDeps);
   registerAuthCommands(registry, sessionDeps);
-  registerInfoCommands(registry, sessionDeps);
+  registerInfoCommands(registry, { ...sessionDeps, ...(infoDeps ?? {}) });
   registerLifecycleCommands(registry);
   if (tgConfigDeps) registerTgConfigCommands(registry, tgConfigDeps);
 }

package/lib/commands/session.ts

@@ -5,6 +5,9 @@ import { SessionManager, type SessionEntry } from "@earendil-works/pi-coding-age
 import type { SessionNameDeps, CommandRegistry } from "./register.ts";
 import { escapeHtml } from "../html.ts";
 import type { CapturedAgentSession } from "../types.ts";
+import { log } from "../logger.ts";
+
+const sessionLog = log.child("session");
 
 function truncate(text: string, max: number): string {
   return text.length <= max ? text : text.slice(0, max - 1) + "…";
@@ -187,7 +190,7 @@ export function registerSessionCommands(
       if (!rawPath) return;
 
       const targetCwd = resolveTargetCwd(rawPath, ctx.cwd);
-      const info = await stat(targetCwd).catch(() => undefined);
+      const info = await stat(targetCwd).catch(sessionLog.swallow("debug", "stat target cwd failed (treated as not-a-directory)", { targetCwd }));
       if (!info?.isDirectory()) {
         ui.notify(`Not a directory: ${escapeHtml(targetCwd)}`, "error");
         return;

package/lib/commands/telegram-commands.ts

@@ -1,9 +1,12 @@
 import { resolve } from "node:path";
-import { bindWorkspaceTelegramConfig, readTelegramConfigStore, unbindWorkspaceTelegramConfig } from "../config.ts";
+import { bindWorkspaceTelegramConfig, readTelegramConfigStore, unbindWorkspaceTelegramConfig, writeGlobalTelegramConfig } from "../config.ts";
 import { escapeHtml } from "../html.ts";
 import { getTelegramBotUsername } from "../telegram-api.ts";
 import type { ResolvedTelegramConfig, TelegramConfig, TelegramTransport } from "../types.ts";
 import type { TelegramPollingRuntime } from "../polling.ts";
+import { log } from "../logger.ts";
+
+const tgCmdLog = log.child("tg-commands");
 
 export type TelegramCommandDeps = {
   getConfig: () => TelegramConfig;
@@ -20,82 +23,103 @@ export type TelegramCommandDeps = {
   clearStatusError: () => void;
 };
 
-/** Shared "connect and start" sequence used by both /tg-setup and /tg-connect. */
-async function connectAndStart(
+/** Shared "connect and start" sequence for the global bot. */
+async function globalConnectAndStart(
   deps: TelegramCommandDeps,
   token: string,
   botUsername: string | undefined,
 ): Promise<void> {
   const config = deps.getConfig();
   deps.setConfig({ ...config, botToken: token, botUsername, telegramEnabled: true });
-  await deps.persistConfig(deps.getConfig());
+  await writeGlobalTelegramConfig({ botToken: token, botUsername, telegramEnabled: true });
   deps.getPolling().start();
   await deps.syncTelegramCommands();
   deps.refreshStatus();
 }
 
-export function configureTelegramToken(
+async function configureGlobalTelegramToken(
   ui: { input: (title: string, placeholder?: string) => Promise<string | undefined>; inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> },
   deps: TelegramCommandDeps,
 ): Promise<boolean> {
-  return (async () => {
-    const token = await (ui.inputSecret?.("Telegram bot token") ?? ui.input("Telegram bot token"));
-    if (!token) return false;
-    const botUsername = await getTelegramBotUsername(token).catch(() => undefined);
-    if (!deps.getResolvedConfig()) {
-      deps.switchResolvedConfig({ store: { version: 2, global: {}, workspaces: [] }, scope: "global", config: {} });
+  const token = await (ui.inputSecret?.("Telegram bot token") ?? ui.input("Telegram bot token"));
+  if (!token) return false;
+  const botUsername = await getTelegramBotUsername(token).catch(tgCmdLog.swallow("warn", "getTelegramBotUsername failed during global token setup"));
+  if (!deps.getResolvedConfig()) {
+    deps.switchResolvedConfig({ store: { version: 2, global: {}, workspaces: [] }, scope: "global", config: {} });
+  }
+  await globalConnectAndStart(deps, token, botUsername);
+  return true;
+}
+
+// ── Handler implementations for reuse by aliases ──────────────────────────
+
+async function handleTgGlobalSetup(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
+  if (!(await configureGlobalTelegramToken(ui, deps))) return;
+  deps.clearStatusError();
+  deps.startStatusHeartbeat();
+  ui.notify("Telegram global bot token saved and connected.", "info");
+}
+
+async function handleTgGlobalConnect(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
+  try {
+    if (!deps.getConfig().botToken) {
+      if (!(await configureGlobalTelegramToken(ui, deps))) return;
+    } else {
+      const botUsername = deps.getConfig().botUsername ?? await getTelegramBotUsername(deps.getConfig().botToken!).catch(tgCmdLog.swallow("warn", "getTelegramBotUsername failed during global connect"));
+      await globalConnectAndStart(deps, deps.getConfig().botToken!, botUsername);
     }
-    await connectAndStart(deps, token, botUsername);
-    return true;
-  })();
+  } catch (err) { tgCmdLog.debug("global connect swallowed error (reported via polling onError)", { err }); }
+  deps.clearStatusError();
+  deps.startStatusHeartbeat();
+  ui.notify("Telegram global bot connected.", "info");
+}
+
+async function handleTgGlobalDisconnect(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  await deps.getPolling().stop();
+  const config = deps.getConfig();
+  deps.setConfig({ ...config, telegramEnabled: false });
+  await writeGlobalTelegramConfig({ telegramEnabled: false });
+  deps.clearStatusError();
+  deps.refreshStatus();
+  ctx.ui.notify("Telegram global bot disconnected. Token is kept; use /tg-global-connect to reconnect.", "info");
 }
 
+// ── Registration ──────────────────────────────────────────────────────────
+
 export function registerTelegramCommands(
   registry: { registerCommand: (name: string, options: { description?: string; handler: (args: string, ctx: any) => Promise<void> }) => void },
   deps: TelegramCommandDeps,
 ): void {
-  // ── /tg-setup ─────────────────────────────────────────────────────────
-  registry.registerCommand("tg-setup", {
-    description: "Configure Telegram bot token",
-    handler: async (_args, ctx) => {
-      const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
-      if (!(await configureTelegramToken(ui, deps))) return;
-      deps.clearStatusError();
-      deps.startStatusHeartbeat();
-      ui.notify("Telegram bot token saved and connected.", "info");
-    },
+  // ── /tg-global-setup ──────────────────────────────────────────────────
+  registry.registerCommand("tg-global-setup", {
+    description: "Configure global Telegram bot token and connect",
+    handler: (args, ctx) => handleTgGlobalSetup(args, ctx, deps),
   });
 
-  // ── /tg-connect ───────────────────────────────────────────────────────
-  registry.registerCommand("tg-connect", {
-    description: "Enable/start Telegram connection",
-    handler: async (_args, ctx) => {
-      const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
-      try {
-        if (!deps.getConfig().botToken) {
-          if (!(await configureTelegramToken(ui, deps))) return;
-        } else {
-          const botUsername = deps.getConfig().botUsername ?? await getTelegramBotUsername(deps.getConfig().botToken!).catch(() => undefined);
-          await connectAndStart(deps, deps.getConfig().botToken!, botUsername);
-        }
-      } catch { /* connection errors reported via polling onError */ }
-      deps.clearStatusError();
-      deps.startStatusHeartbeat();
-      ui.notify("Telegram connected.", "info");
-    },
+  // ── /tg-global-connect ────────────────────────────────────────────────
+  registry.registerCommand("tg-global-connect", {
+    description: "Enable/start the global Telegram bot connection",
+    handler: (args, ctx) => handleTgGlobalConnect(args, ctx, deps),
   });
 
-  // ── /tg-disconnect ────────────────────────────────────────────────────
-  registry.registerCommand("tg-disconnect", {
-    description: "Disable/stop Telegram connection without deleting the token",
-    handler: async (_args, ctx) => {
-      await deps.getPolling().stop();
-      deps.setConfig({ ...deps.getConfig(), telegramEnabled: false });
-      await deps.persistConfig(deps.getConfig());
-      deps.clearStatusError();
-      deps.refreshStatus();
-      ctx.ui.notify("Telegram disconnected. Token is kept; use /tg-connect to reconnect.", "info");
-    },
+  // ── /tg-global-disconnect ─────────────────────────────────────────────
+  registry.registerCommand("tg-global-disconnect", {
+    description: "Disable/stop the global Telegram bot without deleting the token",
+    handler: (args, ctx) => handleTgGlobalDisconnect(args, ctx, deps),
   });
 
   // ── /tg-bind-cwd ──────────────────────────────────────────────────────
@@ -107,7 +131,7 @@ export function registerTelegramCommands(
       const workspacePath = resolve(args.trim() || ctx.cwd || process.cwd());
       const token = await (ui.inputSecret?.(`Telegram bot token for ${workspacePath}`) ?? ui.input(`Telegram bot token for ${workspacePath}`));
       if (!token) return;
-      const botUsername = await getTelegramBotUsername(token).catch(() => undefined);
+      const botUsername = await getTelegramBotUsername(token).catch(tgCmdLog.swallow("warn", "getTelegramBotUsername failed during workspace token setup", { workspacePath }));
       await deps.getPolling().stop();
       deps.switchResolvedConfig(await bindWorkspaceTelegramConfig(workspacePath, {
         botToken: token,
@@ -125,6 +149,57 @@ export function registerTelegramCommands(
     },
   });
 
+  // ── /tg-cwd-connect ───────────────────────────────────────────────────
+  registry.registerCommand("tg-cwd-connect", {
+    description: "Enable the Telegram bot for the current directory",
+    handler: async (_args, ctx) => {
+      const previousScope = deps.getResolvedConfig()?.scope;
+      const config = deps.getConfig();
+      // If no bot token is configured at all, prompt user to bind or set up global first
+      if (!config.botToken && !deps.getResolvedConfig()?.store.global?.botToken) {
+        ctx.ui.notify("No Telegram bot configured. Use /tg-global-setup or /tg-bind-cwd first.", "error");
+        return;
+      }
+      // If no token in current scope, try falling back to global
+      if (!config.botToken) {
+        const global = deps.getResolvedConfig()?.store.global;
+        if (global?.botToken) {
+          deps.setConfig({ ...config, botToken: global.botToken, botUsername: global.botUsername });
+        }
+      }
+      deps.setConfig({ ...deps.getConfig(), telegramEnabled: true });
+      await deps.persistConfig(deps.getConfig());
+      await deps.getPolling().stop();
+      if (deps.isTelegramEnabled()) deps.getPolling().start();
+      deps.clearStatusError();
+      deps.startStatusHeartbeat();
+      ctx.ui.notify(`Telegram bot enabled for current scope (${previousScope}).`, "info");
+    },
+  });
+
+  // ── /tg-cwd-disconnect ────────────────────────────────────────────────
+  registry.registerCommand("tg-cwd-disconnect", {
+    description: "Disable the Telegram bot for the current directory",
+    handler: async (_args, ctx) => {
+      const previousScope = deps.getResolvedConfig()?.scope;
+      await deps.getPolling().stop();
+      deps.setConfig({ ...deps.getConfig(), telegramEnabled: false });
+      await deps.persistConfig(deps.getConfig());
+      // If there's a global bot token, switch to it when disabling workspace bot
+      if (previousScope === "workspace") {
+        const global = deps.getResolvedConfig()?.store.global;
+        if (global?.botToken && global?.telegramEnabled !== false) {
+          deps.setConfig({ ...deps.getConfig(), botToken: global.botToken, botUsername: global.botUsername, telegramEnabled: true });
+          await deps.persistConfig(deps.getConfig());
+          deps.getPolling().start();
+        }
+      }
+      deps.clearStatusError();
+      deps.refreshStatus();
+      ctx.ui.notify(`Telegram bot disabled for current scope (${previousScope}).`, "info");
+    },
+  });
+
   // ── /tg-unbind-cwd ────────────────────────────────────────────────────
   registry.registerCommand("tg-unbind-cwd", {
     description: "Remove current directory Telegram bot binding",
@@ -135,7 +210,14 @@ export function registerTelegramCommands(
         return;
       }
       await deps.getPolling().stop();
+      const global = previous.store.global;
       deps.switchResolvedConfig(await unbindWorkspaceTelegramConfig(ctx.cwd || process.cwd()));
+      // Fall back to global bot if it exists and is enabled
+      if (global?.botToken && global?.telegramEnabled !== false) {
+        const newConfig = deps.getConfig();
+        deps.setConfig({ ...newConfig, botToken: global.botToken, botUsername: global.botUsername });
+        await deps.persistConfig(deps.getConfig());
+      }
       if (deps.isTelegramEnabled()) deps.getPolling().start();
       await deps.syncTelegramCommands();
       deps.refreshStatus();
@@ -149,11 +231,14 @@ export function registerTelegramCommands(
     handler: async (_args, ctx) => {
       const store = await readTelegramConfigStore();
       const lines = [
-        `global: ${store.global?.botUsername ? `@${store.global.botUsername}` : store.global?.botToken ? "configured" : "not configured"}`,
+        `global: ${store.global?.botUsername ? `@${store.global.botUsername}` : store.global?.botToken ? "configured" : "not configured"}${store.global?.telegramEnabled === false ? " (disabled)" : store.global?.telegramEnabled ? "" : ""}`,
         "",
         "workspaces:",
         ...((store.workspaces ?? []).length
-          ? (store.workspaces ?? []).map((workspace) => `- ${escapeHtml(workspace.path)}\n  ${workspace.config.botUsername ? `@${workspace.config.botUsername}` : workspace.config.botToken ? "configured" : "not configured"}`)
+          ? (store.workspaces ?? []).map((workspace) => {
+            const status = workspace.config.telegramEnabled === false ? " (disabled)" : "";
+            return `- ${escapeHtml(workspace.path)}\n  ${workspace.config.botUsername ? `@${workspace.config.botUsername}${status}` : workspace.config.botToken ? `configured${status}` : "not configured"}`;
+          })
           : ["none"]),
       ];
       ctx.ui.notify(lines.join("\n"), "info");

package/lib/config.ts

@@ -3,6 +3,9 @@ import { chmod, mkdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/prom
 import { homedir } from "node:os";
 import { join, relative, resolve } from "node:path";
 import type { ResolvedTelegramConfig, TelegramConfig, TelegramConfigStore, TelegramWorkspaceConfig } from "./types.ts";
+import { log } from "./logger.ts";
+
+const configLog = log.child("config");
 
 export function getAgentDir(): string {
   return process.env.PI_CODING_AGENT_DIR
@@ -33,7 +36,7 @@ async function withTelegramConfigLock<T>(run: () => Promise<T>): Promise<T> {
       if (code !== "EEXIST") throw error;
       const age = Date.now() - (await stat(lockPath).then((s) => s.mtimeMs).catch(() => Date.now()));
       if (age > 30_000 || Date.now() - started > 10_000) {
-        await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
+        await rm(lockPath, { recursive: true, force: true }).catch(configLog.swallow("warn", "rm stale config lock failed", { lockPath }));
         continue;
       }
       await sleep(50);
@@ -42,13 +45,13 @@ async function withTelegramConfigLock<T>(run: () => Promise<T>): Promise<T> {
   try {
     return await run();
   } finally {
-    await rmdir(lockPath).catch(() => undefined);
+    await rmdir(lockPath).catch(configLog.swallow("warn", "rmdir config lock failed on release", { lockPath }));
   }
 }
 
 function assertV2Store(value: unknown): TelegramConfigStore {
   if (!value || typeof value !== "object" || (value as { version?: unknown }).version !== 2) {
-    throw new Error("Unsupported Telegram config format. Please recreate ~/.pi/agent/tg.json as version 2 or run /tg-setup.");
+    throw new Error("Unsupported Telegram config format. Please recreate ~/.pi/agent/tg.json as version 2 or run /tg-global-setup.");
   }
   const store = value as TelegramConfigStore;
   return {
@@ -73,7 +76,7 @@ export async function writeTelegramConfigStore(store: TelegramConfigStore): Prom
     workspaces: store.workspaces ?? [],
   };
   await writeFile(path, JSON.stringify(normalized, null, 2) + "\n", { mode: 0o600 });
-  await chmod(path, 0o600).catch(() => undefined);
+  await chmod(path, 0o600).catch(configLog.swallow("warn", "chmod config file failed", { path }));
 }
 
 function normalizePath(path: string): string {
@@ -169,3 +172,15 @@ export async function unbindWorkspaceTelegramConfig(cwd: string): Promise<Resolv
     return resolveTelegramConfigStore(store, cwd);
   });
 }
+
+/**
+ * Update only the global section of the Telegram config store.
+ * Merges with existing global config and preserves lastUpdateId monotonically.
+ */
+export async function writeGlobalTelegramConfig(config: TelegramConfig): Promise<void> {
+  await withTelegramConfigLock(async () => {
+    const store = await readTelegramConfigStore();
+    store.global = mergeTelegramConfigForWrite(store.global, config);
+    await writeTelegramConfigStore(store);
+  });
+}

package/lib/controller.ts

@@ -12,6 +12,9 @@ import type {
   TelegramTurn,
 } from "./types.ts";
 import type { TelegramUiRuntime } from "./telegram-ui.ts";
+import { log } from "./logger.ts";
+
+const ctrlLog = log.child("controller");
 
 export type TelegramController = {
   handleMessage(message: TelegramMessage): Promise<void>;
@@ -221,7 +224,7 @@ export function createTelegramController(deps: {
     const mode = deps.getMessageMode();
     if (mode === "steer") {
       const task = runPrompt(text, chatId, replaceMessageId);
-      void task.catch(() => undefined);
+      void task.catch(ctrlLog.swallow("error", "steer-mode prompt task failed", { chatId }));
       return;
     }
 
@@ -233,7 +236,7 @@ export function createTelegramController(deps: {
         if (generation !== getInterruptGeneration(chatId)) return;
         return runPrompt(text, chatId, replaceMessageId);
       })
-      .catch(() => undefined);
+      .catch(ctrlLog.swallow("error", "queue-mode prompt task failed", { chatId }));
     setTail(chatId, task);
   };
 
@@ -247,11 +250,45 @@ export function createTelegramController(deps: {
     // prompts (e.g. /new confirmation), and awaiting them would stall the
     // polling loop and block callback processing for that update.
     const telegramUi = deps.ui.create(chatId);
+    const ctx = session.extensionRunner.createCommandContext();
+    // Capture idleness BEFORE the handler runs. Commands like /sisyphus and
+    // /goals enqueue the agent turn fire-and-forget via pi.sendUserMessage and
+    // return immediately; the actual turn (and any goal_question /
+    // propose_goal_draft / goal_questionnaire dialogs it raises) runs AFTER the
+    // handler resolves. If we let runWithTelegramUi restore the TUI UI at that
+    // point, those dialogs render to the local TUI and Telegram gets nothing.
+    // Only hold the swap when the agent was idle when the command arrived: if a
+    // local turn was already streaming, holding the swap would hijack the local
+    // user's TUI (modals would route to Telegram, editor would no-op).
+    const idleFn = typeof (ctx as any).isIdle === "function" ? (ctx as any).isIdle : undefined;
+    const waitFn = typeof (ctx as any).waitForIdle === "function" ? (ctx as any).waitForIdle : undefined;
+    const wasIdle = idleFn ? idleFn.call(ctx) : false;
     void runWithTelegramUi({
       session,
       ui: telegramUi,
-      run: async () => handler(args, session.extensionRunner.createCommandContext()),
-    }).catch(() => undefined);
+      run: async () => {
+        await handler(args, ctx);
+        if (!wasIdle || !idleFn || !waitFn) return;
+        // Hold the Telegram UI swap across the command's enqueued turn and any
+        // auto-continue chain it spawns. pi-goal schedules continuation turns via
+        // setTimeout(0 / 50ms) after a turn ends, so a single waitForIdle()
+        // resolves before the next turn starts. After each idle, yield one
+        // macrotask window (120ms > pi-goal's 50ms CONTINUATION_IDLE_RETRY_MS) to
+        // let a pending continuation begin; if the agent starts streaming again,
+        // keep waiting. Stop when the agent stays idle through the window — the
+        // chain has drained and the local TUI is fully usable again.
+        try {
+          for (;;) {
+            await waitFn.call(ctx);
+            await new Promise((r) => setTimeout(r, 120));
+            if (idleFn.call(ctx)) break;
+          }
+        } catch (err) {
+          // Session disposed / torn down during the wait — nothing to do but log.
+          ctrlLog.debug("waitForIdle during enqueued turn interrupted", { err });
+        }
+      },
+    }).catch(ctrlLog.swallow("warn", "beginTelegramTurn enqueued-turn wrapper failed"));
   };
 
   const tryHandleSlashCommand = async (text: string, chatId: number): Promise<boolean> => {
@@ -287,7 +324,7 @@ export function createTelegramController(deps: {
     async handleCallbackQuery(query) {
       const chatId = query.message?.chat?.id;
       if (typeof chatId !== "number") return;
-      await deps.transport.answerCallbackQuery(query.id).catch(() => undefined);
+      await deps.transport.answerCallbackQuery(query.id).catch(ctrlLog.swallow("debug", "answerCallbackQuery failed", { queryId: query.id }));
       if (!(await deps.authorizeUser(query.from?.id))) return;
       await deps.setActiveChatId(chatId);
 
@@ -297,15 +334,17 @@ export function createTelegramController(deps: {
         const result = deps.ui.resolveInput(chatId, uiValue, query.message?.message_id, true);
         if (!result.handled) {
           await deps.transport.sendText(chatId, "This prompt is no longer active.");
-        } else {
-          // Remove inline keyboards only for terminal UI callbacks. Select
-          // pagination callbacks continue the same flow and immediately edit the
-          // same message with the next page of buttons; removing the keyboard here
-          // can race after that edit and strip the new page buttons.
-          const isPaginationCallback = /^f:[^:]+:p:\d+$/.test(uiValue);
-          const promptMessageId = result.promptMessageId ?? query.message?.message_id;
-          if (!isPaginationCallback && promptMessageId) void deps.transport.removeInlineKeyboard(chatId, promptMessageId);
         }
+        // Keyboard cleanup is OWNED by each UI flow (confirm/input/select and the
+        // custom-dialog bridge): each calls removeInlineKeyboard on its own prompt
+        // message right before resolving a terminal value (yes/no/cancel/submit/...).
+        // The controller must NOT speculatively strip keyboards here. Doing so races
+        // with continuation flows (multi-question tab navigation, single-question
+        // option toggles, select pagination) that edit the SAME message in place:
+        // removeInlineKeyboard and editButtons hit Telegram concurrently on one
+        // message, and when the strip lands last the message is left with no
+        // buttons — the "answered Q1 but Q2 never appeared" bug. Terminal flows
+        // clean up themselves, so no controller-side strip is needed.
         return;
       }
 
@@ -368,7 +407,7 @@ export function createTelegramController(deps: {
             formatIncomingAttachmentReceipt("saved", downloadedMediaLines),
             formatIncomingAttachmentReceipt("failed", failedMediaLines),
           ].filter(Boolean);
-          await deps.transport.sendText(chatId, lines.join("\n\n")).catch(() => undefined);
+          await deps.transport.sendText(chatId, lines.join("\n\n")).catch(ctrlLog.swallow("warn", "sendText media receipt failed", { chatId }));
         }
       }
       const hasPromptInput = hasTextInput || hasMediaInput;