@llblab/pi-telegram 0.13.0 → 0.13.2

package/AGENTS.md

@@ -60,7 +60,7 @@
 - Queue admission is explicit and validated: immediate commands, control lane, priority lane, and default lane must preserve allowed kind/lane pairings
 - Dispatch is gated by active turns, pending dispatch, unsettled control work, compaction, `ctx.isIdle()`, and π pending messages; dispatched prompts remain queued until `agent_start` consumes them
 - Telegram `/compact` owns a native `typing` keepalive for the compaction window so phone clients show activity between the started/completed notices; stop it on both completion and failure
-- `/stop`, `/abort`, `/next`, and `/continue` have distinct contracts: reset queue and abort; abort while preserving queue; force next queued turn; enqueue a priority `continue` prompt
+- `/stop`, `/abort`, `/next`, and `/continue` have distinct contracts: reset queue and abort; abort while preserving queue; force next queued turn; enqueue a control-lane `continue` resume prompt without folding queued prompts into history
 - `/start`, `/help`, and `/status` open the unified command-help/status-row/control menu; `/model`, `/thinking`, and `/queue` jump to sections directly; visible bot commands are `/start`, `/compact`, `/next`, `/continue`, `/abort`, `/stop`
 - Command/menu emoji are fixed UI adornments owned by the `commands` map; do not add a persisted emoji toggle or Settings menu until there is a real setting to own
 - Telegram `reply_to_message` context is prompt-only and must not affect slash-command parsing

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
-## 0.13.0: Command Template Standard, Voice Hardening, And Domain Cleanup (2026-05-22)
+## Unreleased
+
+## 0.13.2: Config Recovery And Inbound Output Bounds Hotfix
+
+- `[Config]` Invalid `telegram.json` now recovers on session startup by renaming the broken file to an `.invalid-*` recovery path, loading safe empty defaults, and recording a runtime diagnostic. Impact: a hand-edited or partially written config no longer bricks `/telegram-setup` or session startup.
+- `[Inbound]` Inbound handler, programmatic handler, voice transcription, and built-in text attachment outputs are now bounded before entering Telegram prompt context. Impact: large OCR, PDF, STT, or text-file outputs cannot silently explode prompt size.
+- `[Diagnostics]` Runtime event messages/details and inbound handler failure stdout/stderr are truncated before storage/rendering. Impact: `/telegram-status` remains useful after noisy provider or handler failures without hiding that truncation happened.
+
+## 0.13.1: Rendering, Typing, And Continue Queue Hotfix
+
+- `[Rendering]` Fixed Telegram HTML rendering for Markdown bold/italic spans that cross soft line breaks, so assistant replies like `**first line\nsecond line**` render as bold text instead of showing raw asterisks. Added a regression for the guest-mode-style multiline bold reply shape.
+- `[Typing Status]` Hardened assistant message activity hooks so transient preview/provider transport failures are recorded but do not break the native Telegram `typing` keepalive while an active turn continues.
+- `[Continue Queue]` `/continue` now enqueues as a control-lane resume prompt and explicitly clears preserved-abort history mode, so queued Telegram prompts stay separate and the continuation runs ahead of queued prompt work after abort or compaction recovery.
+
+## 0.13.0: Command Template Standard, Voice Hardening, And Domain Cleanup
 
 - `[Architecture]` Extracted outbound assistant-action markup parsing into `lib/outbound-markup.ts` and removed the temporary Voice/Outbound/Queue import-cycle allowance. Impact: project source imports are fully acyclic again while preserving existing voice and outbound helper exports.
 - `[Tests]` Updated the Pi SDK centralization invariant to guard the current `@earendil-works/*` package scope as well as the legacy scope. Impact: new direct SDK imports outside `lib/pi.ts` are caught again.

package/index.ts

@@ -48,7 +48,15 @@ export default function (pi: Pi.ExtensionAPI) {
   } = piRuntime;
   const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
   const { abort, lifecycle, queue, setup, typing } = bridgeRuntime;
-  const configStore = Config.createTelegramConfigStore();
+  let configStoreForRedaction: Config.TelegramConfigStore | undefined;
+  const runtimeEvents = Status.createTelegramRuntimeEventRecorder({
+    getBotToken() {
+      return configStoreForRedaction?.getBotToken();
+    },
+  });
+  const recordRuntimeEvent = runtimeEvents.record;
+  const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
+  configStoreForRedaction = configStore;
   Config.bindGlobalTelegramConfigRuntime(configStore);
   const configControls = Config.createTelegramConfigControls(configStore);
   const lockRuntime = Locks.createTelegramLockRuntime<Pi.ExtensionContext>();
@@ -68,10 +76,6 @@ export default function (pi: Pi.ExtensionAPI) {
   const modelMenuRuntime = Menu.createTelegramModelMenuRuntime<ActivePiModel>();
   const sectionRegistry = Sections.createAndBindTelegramSectionRegistry();
 
-  const runtimeEvents = Status.createTelegramRuntimeEventRecorder({
-    getBotToken: configStore.getBotToken,
-  });
-  const recordRuntimeEvent = runtimeEvents.record;
   const timeInjectionRuntime = TimeInjection.createTimeInjectionRuntime({
     getConfig: Config.createTelegramTimeConfigGetter(configStore),
     recordRuntimeEvent,

package/lib/bindings.ts

@@ -279,6 +279,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       startTypingLoop: promptDispatchRuntime.startTypingLoop,
       onMessageStart: previewRuntime.onMessageStart,
       onMessageUpdate: previewRuntime.onMessageUpdate,
+      recordRuntimeEvent,
     });
   Lifecycle.registerTelegramLifecycleHooks(pi, {
     ...sessionLifecycleRuntime,

package/lib/config.ts

@@ -84,6 +84,17 @@ export interface TelegramConfigStoreOptions {
   initialConfig?: TelegramConfig;
   agentDir?: string;
   configPath?: string;
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+}
+
+export interface TelegramInvalidConfigRecovery {
+  configPath: string;
+  recoveryPath: string;
+  error: unknown;
 }
 
 export interface TelegramConfigRuntime {
@@ -125,12 +136,26 @@ export function bindGlobalTelegramConfigRuntime(
   });
 }
 
+function getInvalidTelegramConfigRecoveryPath(configPath: string): string {
+  return `${configPath}.invalid-${process.pid}-${Date.now()}`;
+}
+
 export async function readTelegramConfig(
   configPath: string,
+  options: {
+    onInvalidConfig?: (recovery: TelegramInvalidConfigRecovery) => void;
+  } = {},
 ): Promise<TelegramConfig> {
   if (!existsSync(configPath)) return {};
   const content = await readFile(configPath, "utf8");
-  return JSON.parse(content) as TelegramConfig;
+  try {
+    return JSON.parse(content) as TelegramConfig;
+  } catch (error) {
+    const recoveryPath = getInvalidTelegramConfigRecoveryPath(configPath);
+    await rename(configPath, recoveryPath);
+    options.onInvalidConfig?.({ configPath, recoveryPath, error });
+    return {};
+  }
 }
 
 export async function writeTelegramConfig(
@@ -176,7 +201,15 @@ export function createTelegramConfigStore(
       config.allowedUserId = userId;
     },
     load: async () => {
-      config = await readTelegramConfig(configPath);
+      config = await readTelegramConfig(configPath, {
+        onInvalidConfig: (recovery) => {
+          options.recordRuntimeEvent?.("config", recovery.error, {
+            phase: "load",
+            configPath: recovery.configPath,
+            recoveryPath: recovery.recoveryPath,
+          });
+        },
+      });
     },
     persist: async (nextConfig = config) => {
       await writeTelegramConfig(agentDir, configPath, nextConfig);

package/lib/inbound.ts

@@ -19,6 +19,8 @@ import { getTelegramVoiceTranscriptionProviders } from "./voice.ts";
 
 const DEFAULT_INBOUND_HANDLER_TIMEOUT_MS = 120_000;
 const INBOUND_HANDLER_REGISTRY_KEY = "__piTelegramInboundHandlers__";
+const MAX_INBOUND_HANDLER_OUTPUT_LENGTH = 12_000;
+const MAX_INBOUND_HANDLER_FAILURE_STREAM_LENGTH = 4_000;
 
 type TelegramInboundCommandTemplateConfig =
   | string
@@ -187,12 +189,28 @@ export function clearTelegramInboundHandlers(): void {
   getOrCreateInboundHandlerRegistry().handlers.clear();
 }
 
+function truncateTelegramInboundText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength).trimEnd()}… [truncated ${text.length - maxLength} chars]`;
+}
+
+function truncateTelegramInboundOutput(text: string): string {
+  return truncateTelegramInboundText(text, MAX_INBOUND_HANDLER_OUTPUT_LENGTH);
+}
+
+function truncateTelegramInboundFailureStream(text: string): string {
+  return truncateTelegramInboundText(
+    text.trimEnd(),
+    MAX_INBOUND_HANDLER_FAILURE_STREAM_LENGTH,
+  );
+}
+
 function normalizeInboundProgrammaticHandlerText(
   result: TelegramInboundProgrammaticHandlerResult,
 ): string | undefined {
   const text = typeof result === "string" ? result : result?.text;
   const normalized = text?.trim();
-  return normalized || undefined;
+  return normalized ? truncateTelegramInboundOutput(normalized) : undefined;
 }
 
 function normalizeStringList(value: string | string[] | undefined): string[] {
@@ -401,8 +419,10 @@ function formatTelegramInboundHandlerFailure(
   const parts = [
     `Inbound handler exited with code ${result.code}${result.killed ? " (killed)" : ""}`,
   ];
-  if (result.stderr.trim()) parts.push(`stderr:\n${result.stderr.trimEnd()}`);
-  if (result.stdout.trim()) parts.push(`stdout:\n${result.stdout.trimEnd()}`);
+  if (result.stderr.trim())
+    parts.push(`stderr:\n${truncateTelegramInboundFailureStream(result.stderr)}`);
+  if (result.stdout.trim())
+    parts.push(`stdout:\n${truncateTelegramInboundFailureStream(result.stdout)}`);
   return parts.join("\n\n");
 }
 
@@ -431,7 +451,7 @@ async function executeTelegramInboundHandlerInvocation(
   });
   if (result.code !== 0)
     throw new Error(formatTelegramInboundHandlerFailure(result));
-  return result.stdout;
+  return truncateTelegramInboundOutput(result.stdout);
 }
 
 function getTelegramInboundHandlerCompositionSteps(
@@ -504,7 +524,7 @@ async function executeTelegramTextHandlerInvocation(
   });
   if (result.code !== 0)
     throw new Error(formatTelegramInboundHandlerFailure(result));
-  return result.stdout;
+  return truncateTelegramInboundOutput(result.stdout);
 }
 
 async function executeTelegramTextHandler(
@@ -633,7 +653,7 @@ async function transcribeTelegramVoiceFileWithProviders(
     try {
       const result = await provider(file, {});
       const text = typeof result === "string" ? result : result?.text;
-      if (text?.trim()) return text.trim();
+      if (text?.trim()) return truncateTelegramInboundOutput(text.trim());
     } catch (error) {
       options.recordRuntimeEvent?.("voice-transcription-provider", error, {
         fileName: file.fileName || basename(file.path),
@@ -656,7 +676,7 @@ async function readBuiltInTelegramTextAttachment(
     return undefined;
   }
   const name = file.fileName || basename(file.path);
-  return `[${name}]\n${normalized}`;
+  return truncateTelegramInboundOutput(`[${name}]\n${normalized}`);
 }
 
 async function executeTelegramInboundHandler(

package/lib/lifecycle.ts

@@ -182,6 +182,11 @@ export interface TelegramMessageActivityTypingDeps<TContext> {
   startTypingLoop: (ctx: TContext) => void;
   onMessageStart: TelegramLifecycleRegistrationDeps["onMessageStart"];
   onMessageUpdate: TelegramLifecycleRegistrationDeps["onMessageUpdate"];
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
 }
 
 export function createTelegramMessageActivityTypingHooks<
@@ -195,15 +200,27 @@ export function createTelegramMessageActivityTypingHooks<
   const ensureTyping = (ctx: TContext): void => {
     if (deps.hasActiveTurn()) deps.startTypingLoop(ctx);
   };
+  const handleMessageActivity = async (
+    phase: "start" | "update",
+    event: Parameters<TelegramLifecycleRegistrationDeps["onMessageStart"]>[0],
+    ctx: ExtensionContext,
+    inner: TelegramLifecycleRegistrationDeps["onMessageStart"],
+  ): Promise<void> => {
+    const typedCtx = ctx as TContext;
+    ensureTyping(typedCtx);
+    try {
+      await inner(event, ctx);
+    } catch (error) {
+      deps.recordRuntimeEvent?.("message-activity", error, { phase });
+    } finally {
+      ensureTyping(typedCtx);
+    }
+  };
   return {
-    onMessageStart: async (event, ctx) => {
-      ensureTyping(ctx as TContext);
-      await deps.onMessageStart(event, ctx);
-    },
-    onMessageUpdate: async (event, ctx) => {
-      ensureTyping(ctx as TContext);
-      await deps.onMessageUpdate(event, ctx);
-    },
+    onMessageStart: (event, ctx) =>
+      handleMessageActivity("start", event, ctx, deps.onMessageStart),
+    onMessageUpdate: (event, ctx) =>
+      handleMessageActivity("update", event, ctx, deps.onMessageUpdate),
   };
 }
 

package/lib/preview.ts

@@ -345,6 +345,7 @@ export function createTelegramPreviewControllerRuntime<
     maxDraftId: deps.maxDraftId,
     setTimer: deps.setTimer,
     clearTimer: deps.clearTimer,
+    recordRuntimeEvent: deps.recordRuntimeEvent,
   });
 }
 

package/lib/rendering.ts

@@ -843,7 +843,7 @@ function renderDelimitedInlineStyle(
 ): string {
   const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const pattern = new RegExp(
-    `(^|[^\\p{L}\\p{N}\\\\])(${escapedDelimiter})(?=\\S)(.+?)(?<=\\S)\\2(?=[^\\p{L}\\p{N}]|$)`,
+    `(^|[^\\p{L}\\p{N}\\\\])(${escapedDelimiter})(?=\\S)([\\s\\S]+?)(?<=\\S)\\2(?=[^\\p{L}\\p{N}]|$)`,
     "gu",
   );
   return text.replace(
@@ -1004,9 +1004,28 @@ function renderMarkdownTextPiece(piece: string): string {
   return renderInlineMarkdown(piece);
 }
 
+function isPlainInlineMarkdownLine(line: string): boolean {
+  if (line.trim().length === 0) return false;
+  return (
+    matchMarkdownHeadingLine(line) === null &&
+    !/^(\s*)([-*+]|\d+\.)\s+\[([ xX])\]\s+(.+)$/.test(line) &&
+    !/^(\s*)[-*+]\s+(.+)$/.test(line) &&
+    !/^(\s*)(\d+)\.\s+(.+)$/.test(line) &&
+    !/^>\s?(.+)$/.test(line) &&
+    !/^([-*_]\s*){3,}$/.test(line.trim())
+  );
+}
+
 function renderMarkdownTextLines(block: string): string[] {
   const rendered: string[] = [];
   const lines = block.split("\n");
+  const nonBlankLines = lines.filter((line) => line.trim().length > 0);
+  if (
+    nonBlankLines.length > 1 &&
+    nonBlankLines.every(isPlainInlineMarkdownLine)
+  ) {
+    return renderInlineMarkdown(nonBlankLines.join("\n")).split("\n");
+  }
   for (const line of lines) {
     if (line.trim().length === 0) continue;
     for (const piece of splitPlainMarkdownLine(line)) {

package/lib/routing.ts

@@ -351,8 +351,8 @@ export function createTelegramInboundRouteRuntime<
     const turn = await promptTurnBuilder([continueMessage], [], ctx);
     const continueTurn = {
       ...turn,
-      queueLane: "priority" as const,
-      laneOrder: Number.MIN_SAFE_INTEGER + turn.queueOrder,
+      queueLane: "control" as const,
+      laneOrder: deps.bridgeRuntime.queue.allocateControlOrder(),
       statusSummary: "continue",
     };
     deps.queueMutationRuntime.append(continueTurn, ctx);

package/lib/status.ts

@@ -53,6 +53,8 @@ export interface TelegramStatusContext {
 export type TelegramRuntimeEventDetailValue = string | number | boolean | null;
 
 const MAX_RECENT_TELEGRAM_RUNTIME_EVENTS = 10;
+const MAX_TELEGRAM_RUNTIME_EVENT_MESSAGE_LENGTH = 1000;
+const MAX_TELEGRAM_RUNTIME_EVENT_DETAIL_LENGTH = 1000;
 
 export interface TelegramRuntimeEvent {
   at: number;
@@ -164,12 +166,35 @@ export interface TelegramStatusRuntime<
   getStatusLines: () => string[];
 }
 
+function truncateTelegramRuntimeEventText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength).trimEnd()}… [truncated ${text.length - maxLength} chars]`;
+}
+
 export function redactTelegramRuntimeMessage(
   message: string,
   botToken: string | undefined,
 ): string {
-  if (!botToken) return message;
-  return message.split(botToken).join("<redacted-token>");
+  const redacted = botToken
+    ? message.split(botToken).join("<redacted-token>")
+    : message;
+  return truncateTelegramRuntimeEventText(
+    redacted,
+    MAX_TELEGRAM_RUNTIME_EVENT_MESSAGE_LENGTH,
+  );
+}
+
+function redactTelegramRuntimeDetail(
+  message: string,
+  botToken: string | undefined,
+): string {
+  const redacted = botToken
+    ? message.split(botToken).join("<redacted-token>")
+    : message;
+  return truncateTelegramRuntimeEventText(
+    redacted,
+    MAX_TELEGRAM_RUNTIME_EVENT_DETAIL_LENGTH,
+  );
 }
 
 function normalizeTelegramRuntimeEventDetails(
@@ -181,7 +206,7 @@ function normalizeTelegramRuntimeEventDetails(
   for (const [key, value] of Object.entries(details)) {
     if (value === undefined) continue;
     if (typeof value === "string") {
-      normalized[key] = redactTelegramRuntimeMessage(value, botToken);
+      normalized[key] = redactTelegramRuntimeDetail(value, botToken);
       continue;
     }
     if (typeof value === "number" || typeof value === "boolean") {
@@ -192,7 +217,7 @@ function normalizeTelegramRuntimeEventDetails(
       normalized[key] = null;
       continue;
     }
-    normalized[key] = redactTelegramRuntimeMessage(String(value), botToken);
+    normalized[key] = redactTelegramRuntimeDetail(String(value), botToken);
   }
   return Object.keys(normalized).length > 0 ? normalized : undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "private": false,
   "publishConfig": {
     "access": "public"