@llblab/pi-kit 0.34.2 → 0.34.3

package/BACKLOG.md

@@ -4,6 +4,7 @@ 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.

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.

package/README.md

@@ -18,7 +18,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@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.3` | 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-telegram/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ## 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.

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/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.3",
+  "version": "0.56.4",
   "private": false,
   "publishConfig": {
     "access": "public"

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
 

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/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.3",
+  "version": "0.56.4",
   "private": false,
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.34.2",
+  "version": "0.34.3",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -47,7 +47,7 @@
     "@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.3",
+    "@llblab/pi-telegram": "0.56.4",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [