@llblab/pi-kit 0.34.1 → 0.34.3

package/BACKLOG.md

@@ -4,6 +4,8 @@ Package pins, resource order and bundled runtime ownership remain authoritative
 
 ## Carried checks
 
+- **Installed 0.34.3 typing smoke (operator-owned):** After separately authorized installation/reload of both peers, verify native typing during streaming, UI prompts and compaction without recurring local authorization churn. Check actual client versions, including iOS; successful HTTP issuance and synthetic tests do not prove client visibility. Use disposable sessions and preserve accepted work.
+- **Installed 0.34.2 smoke (operator-owned):** After separately authorized installation/reload, verify Pi 1.2 custom-message completions no longer raise the Telegram prompt-hook error, adjacent button matrices retain their rows and callbacks, and native Windows Codex CLI fallback works on an actual Windows host. Use disposable settings; package validation and synthetic SDK probes do not certify installed clients or authorize live fault injection.
 - **Installed 0.34.0 Telegram smoke (operator-owned):** After separately authorized installation/reload of both peers, verify per-prompt Steer, canonical thumbs-up/thumbs-down/fire controls with other reactions ignored, reconnection after a deleted tab, follower `/start` Restore and first-click leader Restore confirmation with separately proven old-tab cleanup. Unknown creation can leave an extra tab; do not erase accepted work or replay uncertain input. Package/CI validation does not certify live clients.
 - **Installed 0.31.0 Telegram smoke (operator-owned):** After separately authorized installation/reload of every Pi process together (bus protocol v3), confirm an idle leader makes no periodic `state.json` or `telegram.json.transaction` writes, a frozen leader is replaced by its follower, and switching Threaded Mode off takes followers offline. Packed validation does not certify running clients.
 - **Installed 0.30.0 Telegram smoke (operator-owned):** After separately authorized installation/reload, confirm live Restore/rebinding in both roles, immediate temporary-tab removal after Cancel and, on Windows, Restore and follower delivery with disposable runtime storage. Packed validation does not certify running clients.

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.34.3: Telegram Typing Continuity
+
+- `Telegram typing`: Advances only the exact Telegram pin to `0.56.4`. Streaming keepalives preserve the same owner's in-flight typing request, while session, transport and target changes still revoke old authority. Compaction cannot claim an existing agent loop. Other pins, package membership and resource order are unchanged; client-specific typing visibility remains a live check.
+
+## 0.34.2: Telegram Compatibility and Windows Usage Updates
+
+- `Telegram`: Advances the exact pin to `0.56.3`, adding adjacent button matrices with preserved row grouping and fixing Pi 1.2 custom-message starts without a user prompt. Legacy prompt events and voice syntax remain supported; no client-rendering fallback is added.
+- `Usage extensions`: Advances Codex Usage to `0.13.1` for native Windows Codex CLI fallback and Claude Usage to `0.2.2` for its Windows-validated release with unchanged runtime. All eight package pins were checked against npm stable releases; other pins, composition and resource order remain unchanged.
+
 ## 0.34.1: Canonical Telegram Reactions
 
 - `Telegram reactions`: Advances only the exact Telegram pin to `0.56.2`. Only thumbs-up selects Priority, thumbs-down selects Skip, and fire selects Steer; retired aliases no longer flush or control queued input. Queue badges use canonical emoji without rewriting accepted state. Other pins, package membership, resources and load order are unchanged.

package/README.md

@@ -13,12 +13,12 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | Package | Version | Purpose |
 | --- | ---: | --- |
 | [`@llblab/pi-actors`](https://github.com/llblab/pi-actors) | `0.54.0` | Inspectable local Runs, reusable Recipes, persistent tools, and delegation Skills |
-| [`@llblab/pi-claude-usage`](https://github.com/llblab/pi-claude-usage) | `0.2.1` | Claude subscription quota status and shared per-model Fast toggle for Opus, mirrored in Telegram |
+| [`@llblab/pi-claude-usage`](https://github.com/llblab/pi-claude-usage) | `0.2.2` | Claude subscription quota status and shared per-model Fast toggle for Opus, mirrored in Telegram |
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.3.0` | Isolated nested Pi TUI with named npm extensions and compatible model selection |
-| [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.13.0` | OpenAI/legacy Codex subscription quota and Business credit status, with persistent priority Fast toggle mirrored in Telegram |
+| [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.13.1` | OpenAI/legacy Codex subscription quota and Business credit status, with persistent priority Fast toggle mirrored in Telegram |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.9.0` | Visible continuation scheduling and bounded worker Skills through compiled, manifest-owned resources |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.26.4` | Scoped context/memory compiler with step-independent current memory, stable Passive/Active modes and visible blocked-state status |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.56.2` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.56.4` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.

package/node_modules/@llblab/pi-claude-usage/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.2: Windows CI Validation
+
+- Added Linux and Windows GitHub Actions validation that runs the full release check suite (typecheck, tests, extension import, dependency audit and package dry-run) on every push to `main` and pull request, so the shared-refresh SQLite mutex, atomic state writes and path handling are exercised on Windows. The extension runtime is unchanged from 0.2.1.
+
 ## 0.2.1: Telegram Fast Status
 
 - The optional Telegram status row now appends lowercase ` fast` for the active eligible Opus model, or shows `fast` alone when quota is unavailable. It rereads the per-model preference at menu render time, so toggles and model changes do not wait for quota refresh. Unsupported Claude families ignore stale Fast overrides. Quota polling, auth, request adaptation and terminal behavior are unchanged; isolated tests cover eligibility, model/provider changes and unreadable configuration.

package/node_modules/@llblab/pi-claude-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-claude-usage",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "private": false,
   "description": "Minimal Pi extension that shows Anthropic Claude subscription usage limits using Pi OAuth auth",
   "keywords": [

package/node_modules/@llblab/pi-codex-usage/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.13.1: Windows Codex CLI Fallback
+
+- The Codex CLI fallback now starts on Windows. When npm installs Codex behind a `codex.cmd` shim that a shell-free `spawn` cannot launch, the extension resolves the native `codex.exe` from PATH or from the npm platform package and starts it directly, so fallback quota stays available when the primary endpoint fails. Non-Windows platforms keep plain PATH lookup, and the helper window is hidden.
+- Added Linux and Windows GitHub Actions validation for the full release check suite.
+
 ## 0.13.0: OpenAI Subscription Provider Support
 
 - Added `openai` alongside `openai-codex` for `/fast`, request priority adaptation, terminal status and the optional Telegram row. Fast preferences remain isolated by provider/model, including identical model IDs. Both providers share the existing Codex subscription quota stream. Pi subscription OAuth under `openai` now fetches quota directly without requiring the legacy provider; `openai` API-key auth is skipped and the Codex CLI fallback is preserved.

package/node_modules/@llblab/pi-codex-usage/README.md

@@ -172,6 +172,8 @@ The extension tries usage sources in this order:
 1. Pi's subscription auth from `openai` or legacy `openai-codex` (active model first)
 2. `codex app-server --listen stdio://`
 
+On Windows, the fallback resolves the native `codex.exe` from PATH or from the npm platform package behind a `codex.cmd` shim, then launches it directly without a shell. If Codex is missing, install it with `npm install -g @openai/codex@latest` and restart Pi so it inherits the updated PATH.
+
 Selecting an `openai` model enables the status and Fast toggle, and its ChatGPT subscription OAuth credentials can fetch the quota directly; a legacy `openai-codex` provider is not required. The extension uses Pi's resolved auth headers/token, checks `modelRegistry.isUsingOAuth` before using `openai` credentials, and keeps the Codex CLI fallback. OpenAI API keys are not ChatGPT subscription auth and do not expose these quotas; `openai` API-key credentials are skipped, not sent to the ChatGPT quota endpoint. Without subscription auth/quota, the quota status is `n/a` when both sources report an unavailable state. Fast works independently of subscription auth.
 
 ## License

package/node_modules/@llblab/pi-codex-usage/lib/query.ts

@@ -1,5 +1,7 @@
 /** Domain: quota transport. Owns: Pi auth, Codex app-server fallback and errors. Excludes: shared leadership and UI. */
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { createInterface } from "node:readline";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { assertObject, errorMessage, isOpenAICodexModel, normalizeAppServerResponse, normalizeBackendPayload, parseJsonObject, selectUsageSnapshot, type AppServerRateLimitResponse, type CodexUsageModel, type CodexUsageReport, type RateLimitStatusPayload, type UsageQueryError } from "./usage.ts";
@@ -196,6 +198,47 @@ async function queryViaCodexAppServer(
   }
 }
 
+const WINDOWS_CODEX_TARGETS: Record<string, string> = {
+  x64: "x86_64-pc-windows-msvc",
+  arm64: "aarch64-pc-windows-msvc",
+};
+
+/**
+ * npm installs Codex behind a `codex.cmd` shim that a shell-free `spawn` cannot
+ * launch, so on Windows resolve the native executable used by the npm platform
+ * package. Other platforms keep plain PATH lookup. Launching the native binary
+ * attaches disposal to the app-server process instead of a shell or Node shim.
+ */
+export function resolveCodexExecutable(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+  arch: string = process.arch,
+): string {
+  if (platform !== "win32") return "codex";
+  const target = WINDOWS_CODEX_TARGETS[arch];
+  const path = Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+  for (const entry of path.split(";")) {
+    // Ignore empty entries rather than searching the current working directory.
+    const directory = entry.replace(/^"(.*)"$/, "$1");
+    if (!directory) continue;
+    const direct = join(directory, "codex.exe");
+    if (existsSync(direct)) return direct;
+    // A `.cmd` entry means an npm install; its native binary lives in the platform package.
+    if (!target || !existsSync(join(directory, "codex.cmd"))) continue;
+    const packageDirs = [
+      join(directory, "node_modules", "@openai", "codex", "node_modules", "@openai", `codex-win32-${arch}`),
+      join(directory, "node_modules", "@openai", `codex-win32-${arch}`),
+    ];
+    for (const packageDir of packageDirs) {
+      const binary = join(packageDir, "vendor", target, "bin", "codex.exe");
+      if (existsSync(binary)) return binary;
+    }
+  }
+  throw new Error(
+    "Could not find a native Codex executable on PATH. Install Codex with npm install -g @openai/codex@latest, then restart Pi so it inherits the updated PATH.",
+  );
+}
+
 class CodexAppServerClient {
   private child?: ChildProcessWithoutNullStreams;
   private nextId = 1;
@@ -213,8 +256,9 @@ class CodexAppServerClient {
     if (this.startPromise) return this.startPromise;
 
     this.startPromise = new Promise((resolve, reject) => {
-      const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
+      const child = spawn(resolveCodexExecutable(), ["app-server", "--listen", "stdio://"], {
         stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
       });
       this.child = child;
 

package/node_modules/@llblab/pi-codex-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "private": false,
   "description": "Pi extension for Codex subscription usage and an optional Fast toggle",
   "keywords": [

package/node_modules/@llblab/pi-telegram/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 ## Unreleased
 
+## 0.56.4: Typing Keepalive Continuity
+
+- `Typing continuity`: Streaming updates keep the current work's pending presence request alive instead of cancelling it through repeated loop replacement. Explicit starts, session or transport changes, Thread changes and stopping still revoke the previous action; compaction cannot claim an existing agent loop.
+- `Windows validation`: Grouped Restore fixtures control album debounce after both originals are admitted and await chooser publication, so slow filesystem work cannot accidentally split their input group. Exact source, receipt and readiness assertions remain intact; production debounce and routing behavior are unchanged.
+
+## 0.56.3: Button Matrices and Custom-Message Starts
+
+- `Button grammar`: Adjacent complete JSON/CML cells and matrices now compose one button surface in source order instead of dropping fenced controls or truncating footer controls. Each matrix contributes its existing rows; horizontal grouping, disabled controls and callback semantics remain unchanged. Invalid fenced groups register no callbacks. This extends button syntax only; rendering mode and voice syntax are unchanged.
+- `Pi compatibility`: Extension-triggered runs on Pi 1.2 no longer fail when `before_agent_start` carries a custom message without a user prompt. Custom starts retain connected bridge guidance without being mistaken for fresh Telegram user input; legacy user events, unavailable-transport filtering and ordered system-prompt blocks remain supported.
+
 ## 0.56.2: Canonical Queue Reactions
 
 - `Queue reactions`: Only thumbs-up selects Priority, thumbs-down selects Skip, and fire selects Steer. Heart, dove, ghost, broken-heart, poop and wastebasket aliases are no longer controls. Unsupported reactions neither flush waiting input nor change queue intent; removing a supported reaction does not fall back to a retired alias. Only thumbs-down cancels a waiting standalone Continue.

package/node_modules/@llblab/pi-telegram/dist/lib/bindings.js

@@ -847,7 +847,7 @@ export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime,
             return false;
         const turn = activeTurnRuntime.get();
         const target = turn?.target ?? proactivePushTargetGetter();
-        return (promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, { target }) !== false);
+        return (promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, { target, ensure: true }) !== false);
     };
     const startActiveTurnTypingLoop = (ctx) => {
         if (uiPromptActive)
@@ -855,6 +855,7 @@ export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime,
         const turn = activeTurnRuntime.get();
         promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId, {
             target: turn?.target,
+            ensure: true,
         });
     };
     let observedAutomaticCompaction = false;

package/node_modules/@llblab/pi-telegram/dist/lib/outbound-markup.js

@@ -463,23 +463,33 @@ function parseTelegramAdaptiveActionPayloadRows(source, parseCompactPayload, opt
         }
         return undefined;
     };
-    const parseVerticalSequence = () => {
+    const parseTopLevelRows = () => {
         const rows = [];
         while (offset < source.length) {
             skipWhitespace();
-            if (source[offset] !== "{")
+            const character = source[offset];
+            if (character === "{") {
+                const cell = parseCell();
+                if (!cell)
+                    return undefined;
+                rows.push([cell]);
+            }
+            else if (character === "[" && options.allowMatrixGroups) {
+                const matrix = parseMatrix();
+                if (!matrix)
+                    return undefined;
+                rows.push(...matrix);
+            }
+            else {
                 break;
-            const cell = parseCell();
-            if (!cell)
-                return undefined;
-            rows.push([cell]);
+            }
             if (!consumeOptionalSeparator())
                 return undefined;
         }
         return rows.length > 0 ? rows : undefined;
     };
     skipWhitespace();
-    const rows = source[offset] === "{" ? parseVerticalSequence() : parseMatrix();
+    const rows = parseTopLevelRows();
     if (!rows)
         return undefined;
     skipWhitespace();
@@ -527,10 +537,10 @@ function isPlausibleTelegramMatrixStart(source, start) {
     return (source[offset] === "{" || source[offset] === "[" || source[offset] === "]");
 }
 export function parseTelegramButtonPayloadRows(source) {
-    return parseTelegramAdaptiveActionPayloadRows(source.trim(), parseTelegramButtonCompactActionPayload, { maxCompactAtoms: 4 })?.rows;
+    return parseTelegramAdaptiveActionPayloadRows(source.trim(), parseTelegramButtonCompactActionPayload, { maxCompactAtoms: 4, allowMatrixGroups: true })?.rows;
 }
 export function parseTelegramActionPayloadRows(comment, command) {
-    const scanned = scanTelegramActionComment(comment, command, (content, offset) => parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramButtonCompactActionPayload, { allowTrailing: true, maxCompactAtoms: 4 })?.rows);
+    const scanned = scanTelegramActionComment(comment, command, (content, offset) => parseTelegramAdaptiveActionPayloadRows(content.slice(offset), parseTelegramButtonCompactActionPayload, { allowTrailing: true, maxCompactAtoms: 4, allowMatrixGroups: true })?.rows);
     if (!scanned)
         return undefined;
     if ("payload" in scanned)

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.d.ts

@@ -29,7 +29,9 @@ export declare function createTelegramModelContextAvailabilityRuntime(deps: {
     memory?: TelegramModelContextAvailabilityMemory;
 }): TelegramModelContextAvailabilityRuntime;
 export type TelegramSystemPrompt = string | string[];
-type TelegramBeforeAgentStartEvent = Omit<BeforeAgentStartEvent, "systemPrompt"> & {
+type TelegramBeforeAgentStartEvent = Omit<BeforeAgentStartEvent, "systemPrompt" | "prompt" | "messageType"> & {
+    messageType?: "user" | "custom";
+    prompt?: string;
     systemPrompt?: TelegramSystemPrompt | null;
 };
 type TelegramBeforeAgentStartResult = {
@@ -37,7 +39,7 @@ type TelegramBeforeAgentStartResult = {
 };
 type TelegramBeforeAgentStartHook = (event: TelegramBeforeAgentStartEvent) => TelegramBeforeAgentStartResult;
 export declare function buildTelegramBridgeSystemPrompt(options: {
-    prompt: string;
+    prompt?: string;
     systemPrompt?: TelegramSystemPrompt | null;
     telegramPrefix?: string;
     localSystemPromptSuffix: string;

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.js

@@ -113,7 +113,7 @@ export function buildTelegramBridgeSystemPrompt(options) {
     const telegramHead = telegramPrefix.endsWith("]")
         ? telegramPrefix.slice(0, -1)
         : telegramPrefix;
-    const trimmedPrompt = options.prompt.trimStart();
+    const trimmedPrompt = options.prompt?.trimStart() ?? "";
     const telegramTurn = trimmedPrompt.startsWith(`${telegramHead}]`) ||
         trimmedPrompt.startsWith(`${telegramHead}|`);
     const telegramSuffix = telegramTurn
@@ -127,7 +127,7 @@ export function buildTelegramBridgeSystemPrompt(options) {
 }
 export function createTelegramBeforeAgentStartHook(options = {}) {
     return (event) => buildTelegramBridgeSystemPrompt({
-        prompt: event.prompt,
+        prompt: event.messageType === "custom" ? undefined : event.prompt,
         systemPrompt: event.systemPrompt,
         telegramPrefix: options.telegramPrefix,
         localSystemPromptSuffix: options.localSystemPromptSuffix ?? LOCAL_SYSTEM_PROMPT_SUFFIX,

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.d.ts

@@ -119,6 +119,7 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
 }
 export declare function createTelegramTypingLoopStarter<TContext>(deps: TelegramTypingLoopStarterDeps<TContext>): (ctx: TContext, chatId?: number, options?: {
     target?: TelegramTypingLoopTarget;
+    ensure?: boolean;
 }) => boolean;
 /** The whole typing-loop state; only `transitionTelegramTypingLoop` produces a new one. */
 export interface TelegramTypingMachineState {
@@ -214,6 +215,7 @@ export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramTyp
 export interface TelegramPromptDispatchRuntime<TContext> {
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
+        ensure?: boolean;
     }) => boolean | void;
     onPromptDispatchStart: (ctx: TContext, chatId?: number, target?: TelegramTypingLoopTarget) => void;
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.js

@@ -161,6 +161,7 @@ function updateTelegramRuntimeStatusSafely(updateStatus, ctx, options) {
     }
 }
 export function createTelegramTypingLoopStarter(deps) {
+    let currentOwner;
     return (ctx, chatId, options) => {
         const sessionGeneration = deps.getSessionGeneration?.();
         const transportAuthority = deps.getTransportAuthority?.();
@@ -177,9 +178,24 @@ export function createTelegramTypingLoopStarter(deps) {
         // Queue dispatch precedes agent_start: only an explicit destination permits Threaded presence, never chat fallback.
         if (!canContinue())
             return false;
+        const resolvedChatId = chatId ?? deps.getDefaultChatId();
+        if (resolvedChatId === undefined || resolvedChatId === 0)
+            return false;
+        // Streaming updates ensure presence without revoking the same owner's pending HTTP/IPC action.
+        // Explicit starts still replace the loop, including a new turn on the same session and Thread.
+        if (options?.ensure && currentOwner?.canContinue() &&
+            (deps.getSessionGeneration
+                ? Object.is(currentOwner.sessionGeneration, sessionGeneration)
+                : Object.is(currentOwner.ctx, ctx)) &&
+            Object.is(currentOwner.transportAuthority, transportAuthority) &&
+            currentOwner.chatId === resolvedChatId && currentOwner.threadId === target?.threadId)
+            return false;
+        const owner = { ctx, sessionGeneration, transportAuthority, chatId: resolvedChatId,
+            threadId: target?.threadId, canContinue };
+        currentOwner = owner;
         let active = true;
         return deps.typing.start({
-            chatId: chatId ?? deps.getDefaultChatId(),
+            chatId: resolvedChatId,
             target,
             intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
             sendTypingAction: async (targetChatId, actionOptions) => {
@@ -219,6 +235,8 @@ export function createTelegramTypingLoopStarter(deps) {
             shouldContinue: canContinue,
             onStopped: () => {
                 active = false;
+                if (currentOwner === owner)
+                    currentOwner = undefined;
             },
         });
     };

package/node_modules/@llblab/pi-telegram/dist/package.json

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

package/node_modules/@llblab/pi-telegram/dist/skills/telegram-bridge/SKILL.md

@@ -60,7 +60,7 @@ Every enabled button has a self-contained prompt and an optional selection style
 - `{label|prompt}` separates visible label from queued prompt.
 - `{label|prompt|selected_style}` and `{|prompt|selected_style}` accept `primary`, `success`, or `danger`.
 - Fourth-position `1`/`true` disables, `0`/`false` enables; omission means enabled. JSON uses boolean `disabled`. `{|Next||1}` omits label/style; `{Next|||1}` omits prompt/style; `{|||1}` is blank (Telegram receives a non-breaking space). Prefer meaningful labels and retain a useful enabled action. Enabled CML requires a prompt. Disabled controls stay visible but have no callback, queued prompt, or bound-method invocation.
-- Top-level cells form vertical rows; inside a fenced block, adjacent top-level JSON/CML objects may omit the outer array and commas. One nested row groups horizontal peers.
+- Both wrappers concatenate rows from adjacent JSON/CML cells or matrices, with optional commas. Cells are vertical; horizontal peers require a nested row: `[[{A|a}{B|b}]]`.
 - Prefer one matrix per related group. Fenced blocks stay in place in Rich mode; HTML compatibility moves them to the footer. Native rows allow eight buttons. Malformed/oversized/unclosed blocks activate nothing; drafts hide them. Outer code fences and quoted/indented examples remain literal.
 - Both placements share prompt/app routing. In-body clicks acknowledge without recoloring; selected-style highlighting remains footer-only.
 

package/node_modules/@llblab/pi-telegram/docs/architecture.md

@@ -681,7 +681,7 @@ Native typing during compaction follows connected-instance activity rather than
 - Thread-targeted typing is sent only to the concrete thread. Aggregate `All` mirroring is intentionally omitted because duplicating every keepalive multiplies shared-chat flood pressure. Compaction completion, failure, or timeout stops only a loop actually started by the compaction observer; a pre-existing agent-owned loop remains active. Ownership is sticky across a repeated compaction start, whose shared-loop start reports `false` for the observer's own running loop. Authority loss and shutdown still stop the keyed loop.
 - Pi `ui_prompt_start` pauses typing while an extension-owned local prompt waits for the operator; `ui_prompt_end` emits the matching Activity boundary and resumes typing whenever agent or compaction work remains unsettled.
 
-At every connected instance `agent_start`, the lifecycle binding starts Telegram's native `…typing` indicator in that instance's assigned target, whether the run came from Telegram, the local TUI, or an autonomous continuation such as Grow Loop. Terminal `Active` remains Telegram-turn-specific; the native indicator answers the separate question of whether the instance is doing agent work. Queue dispatch carries the queued turn's exact target into typing before `agent_start`, rather than reducing it to a chat ID. In Threaded Mode, missing or invalid Thread targets are refused before starting a loop or invoking the API; mode changes also invalidate a captured Classic chat-only loop. A rejected start never replaces an existing valid Thread loop. The starter also requires the captured Pi context and session generation to remain current at start, queued send, tick and late failure boundaries, even if the transport epoch is unchanged; replacing a context object in place cannot revive old activity. Message activity hooks capture generation across awaited preview work, and agent-start bindings recheck it before post-await activity/typing, so an obsolete finally or continuation cannot acquire replacement ownership. The typing sender carries its captured loop/context/generation/transport assertion as process-local call authority: direct API issuance rechecks it after queued work, and the follower caller rechecks it after registration waits and immediately before socket issuance without putting callbacks in IPC data. Automatic typing uses one HTTP attempt with no transport-family fallback or delayed replay, including forwarded calls; a future keepalive is a fresh owner-checked attempt. An already issued HTTP/RPC cannot be retroactively unsent. Each loop refreshes its exact target every three seconds and keeps one action in flight. The leader API runtime coalesces identical chat/thread/action calls for two seconds, permits at most one concurrent chat action per chat, and shares a Telegram 429 `retry_after` fence across every Thread key in that chat; expired gates prune opportunistically and each gate family retains at most 256 active keys. Suppression never schedules a delayed retry. A failed typing action remains a structured diagnostic but cannot project `error` onto an otherwise healthy connected/leader/follower status. Assistant message start/update hooks still re-arm typing during Telegram-owned turns so transient provider/model errors do not leave a continuing run without activity feedback, and agent/session completion stops it.
+At every connected instance `agent_start`, the lifecycle binding starts Telegram's native `…typing` indicator in that instance's assigned target, whether the run came from Telegram, the local TUI, or an autonomous continuation such as Grow Loop. Terminal `Active` remains Telegram-turn-specific; the native indicator answers the separate question of whether the instance is doing agent work. Streaming keepalives reuse a valid typing owner with the same session generation, transport and target rather than revoking its pending HTTP/IPC action. Fresh context wrappers may reuse that owner within a proven generation; without generation evidence, context identity must match. Explicit queue dispatch and Telegram prompt handoff still replace the owner. Queue dispatch carries the queued turn's exact target into typing before `agent_start`, rather than reducing it to a chat ID. In Threaded Mode, missing or invalid Thread targets are refused before starting a loop or invoking the API; mode changes also invalidate a captured Classic chat-only loop. A rejected start never replaces an existing valid Thread loop. The starter also requires the captured Pi context and session generation to remain current at start, queued send, tick and late failure boundaries, even if the transport epoch is unchanged; replacing a context object in place cannot revive old activity. Message activity hooks capture generation across awaited preview work, and agent-start bindings recheck it before post-await activity/typing, so an obsolete finally or continuation cannot acquire replacement ownership. The typing sender carries its captured loop/context/generation/transport assertion as process-local call authority: direct API issuance rechecks it after queued work, and the follower caller rechecks it after registration waits and immediately before socket issuance without putting callbacks in IPC data. Automatic typing uses one HTTP attempt with no transport-family fallback or delayed replay, including forwarded calls; a future keepalive is a fresh owner-checked attempt. An already issued HTTP/RPC cannot be retroactively unsent. Each loop refreshes its exact target every three seconds and keeps one action in flight. The leader API runtime coalesces identical chat/thread/action calls for two seconds, permits at most one concurrent chat action per chat, and shares a Telegram 429 `retry_after` fence across every Thread key in that chat; expired gates prune opportunistically and each gate family retains at most 256 active keys. Suppression never schedules a delayed retry. A failed typing action remains a structured diagnostic but cannot project `error` onto an otherwise healthy connected/leader/follower status. Assistant message start/update hooks still re-arm typing during Telegram-owned turns so transient provider/model errors do not leave a continuing run without activity feedback, and agent/session completion stops it.
 
 ### Rendering And Delivery
 
@@ -715,7 +715,7 @@ Assistant-authored final-message actions use hidden top-level comments, with an
 - `telegram_voice` accepts one positional compact action cell or JSON object and creates one voice artifact through configured outbound handlers, programmatic voice handlers, or registered synthesis providers.
 - `telegram_button` accepts a JSON object, adaptive JSON/CML matrix, or positional Compact Matrix Literal. Named JSON objects and positional cells may coexist, with commas optional only between completed matrix or row elements. Each top-level cell creates one full-width row, while a nested row groups buttons horizontally without an artificial parser-width cap; every callback enqueues its configured prompt text as a normal Telegram prompt turn. The JSON-first grammar, positional trim/escape rules, atomic rejection, and renderer-owned width policy are specified in [Adaptive Button Literal](./compact-matrix-literal.md).
 
-Standalone column-zero triple-backtick `telegram_button` blocks reuse the same cell/matrix grammar and callback store, including adjacent top-level JSON/CML objects as bracketless comma-free vertical rows, and compile to native Rich Markdown button rows between paragraphs. Rendering validates each complete block before registering any callbacks, escapes label text, preserves disabled cells, and leaves larger enclosing fences literal. Previews hide complete and unfinished action fences. HTML mode projects those controls into the footer. In-body callbacks acknowledge without rewriting the Rich message; selected-style highlighting remains footer-only.
+Standalone column-zero triple-backtick `telegram_button` blocks reuse the same cell/matrix grammar and callback store, including adjacent complete cells and matrices whose normalized rows concatenate in source order, and compile to native Rich Markdown button rows between paragraphs. Rendering validates each complete block before registering any callbacks, escapes label text, preserves disabled cells, and leaves larger enclosing fences literal. Previews hide complete and unfinished action fences. HTML mode projects those controls into the footer. In-body callbacks acknowledge without rewriting the Rich message; selected-style highlighting remains footer-only.
 
 Action recognition remains restricted to top-level column-zero comments and exact-name button fences so nested examples cannot trigger voice, buttons, or callbacks. The Telegram surface independently strips every complete assistant-authored HTML comment from previews and final delivery regardless of Markdown position or comment owner; an unclosed comment is withheld through the remaining tail, and a comment-only result sends no text message. Pi's terminal transcript and model context remain unchanged.
 

package/node_modules/@llblab/pi-telegram/docs/compact-matrix-literal.md

@@ -150,11 +150,11 @@ For `telegram_button` hidden comments and fenced blocks:
 - Positional `{label|prompt|selected_style|1}` is equivalent to JSON `{"label":"label","prompt":"prompt","selected_style":"selected_style","disabled":true}` with a valid selected style; `{|prompt||1}` is equivalent to `{"prompt":"prompt","disabled":true}`. Fourth-position `0` or `false` matches `disabled: false`; `true` is equivalent to `1`.
 - `{label|||1}` matches JSON `{"label":"label","disabled":true}`; `{|||1}` matches `{"disabled":true}`. Disabled cells require no prompt and do not retain action or selected-style semantics.
 - Disabled buttons serialize as `{ text, disabled: {} }`, without `callback_data`; they neither enqueue prompts nor invoke bound app methods. Enabled controls keep existing selection and callback behavior.
-- Top-level cells become full-width rows. Inside a fenced block, a whitespace-separated sequence of top-level JSON/CML objects is an alias for the same objects inside an outer matrix, so vertical rows need neither brackets nor commas.
+- Top-level cells become full-width rows. Telegram button wrappers additionally accept adjacent complete JSON/CML cells and matrices, with optional commas between groups. Normalize each group independently and concatenate its rows in source order: `[{A|a}] [{B|b}]` and `{A|a} [{B|b}]` both equal `[{A|a}{B|b}]`. Horizontal rows remain nested inside a matrix: `[[{A|a}{B|b}]] [{C|c}]` equals `[[{A|a}{B|b}]{C|c}]`. This is a Telegram button wrapper extension, not a change to portable CML v4 or voice syntax.
 - Nested rows become horizontal keyboard rows; horizontal intent still requires the explicit nested array.
 - Invalid payloads are stripped with their recognized action comment and register no callbacks.
 
-The wrapper selects placement without changing cell semantics. A hidden `telegram_button` HTML comment builds the footer keyboard. A standalone column-zero fenced block opened by exactly three backticks plus `telegram_button` renders rows between paragraphs in Native Rich Markdown. A singleton JSON/CML object needs no array in either wrapper. Fenced content must be one complete payload without trailing envelope text. Larger outer fences and ordinary code blocks remain literal examples; unclosed action fences are withheld. Native Rich rows support at most eight buttons and must fit one message chunk; these are renderer constraints, not grammar limits. HTML compatibility places fenced controls in the footer. See [Outbound](./outbound.md) for delivery and callback behavior.
+The wrapper selects placement without changing cell semantics. A hidden `telegram_button` HTML comment builds the footer keyboard. A standalone column-zero fenced block opened by exactly three backticks plus `telegram_button` renders rows between paragraphs in Native Rich Markdown. A singleton JSON/CML object needs no array in either wrapper. Fenced content must be one complete group sequence without trailing envelope text; any invalid group rejects the entire block before callback registration. Larger outer fences and ordinary code blocks remain literal examples; unclosed action fences are withheld. Native Rich rows support at most eight buttons and must fit one message chunk; these are renderer constraints, not grammar limits. HTML compatibility places fenced controls in the footer. See [Outbound](./outbound.md) for delivery and callback behavior.
 
 ````markdown
 Description.

package/node_modules/@llblab/pi-telegram/docs/outbound.md

@@ -182,7 +182,7 @@ Rules:
 - The opening marker must start at column zero on a top-level line outside fenced code, quotes, lists, and indented examples; otherwise it does not activate a button action and is still removed from the Telegram surface.
 - Prefer one matrix comment for multiple buttons. Each top-level JSON object or CML cell becomes one full-width inline-keyboard row in source order; a nested row groups one or more buttons horizontally. The parser imposes no artificial per-row width cap; empty rows, malformed cells, unknown/trailing CML escapes, a fourth unescaped CML separator, empty enabled-cell prompts or three-atom styles, invalid disabled flags, empty one-atom cells, unknown selected styles, and deeper nesting are rejected atomically. Multi-atom cells may omit the label; four-atom cells may additionally omit the selected style, and disabled cells may omit the prompt. Generated surfaces default to five columns and expand to six through eight only for short position-bearing labels. Repeated singular comments remain valid.
 - Button actions are stored in memory with short `callback_data`; Telegram never sees the full prompt in the button payload.
-- Standalone column-zero fences opened by exactly three backticks and `telegram_button` use the same singleton/matrix JSON/CML grammar. Adjacent top-level JSON/CML objects inside one fence may omit the outer array and commas; each remains a vertical singleton row, while horizontal peers still require a nested array. Complete valid blocks become native `<tg-button-row>` elements in `InputRichMessage.markdown`, at their original positions. Each row supports at most eight buttons and must fit a Rich Message chunk; validation precedes callback registration for the entire block. Labels are escaped, prompts never enter the native markup, and disabled cells have no callback. Missing closures, trailing payload garbage, and invalid blocks produce no controls. Other language names and enclosing code examples stay literal. Draft previews withhold complete and unfinished action fences without registering actions. HTML compatibility projects fenced rows into the bottom keyboard before comment-authored footer rows; source ordering within each group is retained.
+- Standalone column-zero fences opened by exactly three backticks and `telegram_button` use the same singleton/matrix JSON/CML grammar. Button wrappers accept adjacent complete JSON/CML cells and matrices with optional commas between groups. Their normalized rows concatenate in source order: `[{A|a}] [{B|b}]` equals `[{A|a}{B|b}]`; a singleton cell is one vertical row and horizontal peers still require a row nested inside a matrix. Any invalid group in a fence rejects the entire block before callback registration. Complete valid blocks become native `<tg-button-row>` elements in `InputRichMessage.markdown`, at their original positions. Each row supports at most eight buttons and must fit a Rich Message chunk; validation precedes callback registration for the entire block. Labels are escaped, prompts never enter the native markup, and disabled cells have no callback. Missing closures, trailing payload garbage, and invalid blocks produce no controls. Other language names and enclosing code examples stay literal. Draft previews withhold complete and unfinished action fences without registering actions. HTML compatibility projects fenced rows into the bottom keyboard before comment-authored footer rows; source ordering within each group is retained.
 - In-body controls share prompt/app dispatch, TTL, generation/revision checks, and sent-message target ownership with footer controls. Their acknowledgement is the selection feedback; `selected_style` does not recolor the Rich body. No callback-triggered body rewrite is introduced, preventing a stale click from overwriting newer app output. The operator confirmed the post-reload current-client smoke: singleton CML and mixed JSON/CML in-body rows, their ordinary prompt callbacks, a labeled disabled control, and the separate footer callback work as intended. Client type was not recorded. The operator also confirmed that HTML mode projects the in-body groups into the bottom keyboard as intended. Second-client coverage, follower routing, blank cells, and app-method dispatch/revision rejection remain live-gated. Bot API evidence: `InputRichBlockButtons` / Rich Markdown `tg-button-row` and `RichMessageButton` use ordinary `callback_data` and support disabled controls.
 - After Telegram accepts a generated footer button callback as a queued prompt, the bridge changes that exact button to its configured selection style without changing agent-authored text or emoji. Set `selected_style` to `primary` (blue), `success` (green), or `danger` (red); omitted or invalid values fall back to `primary`. The style never suppresses queue admission. Other choices stay visually unchanged and remain available; the callback acknowledgement remains the fallback on clients that do not render button styles.
 - When generated button markup is the entire assistant reply, the bridge supplies the standard `☑️ **Choose an option:**` heading as visible message text so Telegram has a message to which it can attach the inline keyboard.
@@ -197,6 +197,7 @@ The extension injects prompt guidance by context:
 
 - If no bot token is configured, no Telegram bridge suffix is injected.
 - For ordinary local/TUI prompts, the compact routing note points to bundled Skills, including portable `show-me`, while forbidding Telegram use unless explicitly requested.
+- Pi 1.2 custom-message starts may omit the user `prompt`. They retain connected bridge guidance without acquiring Telegram-user origin from their message content; explicit custom origin also overrides any stale prompt field. Legacy user events without `messageType` retain prefix-based Telegram detection. Unavailable transport still strips Telegram tool guidance.
 - For Telegram-originated turns, the compact note routes the agent to `telegram-bridge` for voice/button/direct-delivery/Threaded Mode/formatting/debug guidance and to `show-me` when the user needs a visual explanation of work or behavior.
 - For ordinary Telegram-originated answers, write the full technical answer as phone-width Markdown. `show-me` may instead deliver a focused self-contained HTML artifact when explicitly requested or when spatial density earns it, while keeping the immediate reply useful.
 - Add `telegram_voice` with positional CML by default or JSON when multiline content, named fields, or escaping requires it. A companion summary is optional, no specific summary format is required.

package/node_modules/@llblab/pi-telegram/docs/public-api.md

@@ -75,7 +75,7 @@ Every assistant-authored HTML comment is transport-private on Telegram: previews
 - `telegram_message(text, chat_id?, media?, channel?, thread_id?, thread?)` sends a direct Telegram Markdown message when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus. A public `@username`, or an exact negative numeric channel ID with `channel: true`, is passed as `chat_id` without a local registry; channel delivery requires the direct leader, and Telegram enforces whether the bot has channel posting permission. Channel delivery accepts `media` as one local `.jpg`/`.jpeg`/`.png`/`.webp` photo or `.mp4` video (photo ≤ 10 MiB, video ≤ 50 MiB), uploaded through multipart `sendPhoto`/`sendVideo` with `text` as its HTML caption (≤ 1024 visible characters); unsupported media types and albums are rejected before issuance, and the durable channel-post journal binds media identity and caption so duplicate or lost-acknowledgement retries never re-upload. `thread` accepts a live numeric Thread id or its current acknowledged display title; name matching is case-insensitive and fails closed when absent or ambiguous, while delivery captures the numeric target. During an active Telegram turn, omitted targeting and an explicit target equal to that turn are rejected so the ordinary final-reply path remains the sole current-target response; an explicit different chat/thread target remains allowed. Outside active turns, paired/default local/TUI delivery remains unchanged. Top-level `telegram_button` comments inside `text` are parsed with the same planner used for normal replies and attached to that message; buttons are never standalone Telegram messages.
 - The bundled `telegram-bridge` Skill owns action syntax, target routing, Threaded Mode, formatting, Generative App operation, and profile-specific debugging guidance. The bundled `show-me` Skill owns portable evidence-honest explanations and adapts them to phone-width Markdown or self-contained HTML artifacts when Telegram is the active surface. The regular prompt routes applicable turns to these and the other bundled Skills. Compiled npm/git installations expose them through the package `pi.skills` manifest so Pi resource filters remain authoritative; a raw TypeScript checkout under Pi's `extensions` directory contributes its source Skill root at runtime instead. `telegram_attach`, `telegram_bind`, and `telegram_message` remain registered but are model-active only while this instance owns direct transport or holds a live follower registration; disconnect/loss suppresses their schemas and prompt metadata, and recovery restores only the operator's previously active pi-telegram subset.
 - `telegram_voice` hidden comments request Telegram-native voice delivery through `{text}`, `{text|lang}`, `{text|lang|rate}`, or a JSON object. JSON is the fallback for multiline content, named fields, or escaping; equivalent `text` or `value` supplies the spoken payload, with explicit `text` taking precedence.
-- `telegram_button` hidden comments create footer buttons; standalone column-zero triple-backtick `telegram_button` blocks create button rows between paragraphs in Native Rich Markdown. Both accept the same singleton or mixed JSON/CML matrix and share prompt/app routing; fenced blocks also accept adjacent top-level JSON/CML objects without an outer array or commas as vertical singleton rows. Native rows allow at most eight buttons and must fit one Rich Message chunk; invalid or incomplete blocks register nothing. Drafts hide action fences. HTML compatibility projects fenced controls into the footer. In-body clicks acknowledge without recoloring the Rich body; selected-style highlighting remains footer-only. One marker accepts a JSON object, adaptive JSON/CML matrix, or positional [Compact Matrix Literal](./compact-matrix-literal.md). Named JSON objects and positional cells may coexist in one matrix or row; separators are optional and one trailing comma is tolerated at matrix, row, and JSON-object boundaries. Top-level cells become full-width rows, while nested rows group one or more buttons horizontally without an artificial parser-width cap. CML uses `{value}`, `{label|prompt}`, prompt-only `{|prompt}`, or the corresponding three-atom form with `selected_style`; an omitted label uses the existing prompt-as-label fallback, and the optional third atom requires a non-empty prompt and accepts only `primary`, `success`, or `danger`. A fourth atom accepts `1` or `true` (disabled), and `0` or `false` (enabled), with exact lowercase spelling; an omitted fourth position stays enabled, and the third atom may be empty in this form (`{|Next||1}`). JSON uses boolean `disabled`. Disabled cells need no prompt or selected style: `{Next|||1}` is label-only and `{|||1}` is blank (JSON `{"label":"Next","disabled":true}` and `{"disabled":true}`). The Telegram renderer supplies a non-breaking space only when the label is empty. Disabled cells stay visible but carry `disabled: {}` instead of callback data and register no prompt or bound action; invalid disabled values reject the candidate matrix. It trims atom boundaries and supports only the minimal escapes `\|`, `\}`, and `\\`. Prefer one matrix comment for multiple buttons. Use JSON `label` plus `prompt`, or `value` when both strings are identical. Action markers are colon-free; colon-prefixed payloads are rejected. Use top-level column-zero action wrappers, outside quotes, lists, or enclosing code examples. Ordinary code fences and larger outer fences preserve literal examples; bare JSON/CML in prose never activates.
+- `telegram_button` hidden comments create footer buttons; standalone column-zero triple-backtick `telegram_button` blocks create button rows between paragraphs in Native Rich Markdown. Both accept the same singleton or mixed JSON/CML matrix and share prompt/app routing; both wrappers also accept adjacent complete JSON/CML cells and matrices with optional separators, concatenating their normalized rows in source order. Cells remain singleton rows and nested horizontal rows retain their grouping. Native rows allow at most eight buttons and must fit one Rich Message chunk; invalid or incomplete blocks register nothing. Drafts hide action fences. HTML compatibility projects fenced controls into the footer. In-body clicks acknowledge without recoloring the Rich body; selected-style highlighting remains footer-only. One marker accepts a JSON object, adaptive JSON/CML matrix, or positional [Compact Matrix Literal](./compact-matrix-literal.md). Named JSON objects and positional cells may coexist in one matrix or row; separators are optional and one trailing comma is tolerated at matrix, row, and JSON-object boundaries. Top-level cells become full-width rows, while nested rows group one or more buttons horizontally without an artificial parser-width cap. CML uses `{value}`, `{label|prompt}`, prompt-only `{|prompt}`, or the corresponding three-atom form with `selected_style`; an omitted label uses the existing prompt-as-label fallback, and the optional third atom requires a non-empty prompt and accepts only `primary`, `success`, or `danger`. A fourth atom accepts `1` or `true` (disabled), and `0` or `false` (enabled), with exact lowercase spelling; an omitted fourth position stays enabled, and the third atom may be empty in this form (`{|Next||1}`). JSON uses boolean `disabled`. Disabled cells need no prompt or selected style: `{Next|||1}` is label-only and `{|||1}` is blank (JSON `{"label":"Next","disabled":true}` and `{"disabled":true}`). The Telegram renderer supplies a non-breaking space only when the label is empty. Disabled cells stay visible but carry `disabled: {}` instead of callback data and register no prompt or bound action; invalid disabled values reject the candidate matrix. It trims atom boundaries and supports only the minimal escapes `\|`, `\}`, and `\\`. Prefer one matrix comment for multiple buttons. Use JSON `label` plus `prompt`, or `value` when both strings are identical. Action markers are colon-free; colon-prefixed payloads are rejected. Use top-level column-zero action wrappers, outside quotes, lists, or enclosing code examples. Ordinary code fences and larger outer fences preserve literal examples; bare JSON/CML in prose never activates.
 
 Prompt guidance is context-aware: local/TUI prompts see only explicit direct-delivery guidance, while Telegram-originated turns receive the full action-comment syntax and phone-width output contract.
 

package/node_modules/@llblab/pi-telegram/lib/bindings.ts

@@ -1538,7 +1538,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       promptDispatchRuntime.startTypingLoop(
         ctx,
         turn?.chatId ?? target?.chatId,
-        { target },
+        { target, ensure: true },
       ) !== false
     );
   };
@@ -1547,6 +1547,7 @@ export function registerTelegramLifecycleRuntimeHooks({
     const turn = activeTurnRuntime.get();
     promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId, {
       target: turn?.target,
+      ensure: true,
     });
   };
   let observedAutomaticCompaction = false;

package/node_modules/@llblab/pi-telegram/lib/outbound-markup.ts

@@ -364,7 +364,7 @@ function parseTelegramVoiceCompactActionPayload(
 function parseTelegramAdaptiveActionPayloadRows(
   source: string,
   parseCompactPayload: TelegramCompactActionPayloadParser,
-  options: { allowTrailing?: boolean; maxCompactAtoms?: number } = {},
+  options: { allowTrailing?: boolean; maxCompactAtoms?: number; allowMatrixGroups?: boolean } = {},
 ): { rows: Record<string, unknown>[][]; end: number } | undefined {
   let offset = 0;
   const isStructuralWhitespace = (character: string | undefined): boolean =>
@@ -512,21 +512,29 @@ function parseTelegramAdaptiveActionPayloadRows(
     return undefined;
   };
 
-  const parseVerticalSequence = (): Record<string, unknown>[][] | undefined => {
+  const parseTopLevelRows = (): Record<string, unknown>[][] | undefined => {
     const rows: Record<string, unknown>[][] = [];
     while (offset < source.length) {
       skipWhitespace();
-      if (source[offset] !== "{") break;
-      const cell = parseCell();
-      if (!cell) return undefined;
-      rows.push([cell]);
+      const character = source[offset];
+      if (character === "{") {
+        const cell = parseCell();
+        if (!cell) return undefined;
+        rows.push([cell]);
+      } else if (character === "[" && options.allowMatrixGroups) {
+        const matrix = parseMatrix();
+        if (!matrix) return undefined;
+        rows.push(...matrix);
+      } else {
+        break;
+      }
       if (!consumeOptionalSeparator()) return undefined;
     }
     return rows.length > 0 ? rows : undefined;
   };
 
   skipWhitespace();
-  const rows = source[offset] === "{" ? parseVerticalSequence() : parseMatrix();
+  const rows = parseTopLevelRows();
   if (!rows) return undefined;
   skipWhitespace();
   if (!options.allowTrailing && offset !== source.length) return undefined;
@@ -581,7 +589,7 @@ export function parseTelegramButtonPayloadRows(
   return parseTelegramAdaptiveActionPayloadRows(
     source.trim(),
     parseTelegramButtonCompactActionPayload,
-    { maxCompactAtoms: 4 },
+    { maxCompactAtoms: 4, allowMatrixGroups: true },
   )?.rows;
 }
 
@@ -596,7 +604,7 @@ export function parseTelegramActionPayloadRows(
       parseTelegramAdaptiveActionPayloadRows(
         content.slice(offset),
         parseTelegramButtonCompactActionPayload,
-        { allowTrailing: true, maxCompactAtoms: 4 },
+        { allowTrailing: true, maxCompactAtoms: 4, allowMatrixGroups: true },
       )?.rows,
   );
   if (!scanned) return undefined;

package/node_modules/@llblab/pi-telegram/lib/prompts.ts

@@ -150,10 +150,13 @@ export function createTelegramModelContextAvailabilityRuntime(deps: {
 
 export type TelegramSystemPrompt = string | string[];
 
+// Pi 1.0 user events lack messageType; Pi 1.2 custom starts carry no user prompt.
 type TelegramBeforeAgentStartEvent = Omit<
   BeforeAgentStartEvent,
-  "systemPrompt"
+  "systemPrompt" | "prompt" | "messageType"
 > & {
+  messageType?: "user" | "custom";
+  prompt?: string;
   systemPrompt?: TelegramSystemPrompt | null;
 };
 
@@ -166,7 +169,7 @@ type TelegramBeforeAgentStartHook = (
 ) => TelegramBeforeAgentStartResult;
 
 export function buildTelegramBridgeSystemPrompt(options: {
-  prompt: string;
+  prompt?: string;
   systemPrompt?: TelegramSystemPrompt | null;
   telegramPrefix?: string;
   localSystemPromptSuffix: string;
@@ -177,7 +180,7 @@ export function buildTelegramBridgeSystemPrompt(options: {
   const telegramHead = telegramPrefix.endsWith("]")
     ? telegramPrefix.slice(0, -1)
     : telegramPrefix;
-  const trimmedPrompt = options.prompt.trimStart();
+  const trimmedPrompt = options.prompt?.trimStart() ?? "";
   const telegramTurn =
     trimmedPrompt.startsWith(`${telegramHead}]`) ||
     trimmedPrompt.startsWith(`${telegramHead}|`);
@@ -200,7 +203,7 @@ export function createTelegramBeforeAgentStartHook(
 ): TelegramBeforeAgentStartHook {
   return (event) =>
     buildTelegramBridgeSystemPrompt({
-      prompt: event.prompt,
+      prompt: event.messageType === "custom" ? undefined : event.prompt,
       systemPrompt: event.systemPrompt,
       telegramPrefix: options.telegramPrefix,
       localSystemPromptSuffix:

package/node_modules/@llblab/pi-telegram/lib/runtime.ts

@@ -364,8 +364,16 @@ export function createTelegramTypingLoopStarter<TContext>(
 ): (
   ctx: TContext,
   chatId?: number,
-  options?: { target?: TelegramTypingLoopTarget },
+  options?: { target?: TelegramTypingLoopTarget; ensure?: boolean },
 ) => boolean {
+  let currentOwner: {
+    ctx: TContext;
+    sessionGeneration: number | undefined;
+    transportAuthority: string | number | undefined;
+    chatId: number;
+    threadId: number | undefined;
+    canContinue: () => boolean;
+  } | undefined;
   return (ctx, chatId, options) => {
     const sessionGeneration = deps.getSessionGeneration?.();
     const transportAuthority = deps.getTransportAuthority?.();
@@ -382,9 +390,22 @@ export function createTelegramTypingLoopStarter<TContext>(
         (target?.threadId !== undefined && Number.isSafeInteger(target.threadId) && target.threadId > 0));
     // Queue dispatch precedes agent_start: only an explicit destination permits Threaded presence, never chat fallback.
     if (!canContinue()) return false;
+    const resolvedChatId = chatId ?? deps.getDefaultChatId();
+    if (resolvedChatId === undefined || resolvedChatId === 0) return false;
+    // Streaming updates ensure presence without revoking the same owner's pending HTTP/IPC action.
+    // Explicit starts still replace the loop, including a new turn on the same session and Thread.
+    if (options?.ensure && currentOwner?.canContinue() &&
+      (deps.getSessionGeneration
+        ? Object.is(currentOwner.sessionGeneration, sessionGeneration)
+        : Object.is(currentOwner.ctx, ctx)) &&
+      Object.is(currentOwner.transportAuthority, transportAuthority) &&
+      currentOwner.chatId === resolvedChatId && currentOwner.threadId === target?.threadId) return false;
+    const owner = { ctx, sessionGeneration, transportAuthority, chatId: resolvedChatId,
+      threadId: target?.threadId, canContinue };
+    currentOwner = owner;
     let active = true;
     return deps.typing.start({
-      chatId: chatId ?? deps.getDefaultChatId(),
+      chatId: resolvedChatId,
       target,
       intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
       sendTypingAction: async (targetChatId, actionOptions) => {
@@ -419,6 +440,7 @@ export function createTelegramTypingLoopStarter<TContext>(
       shouldContinue: canContinue,
       onStopped: () => {
         active = false;
+        if (currentOwner === owner) currentOwner = undefined;
       },
     });
   };
@@ -722,7 +744,7 @@ export interface TelegramPromptDispatchRuntime<TContext> {
   startTypingLoop: (
     ctx: TContext,
     chatId?: number,
-    options?: { target?: TelegramTypingLoopTarget },
+    options?: { target?: TelegramTypingLoopTarget; ensure?: boolean },
   ) => boolean | void;
   onPromptDispatchStart: (ctx: TContext, chatId?: number, target?: TelegramTypingLoopTarget) => void;
   onPromptDispatchFailure: (ctx: TContext, message: string) => void;

package/node_modules/@llblab/pi-telegram/package.json

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

package/node_modules/@llblab/pi-telegram/skills/telegram-bridge/SKILL.md

@@ -60,7 +60,7 @@ Every enabled button has a self-contained prompt and an optional selection style
 - `{label|prompt}` separates visible label from queued prompt.
 - `{label|prompt|selected_style}` and `{|prompt|selected_style}` accept `primary`, `success`, or `danger`.
 - Fourth-position `1`/`true` disables, `0`/`false` enables; omission means enabled. JSON uses boolean `disabled`. `{|Next||1}` omits label/style; `{Next|||1}` omits prompt/style; `{|||1}` is blank (Telegram receives a non-breaking space). Prefer meaningful labels and retain a useful enabled action. Enabled CML requires a prompt. Disabled controls stay visible but have no callback, queued prompt, or bound-method invocation.
-- Top-level cells form vertical rows; inside a fenced block, adjacent top-level JSON/CML objects may omit the outer array and commas. One nested row groups horizontal peers.
+- Both wrappers concatenate rows from adjacent JSON/CML cells or matrices, with optional commas. Cells are vertical; horizontal peers require a nested row: `[[{A|a}{B|b}]]`.
 - Prefer one matrix per related group. Fenced blocks stay in place in Rich mode; HTML compatibility moves them to the footer. Native rows allow eight buttons. Malformed/oversized/unclosed blocks activate nothing; drafts hide them. Outer code fences and quoted/indented examples remain literal.
 - Both placements share prompt/app routing. In-body clicks acknowledge without recoloring; selected-style highlighting remains footer-only.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.34.1",
+  "version": "0.34.3",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -42,12 +42,12 @@
   ],
   "dependencies": {
     "@llblab/pi-actors": "0.54.0",
-    "@llblab/pi-claude-usage": "0.2.1",
+    "@llblab/pi-claude-usage": "0.2.2",
     "@llblab/pi-clean-room": "0.3.0",
-    "@llblab/pi-codex-usage": "0.13.0",
+    "@llblab/pi-codex-usage": "0.13.1",
     "@llblab/pi-grow-loop": "0.9.0",
     "@llblab/pi-state-flow": "0.26.4",
-    "@llblab/pi-telegram": "0.56.2",
+    "@llblab/pi-telegram": "0.56.4",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [