@llblab/pi-telegram 0.13.0 → 0.13.1

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/BACKLOG.md

@@ -1,3 +1,28 @@
 # Project Backlog
 
-No open work.
+## Bound inbound handler output
+
+`Task`: Bound inbound handler stdout, stderr, and recorded failure text before they enter prompts or runtime status.
+
+`Why`: Large OCR, PDF, STT, or failing command output can inflate prompt context, memory use, and `/telegram-status`.
+
+`Exit criteria`:
+
+- Handler stdout added to `[outputs]` is truncated or externalized behind a bounded artifact reference.
+- Handler stderr and stdout included in failure messages are bounded.
+- Runtime event messages and details are bounded before storage and rendering.
+- Regression tests cover large handler stdout and large failure output.
+
+## Recover from invalid config JSON
+
+`Task`: Make `telegram.json` load failures recoverable without bricking pi-telegram session startup.
+
+`Why`: A hand-edited or partially written invalid config currently bubbles `JSON.parse` failure through session start, which can block the normal repair path.
+
+`Exit criteria`:
+
+- Invalid config JSON is reported through a runtime event or clear status diagnostic.
+- Session startup continues with safe empty config defaults.
+- The invalid file is preserved or renamed for operator recovery.
+- `/telegram-setup` remains usable after an invalid config is detected.
+- Regression tests cover invalid config startup behavior.

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Changelog
 
-## 0.13.0: Command Template Standard, Voice Hardening, And Domain Cleanup (2026-05-22)
+## Unreleased
+
+## 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/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/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/package.json

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