@llblab/pi-telegram 0.25.0 → 0.25.1

package/AGENTS.md

@@ -121,7 +121,7 @@ The core product loop is mobile continuation: start or supervise work in the ter
 - Forward-annotation grouping distinguishes two semantic layers: the forward owns its source text/caption/media, while an optional separate owner-authored annotation normally arrives immediately before it. Use a bounded one-second candidate window in both transport orders: ordinary short human text may wait for an adjacent same-sender/chat/thread forward, and a forwarded message—including a media-only forward with no source caption—may wait for one adjacent owner annotation. A matching opposite-kind message flushes immediately; same-kind messages, commands, bots, ordinary non-forward captions, media groups, target/sender mismatches, reversed ids, and distant ids stay separate. Preserve the candidate across session replacement and follower forwarding without weakening exact routing-generation authority.
 - `telegram_voice` and `telegram_button` are not Pi tools; keep prompts/docs explicit that agents should author markup while voice synthesis provider extensions own TTS/OGG conversion, and pi-telegram owns button routing plus Telegram delivery
 - Voice reply policy and prompt context are owned by pi-telegram's `telegram.json` `voice.replyMode`: missing, invalid, `hidden`, and legacy `manual` config resolve to `hidden` and add no `[voice]` context; `mirror` adds `[voice] delivery: automatic voice` only for voice/audio input, while `always` adds that same single factual line to every Telegram turn. Place voice context after `[outputs]` when handler output exists, otherwise after `[attachments]`; provider prompt contributions are optional provider-specific additions, not the default policy or delivery-composition channel.
-- Optional `telegram.json` `time` may add `[time] YYYY-MM-DD HH:mm:ss <timezone>` to Telegram-originated prompts for wall-clock context. It is hidden by default, uses `time.injectionMode` values `hidden|always|interval`, stores `time.interval` in milliseconds, uses the system timezone, and should render last after `[attachments]`, `[outputs]`, and `[voice]` sections. The Settings row `🕒 Time injection: hidden|always|interval` controls `time.injectionMode` only.
+- Optional Telegram wall-clock context may add `[time] YYYY-MM-DD HH:mm:ss <timezone>` to Telegram-originated prompts. It is hidden by default, uses `assistant.timeInjection` values `hidden|always|interval`, stores the interval duration separately as `time.interval` in milliseconds, uses the system timezone, and should render last after `[attachments]`, `[outputs]`, and `[voice]` sections. The Settings row `🕒 Time injection: hidden|always|interval` controls only `assistant.timeInjection`; the old `time.injectionMode` key is ignored and is not migrated.
 - Agent activity status is native-only for the release path: Telegram uses `sendChatAction(typing)` and renders its native `…typing` indicator as the automatic work signal. When a connected instance starts any real agent run, send that indicator to the instance's own thread (and aggregate `All` surface), including Telegram turns, local/TUI prompts, and autonomous continuations such as Grow Loop; stop it at agent/session completion. Keep at most one chat action in flight per loop, coalesce identical leader-side actions across follower traffic, and treat Telegram 429 `retry_after` as a shared suppression window rather than a delayed retry or persistent terminal error. This signal is independent from terminal `Active`, which remains scoped to Telegram-owned turns. Confirmed manual `/compact` and automatic compaction tied to an active Telegram turn also use native activity. Do not send activity merely for startup/connect/reload/recovery or add extra in-chat work surfaces without a new explicit design decision.
 - Voice reply mode Settings UI standard: the top-level Settings row is `👄 Voice reply: hidden|mirror|always`; `hidden` is the true default, persists no `voice.replyMode`, adds no voice context, and still allows explicit agent-authored `telegram_voice`; `mirror` activates automatic voice context only for voice/audio input, and `always` activates it for every Telegram turn. The submenu title is `👄 Voice reply mode:`; choice buttons use lowercase labels with a model-style active dot (`🟢 hidden`, `🟢 mirror`) rather than per-mode emoji; the explanatory submenu body uses compact HTML-code bullets such as `<code>-</code> <code>hidden</code> (default): ...`. Preserve this wording/icons unless the operator explicitly asks to redesign it
 - Outbound voice delivery is one fallback pipeline: configured `outboundHandlers` with `type: "voice"` run first in `telegram.json` order, then programmatic voice handlers, then registered voice synthesis providers as zero-config progressive fallbacks; provider extensions must not override operator-configured handlers

package/BACKLOG.md

@@ -2,24 +2,17 @@
 
 _This backlog tracks only open release-relevant work: hotfixes, bounded maintenance, live runtime verification, evidence-gated Telegram client follow-ups, and upstream Pi API blockers. Completed outcomes and validation evidence belong in `CHANGELOG.md`, not in this queue._
 
-## P1 — 0.25.0 Configurable Activity Verbosity
+## P1 — Configurable Activity Live Smoke
 
-Context: Start the next minor release with an operator-controlled Telegram activity surface. Current behavior remains the quiet default: users receive assistant previews, intermediate public prose, and final answers without model reasoning or tool traffic. A new verbose mode should add compact technical reasoning and tool activity without turning bridge-owned UI into Markdown or mixing it into the semantic answer stream.
+Context: `0.25.0` shipped quiet-by-default configurable activity verbosity. The remaining work is live Telegram client verification of verbose reasoning and compact technical tool activity.
 
 Bot API evidence: Bot API 10.2 exposes explicit outgoing Rich Message blocks. `InputRichBlockThinking` is draft-only and disappears when the draft lifecycle ends; `InputRichBlockDetails` provides a collapsed disclosure container, and `InputRichBlockPreformatted` provides nested `<pre><code>` content. Exact mobile/Desktop rendering, edit behavior, and practical limits remain live-verification gates.
 
 Open work:
 
-- [x] Add a persisted `Activity` Settings option backed by `assistant.activity`, with exactly two initial values: `quiet` (default/current behavior) and `verbose` (reasoning plus tool activity). Omitted or invalid configuration must resolve to `quiet`; legacy `assistant.activityVerbosity` is read only when the canonical key is absent and removed on the next write. Settings must follow the existing nested list-option UI and callback/persistence concurrency contracts.
-- [x] In `verbose`, stream reasoning content exposed by supported Pi lifecycle events through a short-lived Telegram Rich Draft `Thinking` block bound to the exact chat/thread, profile, session generation, and direct-owner or follower authority. Finalization, cancellation, failure, replacement, and disconnect must clear local draft ownership without creating a persisted reasoning message or projecting unavailable provider-private chain-of-thought.
-- [x] Persist completed tool activity as bridge-owned compact ordinary HTML messages rather than assistant Markdown or Rich Messages. Render each tool call under one registered semantic icon and tool name with bounded, escaped arguments, updates, result, and error evidence inside a standard expandable blockquote.
-- [x] Coalesce consecutive tool calls from one ordered run into the same editable ordinary message while it remains within Telegram HTML message limits, with one independent expandable blockquote per call. Start a new message when the current message cannot safely accept another block; never reorder tools across assistant prose, reasoning boundaries, targets, runs, or lifecycle generations.
-- [x] Define bounded output, redaction, truncation, retry, edit-ambiguity, and transport-failure behavior so verbose mode cannot leak known secrets, flood the target, replay a possibly committed message, block Pi lifecycle completion, or disturb quiet-mode preview/final ordering. Record failures through existing diagnostics.
-- [x] Reconcile the current no-hidden-reasoning invariant and Rich rendering boundary in `AGENTS.md`, then update README, Settings/configuration docs, architecture/outbound docs, public activity guidance, UI emoji registry, and focused config/menu/activity/delivery/rendering/integration regressions.
-- [x] Order first-level `Settings` by operator meaning while keeping `⬆️ Main menu` first: message presentation (`Draft previews`, `Rendering`, `Voice reply`), technical/public activity (`Activity`, `Proactive push`), prompt context (`Time injection`), then lifecycle (`Thread cleanup`). Append extension-provided rows using their explicit `settings.order` and stable section-id tie-break, preserve each detail submenu's semantic option order, and add focused menu/section regressions.
 - [ ] Live-smoke both modes in classic and Threaded Mode on Telegram mobile and Desktop, including multiple sequential tools, oversized output rollover, cancellation during reasoning, tool failure, session replacement, follower transport, and final-answer ordering.
 
-Done when: `quiet` remains behaviorally unchanged, `verbose` shows ephemeral reasoning plus durable collapsed tool-call evidence with exact routing and bounded safe output, first-level Settings entries follow the documented semantic groups with deterministic extension ordering, Settings survives reload and concurrent persistence, all automated validation passes, and live clients confirm the intended draft/disclosure UX.
+Done when: live mobile and Desktop clients confirm the intended quiet/verbose draft, disclosure, routing, rollover, cancellation, failure, and final-answer ordering behavior in classic and Threaded Mode.
 
 ## P1 — Native Windows Runtime Smoke
 

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.25.1: Config And Activity Presentation
+
+- `Time Injection Config`: Moved the Settings-owned mode to `assistant.timeInjection`, while retaining `time.interval` as the independent interval duration. The old `time.injectionMode` key is ignored without fallback, migration, or automatic rewriting. Impact: assistant presentation controls share one config domain without silently mutating historical user data.
+- `Verbose Tool Evidence`: Quoted argument, update, result, and error labels as JSON-style properties and compacted arrays of object entries to `[{ ... }, { ... }]` while retaining readable fields, evidence order, redaction, truncation, and delivery bounds. Impact: multi-entry tool updates consume less vertical space without losing technical evidence.
+
 ## 0.25.0: Configurable Activity
 
 - `Activity`: Added a persisted quiet-by-default `assistant.activity` Settings control. Verbose mode streams only provider-exposed reasoning through ephemeral target-fenced Rich Thinking drafts, projects inline Markdown bold/code markers to native Rich Text, and records completed executed tools through memory/transport-bounded ordinary HTML messages with standard expandable blockquotes; tool activity never uses Rich Messages. Tool headers use `🛠  <tool>: <status>` with a monospace `running`, `done`, or `failed` status, while argument, update, result, and error labels sit directly before their serialized values (`arguments: {`, `result: {`) for compact scanning. Settings refreshes always read the live value; legacy `assistant.activityVerbosity` is accepted only when the canonical key is absent and removed on the next write. Consecutive ordered tools coalesce without crossing assistant/reasoning, target, activity, or transport-generation boundaries. Final delivery waits behind admitted technical activity inside the background delivery task, while replacement sessions abandon queued old-generation work immediately. Impact: operators can inspect compact redacted technical activity without stale menu state, mixing it into assistant answers, exposing it by default, replaying ambiguous sends, reordering the final answer, or delaying Pi lifecycle completion.

package/docs/outbound.md

@@ -17,7 +17,7 @@ Proactive blocks use `assistant.rendering` independently of voice policy. Rich m
 `assistant.activity` defaults to `quiet`. In `verbose`, the bridge consumes the same normalized Activity stream without mixing technical UI into assistant Markdown:
 
 - Provider-exposed reasoning deltas update a bounded ephemeral `sendRichMessageDraft` containing one `Thinking` block. Inline Markdown bold and code markers are projected to native Rich Text so their delimiters do not appear literally; unmatched streaming delimiters remain plain text until a later complete draft. The draft is fenced to its captured chat/thread and transport generation; settlement, cancellation, replacement, disconnect, or authority loss drops local ownership. It is never converted into a persisted reasoning message, and providers that expose no reasoning produce none.
-- Completed executed tools use ordinary `sendMessage` HTML, never `sendRichMessage`. Each tool header renders as `🛠  <tool>: <status>`, with a stable two-space visual gap after the icon and the `running`, `done`, or `failed` status in monospace. One standard Telegram `<blockquote expandable>` then contains bounded redacted evidence in chronological order. Labels share a line with their serialized value opening, for example `arguments: {`, `update 1: {`, and `result: {` or `error: {`.
+- Completed executed tools use ordinary `sendMessage` HTML, never `sendRichMessage`. Each tool header renders as `🛠  <tool>: <status>`, with a stable two-space visual gap after the icon and the `running`, `done`, or `failed` status in monospace. One standard Telegram `<blockquote expandable>` then contains bounded redacted evidence in chronological order. JSON-style labels share a line with their serialized value opening, for example `"arguments": {`, `"update 1": {`, and `"result": {` or `"error": {`; arrays of object entries use the denser `[{ ... }, { ... }]` layout while retaining indented fields.
 - Consecutive tools coalesce by editing one message only while target, activity, generation, ordering boundary, tool count, and serialized-size bounds still match. Assistant or reasoning content closes the batch. A non-idempotent send with unknown commit state is never replayed; failed or ambiguous edits start no fallback send.
 
 Reasoning retains only a bounded latest-text window, tool updates retain only a bounded latest-entry window, and a session reset abandons queued old-generation work without making the replacement session wait for an old transport call. Final-answer delivery waits for the admitted verbose activity queue inside the extension-owned background delivery task, so completed tool evidence cannot be overtaken by the semantic answer and Pi lifecycle completion remains non-blocking.

package/docs/public-api.md

@@ -96,13 +96,13 @@ interface TelegramConfig {
     rendering?: "rich" | "html";
     proactivePush?: boolean;
     activity?: "quiet" | "verbose";
+    timeInjection?: "hidden" | "always" | "interval";
   };
   voice?: {
     replyMode?: "hidden" | "mirror" | "always";
     sendTranscript?: boolean;
   };
   time?: {
-    injectionMode?: "hidden" | "always" | "interval";
     interval?: number;
   };
   threads?: {
@@ -122,7 +122,7 @@ Hidden/default semantics are represented by absence:
 - `assistant.activity` accepts exactly `"quiet"` or `"verbose"` and resolves omitted or invalid values to `"quiet"`. Quiet preserves the answer-only behavior. Verbose adds provider-exposed reasoning as an ephemeral target-bound Rich `Thinking` draft. Completed tool activity uses ordinary HTML `sendMessage`/`editMessageText`, with each tool represented by a standard expandable blockquote containing bounded redacted arguments, retained updates, results, and errors; tool output never uses Rich Messages. Consecutive tools coalesce only inside the same ordered activity segment and bounded message. Legacy `assistant.activityVerbosity` is read only when `assistant.activity` is absent and is removed by the next Activity Settings write.
 - Voice Reply `hidden`: no `voice.replyMode` key is persisted; legacy `manual` resolves to this silent default. `mirror` adds `[voice] delivery: automatic voice` only to voice/audio-input turns, while `always` adds the same effective line to every Telegram turn.
 - Agent activity status is not configurable in this release. Telegram uses native `sendChatAction(typing)` / product `...active` status as the only automatic in-chat work signal before the final reply.
-- Time Injection `hidden`: no `time.injectionMode` key is persisted; if `time` becomes empty, the whole `time` object may be omitted.
+- `assistant.timeInjection` accepts `hidden`, `always`, or `interval` and defaults to `hidden`. Settings writes the selected value there, including `hidden`; the old `time.injectionMode` key is ignored and is not migrated. `time.interval` remains the optional interval duration in milliseconds.
 
 With `assistant.rendering: "rich"` (the default), assistant Markdown delivery is native: final replies are sent as `InputRichMessage.markdown` via `sendRichMessage`, and draft previews use `sendRichMessageDraft` when a structurally closed preview frame is available. Draft-frame failures are recorded and skipped rather than converted into raw plain preview messages, because partial Markdown can be temporarily invalid while the final answer remains valid. Long native replies are split at Telegram Rich Message transport limits, with oversized fenced code, display-math, and fully wrapped inline-formatting blocks rewrapped per chunk so persisted chunks remain structurally valid. Guest replies use `InputRichMessageContent` in `answerGuestQuery` results. Bridge-owned UI surfaces such as menus, status, queue controls, commands, and sections keep explicit Telegram HTML/plain rendering by default because those texts are authored by the bridge or companion extensions for Telegram UI. Companion extension sections may explicitly request `"markdown"`, `"html"`, or `"plain"` per view. `assistant.rendering: "html"` keeps the compatibility path that converts assistant Markdown to Telegram HTML before ordinary message delivery. The bridge sets `skip_entity_detection: true` for assistant and guest Markdown so technical text such as `/commands`, hashtags, URLs, phone numbers, and card-like numbers does not gain unintended automatic entities; explicit Markdown links still belong in the Markdown source.
 

package/lib/activity-verbosity.ts

@@ -86,11 +86,71 @@ function renderReasoningRichText(text: string): TelegramRichText {
   return parts.length === 1 ? parts[0]! : parts;
 }
 
+function formatActivityJson(value: unknown, depth = 0): string[] {
+  const indent = "  ".repeat(depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [`${indent}[]`];
+    if (
+      value.every(
+        (entry) =>
+          entry !== null && typeof entry === "object" && !Array.isArray(entry),
+      )
+    ) {
+      const lines = [`${indent}[{`];
+      value.forEach((entry, index) => {
+        const fields = Object.entries(entry as Record<string, unknown>);
+        fields.forEach(([key, nested], fieldIndex) => {
+          const nestedLines = formatActivityJson(nested, depth + 1);
+          const nestedIndent = "  ".repeat(depth + 1);
+          lines.push(
+            `${nestedIndent}${JSON.stringify(key)}: ${nestedLines[0]!.slice(nestedIndent.length)}`,
+            ...nestedLines.slice(1),
+          );
+          if (fieldIndex < fields.length - 1) {
+            lines[lines.length - 1] += ",";
+          }
+        });
+        lines.push(
+          index < value.length - 1 ? `${indent}}, {` : `${indent}}]`,
+        );
+      });
+      return lines;
+    }
+    const lines = [`${indent}[`];
+    value.forEach((entry, index) => {
+      const nestedLines = formatActivityJson(entry, depth + 1);
+      if (index < value.length - 1) {
+        nestedLines[nestedLines.length - 1] += ",";
+      }
+      lines.push(...nestedLines);
+    });
+    lines.push(`${indent}]`);
+    return lines;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>);
+    if (entries.length === 0) return [`${indent}{}`];
+    const lines = [`${indent}{`];
+    entries.forEach(([key, nested], index) => {
+      const nestedLines = formatActivityJson(nested, depth + 1);
+      const nestedIndent = "  ".repeat(depth + 1);
+      lines.push(
+        `${nestedIndent}${JSON.stringify(key)}: ${nestedLines[0]!.slice(nestedIndent.length)}`,
+        ...nestedLines.slice(1),
+      );
+      if (index < entries.length - 1) lines[lines.length - 1] += ",";
+    });
+    lines.push(`${indent}}`);
+    return lines;
+  }
+  return [`${indent}${JSON.stringify(value)}`];
+}
+
 function serializeActivityValue(value: unknown): string {
   const seen = new WeakSet<object>();
   let text: string;
   try {
-    text =
+    const normalized =
       JSON.stringify(
         value,
         (_key, nested) => {
@@ -101,8 +161,8 @@ function serializeActivityValue(value: unknown): string {
           }
           return nested;
         },
-        2,
       ) ?? JSON.stringify(String(value));
+    text = formatActivityJson(JSON.parse(normalized)).join("\n");
   } catch {
     text = JSON.stringify(String(value));
   }
@@ -113,17 +173,17 @@ function serializeActivityValue(value: unknown): string {
 }
 
 function renderToolActivityHtml(tool: ToolActivity): string {
-  const evidence = [`arguments: ${tool.args}`];
+  const evidence = [`"arguments": ${tool.args}`];
   if (tool.droppedUpdates > 0) {
     evidence.push(`… [${tool.droppedUpdates} earlier updates omitted]`);
   }
   tool.updates.forEach((update, index) => {
     evidence.push(
-      `update ${tool.droppedUpdates + index + 1}: ${update}`,
+      `"update ${tool.droppedUpdates + index + 1}": ${update}`,
     );
   });
   if (tool.complete && tool.result !== undefined) {
-    evidence.push(`${tool.isError ? "error" : "result"}: ${tool.result}`);
+    evidence.push(`"${tool.isError ? "error" : "result"}": ${tool.result}`);
   }
   const status = tool.complete
     ? tool.isError

package/lib/config.ts

@@ -44,7 +44,6 @@ export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConf
 export type TelegramTimeMode = "hidden" | "always" | "interval";
 
 export interface TelegramTimeConfig {
-  injectionMode?: TelegramTimeMode;
   interval?: number;
 }
 
@@ -76,6 +75,7 @@ export interface TelegramConfig {
     rendering?: TelegramAssistantRenderingMode;
     proactivePush?: boolean;
     activity?: TelegramActivityVerbosity;
+    timeInjection?: TelegramTimeMode;
     /** @deprecated use activity */
     activityVerbosity?: TelegramActivityVerbosity;
   };
@@ -834,10 +834,11 @@ function getSystemTimezone(): string {
 
 export function resolveTelegramTimeConfig(
   raw: TelegramTimeConfig | undefined,
+  timeInjection: TelegramTimeMode | undefined = undefined,
 ): ResolvedTelegramTimeConfig {
   const injectionMode: TelegramTimeMode =
-    raw?.injectionMode === "always" || raw?.injectionMode === "interval"
-      ? raw.injectionMode
+    timeInjection === "always" || timeInjection === "interval"
+      ? timeInjection
       : "hidden";
   const interval =
     typeof raw?.interval === "number" && raw.interval > 0
@@ -850,13 +851,25 @@ export function resolveTelegramTimeConfig(
 export function createTelegramTimeConfigGetter(
   configStore: Pick<TelegramConfigStore, "get">,
 ): () => ResolvedTelegramTimeConfig {
-  return () => resolveTelegramTimeConfig(configStore.get().time);
+  return () => {
+    const config = configStore.get();
+    return resolveTelegramTimeConfig(
+      config.time,
+      config.assistant?.timeInjection,
+    );
+  };
 }
 
 export function createTelegramTimeInjectionModeGetter(
   configStore: Pick<TelegramConfigStore, "get">,
 ): () => TelegramTimeMode {
-  return () => resolveTelegramTimeConfig(configStore.get().time).injectionMode;
+  return () => {
+    const config = configStore.get();
+    return resolveTelegramTimeConfig(
+      config.time,
+      config.assistant?.timeInjection,
+    ).injectionMode;
+  };
 }
 
 export function createTelegramTimeInjectionModeSetter(
@@ -865,19 +878,12 @@ export function createTelegramTimeInjectionModeSetter(
   return async (injectionMode) => {
     await loadLatestTelegramConfig(configStore);
     const current = configStore.get();
-    if (injectionMode === "hidden") {
-      const { injectionMode: _injectionMode, ...remainingTime } =
-        current.time ?? {};
-      const next = { ...current };
-      if (Object.keys(remainingTime).length > 0) next.time = remainingTime;
-      else delete next.time;
-      configStore.set(next);
-      await configStore.persist(next);
-      return;
-    }
     const next = {
       ...current,
-      time: { ...(current.time ?? {}), injectionMode },
+      assistant: {
+        ...(current.assistant ?? {}),
+        timeInjection: injectionMode,
+      },
     };
     configStore.set(next);
     await configStore.persist(next);

package/package.json

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