@llblab/pi-telegram 0.26.12 → 0.26.14

package/BACKLOG.md

@@ -2,19 +2,6 @@
 
 _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._
 
-## P0 — Monospaced Tool Evidence Keys
-
-Context: nested `arguments`, `update`, `result`, and `error` summaries already behave like quote-free outer JSON keys. Rendering the lowercase label itself as inline code completes that semantic relationship without reintroducing icons, markers, or extra height.
-
-Open work:
-
-- [x] Render every nested tool evidence summary as one lowercase monospaced label, retaining omission suffixes inside the same code span.
-- [x] Preserve root styling, Arguments open-by-default behavior, collapsed secondary evidence, JSON blocks, and all delivery guarantees.
-- [x] Update focused regressions, durable UI documentation, changelog, and package metadata.
-- [ ] Pass live Telegram smoke plus two fresh Linux/macOS/Windows matrices before release.
-
-Done when: child keys read as compact code-like metadata, hierarchy and behavior remain unchanged, live clients confirm the style, and the guarded hotfix release completes.
-
 ## P1 — Windows Graceful Disconnect Test Budget
 
 Context: the graceful follower-disconnect integration overrides the production 30-second bus budget with 500 milliseconds even though the path persists cleanup intent, performs close/delete operations, updates binding state, and returns an authenticated response. A loaded Windows runner exceeded that artificial deadline while the same focused path completes promptly under normal scheduling.

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.26.14: Reasoning Activity Throttle
+
+- `Reasoning Throttle`: Added a minimum interval between reasoning-block edits (`TELEGRAM_REASONING_MIN_INTERVAL_MS = 1_200`) so the first frame publishes immediately while later frames wait until both the interval and the 160-char delta threshold pass. The final `reasoning-end`/`agent-end` flush stays unconditional, and the 24-frame cap is unchanged. Impact: fast-token models with very large reasoning blocks no longer push an edit per character burst, so parallel threads stop saturating the bus and inbound Telegram messages arrive without multi-second delay.
+
+## 0.26.13: Entrypoint Compression And BotFather Prerequisites
+
+- `Entrypoint Compression`: Moved low-level policy out of `index.ts` into owning domains: the deferred queue dispatch delay defaults in the queue domain, the delivery generation seed is built by the delivery domain, the `target-bindings` sync slice key and the default profile name resolve from their domains, and bus-runtime capability answers come from the thread capability state. Removed a redundant follower client timeout literal that duplicated the domain default. Impact: the composition root wires ports while constants, generations, and capability decisions stay with their owning domains.
+- `Assembly Ownership`: Extracted the follower assembly (receiver, target replacement, recovery, registration) and session-lifecycle assembly (queue, follower, services) dependency structures into builders owned by `bus-follower` and `lifecycle`, normalizing shared ports and moving auth-secret derivation and grouped-input sequencing into domain runtimes. Impact: assembly shape and policy live in the owning domains, and the entrypoint reads as named construction steps instead of nested constructor calls.
+- `Setup Documentation`: Documented the BotFather prerequisites for guest mode, private-chat Threaded Mode, and queue-reaction admin rights in the Quick Start. Impact: operators can enable the capabilities a feature needs instead of discovering that a disabled capability silently never triggers.
+
 ## 0.26.12: Monospaced Tool Evidence Keys
 
 - `Tool Evidence Typography`: Rendered nested `arguments`, `update`, `result`, and `error` summaries as lowercase inline code, including any dropped-update suffix in the same span. Impact: child labels read as compact quote-free outer JSON keys while root styling, disclosure state, evidence blocks, message height, and delivery guarantees remain unchanged.

package/README.md

@@ -67,6 +67,14 @@ Open the bot DM and send:
 
 The first Telegram user to message the bot becomes the allowed owner. Other users are ignored.
 
+### 5. Enable optional bot capabilities in BotFather
+
+Enable the optional capabilities the bridge needs in [@BotFather](https://t.me/BotFather). The bridge does not fail loudly when a capability is off; the feature simply never triggers.
+
+1. Enable guest mode so the bot can answer mentions and replies in chats where it is not a member.
+2. Enable private-chat Threaded Mode; when it is available, one live instance becomes the profile's leader and later visible Pi instances register as followers. Without it, the bridge stays in classic single-owner DM mode.
+3. Make the bot an administrator in any chat where the queue reaction shortcuts (👍 promote, 👎 remove) should work. Reaction updates require admin rights, so the shortcuts silently do nothing in non-admin chats; private chats deliver reactions without admin rights.
+
 ## What It Feels Like
 
 - Start a task in the terminal, walk away, and keep supervising it from your phone.

package/index.ts

@@ -107,7 +107,7 @@ export default function (pi: Pi.ExtensionAPI) {
     Ownership.createTelegramBusMessageOwnershipRuntime({
       instanceId: telegramInstanceId,
       getProfileKey() {
-        return getActiveTelegramThreadProfile() ?? "default";
+        return getActiveTelegramThreadProfile() ?? Config.TELEGRAM_DEFAULT_PROFILE_NAME;
       },
       listFollowers: telegramBusFollowerRegistry.list,
     });
@@ -117,9 +117,7 @@ export default function (pi: Pi.ExtensionAPI) {
   const runtimeEvents = runtimeDiagnostics.events;
   const recordRuntimeEvent = runtimeDiagnostics.recordRuntimeEvent;
   const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
-  const isTelegramBusRuntimeEnabled = function (): boolean {
-    return !telegramThreadCapabilityState.isTopicModeUnavailable();
-  };
+  const isTelegramBusRuntimeEnabled = telegramThreadCapabilityState.isBusRuntimeEnabled;
   Config.bindGlobalTelegramConfigRuntime(configStore);
   const configControls = Config.createTelegramConfigControls(configStore);
   const lockRuntime = Locks.createTelegramLockRuntime<Pi.ExtensionContext>({
@@ -225,7 +223,6 @@ export default function (pi: Pi.ExtensionAPI) {
   );
   const deferredQueueDispatchRuntime =
     Queue.createTelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>({
-      delayMs: 50,
       recordRuntimeEvent,
     });
   const pollingControllerState = Polling.createTelegramPollingControllerState();
@@ -364,7 +361,6 @@ export default function (pi: Pi.ExtensionAPI) {
       getForwardCommentBatchPosition:
         textGroupRuntime.getPreparedForwardingPosition,
       recordRuntimeEvent,
-      timeoutMs: 30_000,
     });
   const telegramApiRuntime = BusApi.createTelegramBusAwareApiRuntime({
     directRuntime: directTelegramApiRuntime,
@@ -446,7 +442,8 @@ export default function (pi: Pi.ExtensionAPI) {
       getActiveTurnTarget: activeTurnRuntime.getTarget,
       getActiveGuestQueryId: activeTurnRuntime.getGuestQueryId,
     });
-  const deliveryGenerationSeed = `${telegramInstanceId}:${Date.now()}`;
+  const deliveryGenerationSeed =
+    Delivery.createTelegramDeliveryGenerationSeed(telegramInstanceId);
   const deliveryLifecycleRuntime =
     Delivery.createTelegramBridgeDeliveryLifecycleHooks({
       generationSeed: deliveryGenerationSeed,
@@ -687,10 +684,13 @@ export default function (pi: Pi.ExtensionAPI) {
       followerRegistry: telegramBusFollowerRegistry,
       followerTargetController,
       onRestored() {
-        telegramSyncStateRuntime.markSliceFresh("target-bindings", {
-          nowMs: Date.now(),
-          action: "follower-thread-restore",
-        });
+        telegramSyncStateRuntime.markSliceFresh(
+          Sync.TELEGRAM_SYNC_SLICE_TARGET_BINDINGS,
+          {
+            nowMs: Date.now(),
+            action: "follower-thread-restore",
+          },
+        );
       },
     });
   const observedThreadTargetBinding =
@@ -811,58 +811,54 @@ export default function (pi: Pi.ExtensionAPI) {
       handleAuthorizedReactionUpdate:
         inboundRouteRuntime.handleAuthorizedReactionUpdate,
     });
-  const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
-    BusFollower.createTelegramBusFollowerRuntimeAssembly<
+  const telegramBusFollowerAssemblyDeps =
+    BusFollower.createTelegramBusFollowerRuntimeAssemblyDeps<
       Pi.ExtensionContext,
       Updates.TelegramMessageReactionUpdated,
       Routing.TelegramRoutedCallbackQuery,
       Routing.TelegramRoutedMessage
     >({
+      instanceId: telegramInstanceId,
+      registrationState: telegramBusFollowerRegistrationState,
+      recordRuntimeEvent,
       receiver: {
         socketPath: getTelegramBusFollowerSocketPath,
-        instanceId: telegramInstanceId,
         getContext: telegramSessionContextStore.get,
         getAuthSecret: telegramBusFollowerControlState.getActiveAuthSecret,
         ...forwardedRouteHandlers,
         prepareForwardedMessage: textGroupRuntime.prepareForwardedMessage,
-        recordRuntimeEvent,
       },
       targetReplacement: {
         topicTargetStore: threadStore,
-        registrationState: telegramBusFollowerRegistrationState,
-        instanceId: telegramInstanceId,
         getManualFollowerProfileKey: getTelegramManualFollowerProfileKey,
         manualFollowerOwnerId: telegramManualFollowerOwnerId,
         getSyncState: telegramSyncStateRuntime.getState,
         setSyncState: telegramSyncStateRuntime.setState,
         updateStatus,
-        recordRuntimeEvent,
       },
       recovery: {
-        registrationState: telegramBusFollowerRegistrationState,
         getLeaderState: lockRuntime.getState,
         setLifecyclePhase: telegramBusFollowerControlState.setLifecyclePhase,
         updateStatus,
         promoteToLeader: promoteTelegramBusFollowerToLeader,
         getActiveContext: telegramSessionContextStore.get,
-        recordRuntimeEvent,
       },
       registration: {
-        instanceId: telegramInstanceId,
         getFollowerBusSocketPath: getTelegramBusFollowerSocketPath,
         getLeaderSocketPath: getTelegramBusSocketPath,
-        registrationState: telegramBusFollowerRegistrationState,
         isContextActive: telegramSessionContextStore.isCurrent,
         createRequestId: telegramBusFollowerClients.createRequestId,
-        getLeaderAuthSecret(owner) {
-          return owner.busSecret;
-        },
-        setActiveAuthSecret:
-          telegramBusFollowerControlState.setActiveAuthSecret,
+        setActiveAuthSecret: telegramBusFollowerControlState.setActiveAuthSecret,
         getProfileKey: getTelegramManualFollowerProfileKey,
-        recordRuntimeEvent,
       },
     });
+  const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
+    BusFollower.createTelegramBusFollowerRuntimeAssembly<
+      Pi.ExtensionContext,
+      Updates.TelegramMessageReactionUpdated,
+      Routing.TelegramRoutedCallbackQuery,
+      Routing.TelegramRoutedMessage
+    >(telegramBusFollowerAssemblyDeps);
   const telegramBusFollowerRegistration =
     telegramBusFollowerAssembly.registration;
   const pollingRuntime = Polling.createTelegramPollingControllerRuntime({
@@ -1001,8 +997,8 @@ export default function (pi: Pi.ExtensionAPI) {
       stopPolling: lockedPollingRuntime.stop,
       recordRuntimeEvent,
     });
-  const sessionLifecycleRuntime =
-    Lifecycle.createTelegramBridgeSessionLifecycleAssembly({
+  const telegramBridgeSessionLifecycleDeps =
+    Lifecycle.createTelegramBridgeSessionLifecycleDeps({
       contextStore: telegramSessionContextStore,
       queue: {
         getCurrentModel: getContextModel,
@@ -1038,20 +1034,24 @@ export default function (pi: Pi.ExtensionAPI) {
         recordRuntimeEvent,
       },
       services: {
-        resumeGroupedInput(ctx) {
-          mediaGroupRuntime.resume(ctx);
-          textGroupRuntime.resume(ctx);
+        mediaGroup: {
+          resume: mediaGroupRuntime.resume,
+          suspend: mediaGroupRuntime.suspend,
+        },
+        textGroup: {
+          resume: textGroupRuntime.resume,
+          suspend: textGroupRuntime.suspend,
         },
-        suspendGroupedInput: TextGroups.createTelegramGroupedInputClearer({
-          clearMediaGroups: mediaGroupRuntime.suspend,
-          clearTextGroups: textGroupRuntime.suspend,
-        }),
         delivery: deliveryLifecycleRuntime,
         polling: lockedPollingRuntime,
         capabilityMonitor: telegramThreadCapabilityMonitor,
         queueWatchdog: queueDispatchWatchdogRuntime,
       },
     });
+  const sessionLifecycleRuntime =
+    Lifecycle.createTelegramBridgeSessionLifecycleAssembly(
+      telegramBridgeSessionLifecycleDeps,
+    );
 
   // --- Extension API Bindings ---
 

package/lib/activity-verbosity.ts

@@ -24,6 +24,7 @@ export const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3_900;
 export const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1_200;
+export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1_200;
 export const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 
 interface ToolActivity {
@@ -291,6 +292,7 @@ export interface TelegramActivityVerbosityRuntime {
 export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   getActivityMode: () => "quiet" | "thinking" | "tools" | "verbose";
   refreshActivityMode?: () => Promise<void>;
+  getNowMs?: () => number;
   resolveTarget: (event: TelegramActivityEvent) => TelegramTarget | undefined;
   captureAuthority: () => TAuthority;
   isAuthorityActive: (authority: TAuthority) => boolean;
@@ -315,6 +317,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   let active = true;
   let generation = 0;
   let tail = Promise.resolve();
+  const getNowMs = deps.getNowMs ?? Date.now;
   let activityId: string | undefined;
   let authority: TAuthority | undefined;
   let target: TelegramTarget | undefined;
@@ -324,6 +327,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   let lastReasoningMessageChars = 0;
   let reasoningMessage: ReasoningMessage | undefined;
   let reasoningBlocked = false;
+  let lastReasoningPublishMs = 0;
   let toolMessage: ToolMessage | undefined;
   const tools = new Map<string, ToolActivity>();
   const toolOrder: string[] = [];
@@ -338,6 +342,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
     lastReasoningMessageChars = 0;
     reasoningMessage = undefined;
     reasoningBlocked = false;
+    lastReasoningPublishMs = 0;
     toolMessage = undefined;
     tools.clear();
     toolOrder.length = 0;
@@ -412,6 +417,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       if (generation !== acceptedGeneration) return;
       reasoningMessageFrames += 1;
       lastReasoningMessageChars = reasoningChars;
+      lastReasoningPublishMs = getNowMs();
     } catch (error) {
       deps.recordFailure?.(
         canEdit ? "reasoning-edit" : "reasoning-send",
@@ -552,10 +558,11 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       reasoningBuffer = `${reasoningBuffer}${event.delta}`.slice(
         -TELEGRAM_REASONING_BUFFER_MAX_CHARS,
       );
-      if (
-        reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES &&
+      if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES &&
         (reasoningMessageFrames === 0 ||
-          reasoningChars - lastReasoningMessageChars >= 160)
+          (getNowMs() - lastReasoningPublishMs >=
+            TELEGRAM_REASONING_MIN_INTERVAL_MS &&
+            reasoningChars - lastReasoningMessageChars >= 160))
       ) {
         await publishReasoning(event, acceptedGeneration);
       }
@@ -580,6 +587,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       reasoningChars = 0;
       reasoningMessageFrames = 0;
       lastReasoningMessageChars = 0;
+      lastReasoningPublishMs = 0;
       reasoningMessage = undefined;
       reasoningBlocked = false;
       return;

package/lib/bus-follower.ts

@@ -514,6 +514,91 @@ export function createTelegramBusForwardedRouteHandlers<
   };
 }
 
+export interface TelegramBusFollowerRuntimeAssemblyPorts<
+  TContext extends { cwd?: string },
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage = unknown,
+> {
+  instanceId: string;
+  registrationState: TelegramBusFollowerRegistrationState;
+  recordRuntimeEvent: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
+  receiver: Omit<
+    TelegramBusForwardedUpdateReceiverRuntimeDeps<
+      TContext,
+      TReactionUpdate,
+      TCallbackQuery,
+      TMessage
+    >,
+    "handleReplaceTarget" | "instanceId" | "recordRuntimeEvent"
+  >;
+  targetReplacement: Omit<
+    TelegramBusFollowerTargetReplacementHandlerDeps<TContext>,
+    "registrationState" | "instanceId" | "recordRuntimeEvent"
+  >;
+  recovery: Omit<
+    TelegramBusFollowerHeartbeatRecoveryHandlerDeps<TContext>,
+    "getRegistrationRuntime" | "registrationState" | "recordRuntimeEvent"
+  >;
+  registration: Omit<
+    TelegramBusFollowerRegistrationRuntimeDeps<TContext>,
+    | "startReceiving"
+    | "stopReceiving"
+    | "onHeartbeatFailure"
+    | "instanceId"
+    | "registrationState"
+    | "recordRuntimeEvent"
+  >;
+}
+
+export function createTelegramBusFollowerRuntimeAssemblyDeps<
+  TContext extends { cwd?: string },
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage = unknown,
+>(
+  ports: TelegramBusFollowerRuntimeAssemblyPorts<
+    TContext,
+    TReactionUpdate,
+    TCallbackQuery,
+    TMessage
+  >,
+): TelegramBusFollowerRuntimeAssemblyDeps<
+  TContext,
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage
+> {
+  return {
+    receiver: {
+      ...ports.receiver,
+      instanceId: ports.instanceId,
+      recordRuntimeEvent: ports.recordRuntimeEvent,
+    },
+    targetReplacement: {
+      ...ports.targetReplacement,
+      instanceId: ports.instanceId,
+      registrationState: ports.registrationState,
+      recordRuntimeEvent: ports.recordRuntimeEvent,
+    },
+    recovery: {
+      ...ports.recovery,
+      registrationState: ports.registrationState,
+      recordRuntimeEvent: ports.recordRuntimeEvent,
+    },
+    registration: {
+      ...ports.registration,
+      instanceId: ports.instanceId,
+      registrationState: ports.registrationState,
+      recordRuntimeEvent: ports.recordRuntimeEvent,
+    },
+  };
+}
+
 export function createTelegramBusFollowerRuntimeAssembly<
   TContext extends { cwd?: string },
   TReactionUpdate,
@@ -1260,7 +1345,9 @@ export function createTelegramBusFollowerRegistrationRuntime<
         deps.getLeaderSocketPath?.() ??
         getTelegramBusSocketPath();
       await deps.startReceiving?.();
-      activeAuthSecret = deps.getLeaderAuthSecret?.(leader);
+      activeAuthSecret = deps.getLeaderAuthSecret
+        ? deps.getLeaderAuthSecret(leader)
+        : leader?.busSecret;
       deps.setActiveAuthSecret?.(activeAuthSecret);
       const registrationGeneration = deps.createRequestId();
       const registrationEnvelope: Extract<

package/lib/delivery.ts

@@ -198,6 +198,10 @@ export function createTelegramDeliveryLifecycleHooks(
   };
 }
 
+export function createTelegramDeliveryGenerationSeed(instanceId: string): string {
+  return `${instanceId}:${Date.now()}`;
+}
+
 /** @internal */
 export function createTelegramBridgeDeliveryLifecycleHooks<TTransportStamp>(
   deps: Omit<

package/lib/lifecycle.ts

@@ -6,6 +6,7 @@
 
 import * as BusFollower from "./bus-follower.ts";
 import * as Queue from "./queue.ts";
+import * as TextGroups from "./text-groups.ts";
 import type {
   AgentEndEvent,
   AgentSettledEvent,
@@ -253,6 +254,67 @@ export interface TelegramBridgeSessionLifecycleAssemblyDeps<
   services: TelegramBridgeSessionServiceRuntime;
 }
 
+export interface TelegramBridgeSessionLifecyclePorts<
+  TQueueItem,
+  TModel = unknown,
+> {
+  contextStore: TelegramSessionContextStore<ExtensionContext>;
+  queue: Omit<
+    Queue.TelegramSessionLifecycleRuntimeDeps<
+      ExtensionContext,
+      TQueueItem,
+      TModel
+    >,
+    "isSessionActive" | "stopPolling" | "clearPendingMediaGroups"
+  >;
+  follower: Omit<
+    BusFollower.TelegramBusFollowerSessionRefreshHookDeps<ExtensionContext>,
+    "isSessionActive"
+  > &
+    BusFollower.TelegramBusFollowerSessionReplacementSuspenderDeps;
+  services: {
+    mediaGroup: {
+      resume(ctx: ExtensionContext): void;
+      suspend(): void;
+    };
+    textGroup: {
+      resume(ctx: ExtensionContext): void;
+      suspend(): void;
+    };
+    delivery: TelegramBridgeSessionServiceRuntime["delivery"];
+    polling: TelegramBridgeSessionServiceRuntime["polling"];
+    capabilityMonitor: TelegramBridgeSessionServiceRuntime["capabilityMonitor"];
+    queueWatchdog: TelegramBridgeSessionServiceRuntime["queueWatchdog"];
+  };
+}
+
+export function createTelegramBridgeSessionLifecycleDeps<
+  TQueueItem,
+  TModel = unknown,
+>(
+  ports: TelegramBridgeSessionLifecyclePorts<TQueueItem, TModel>,
+): TelegramBridgeSessionLifecycleAssemblyDeps<TQueueItem, TModel> {
+  return {
+    contextStore: ports.contextStore,
+    queue: ports.queue,
+    follower: ports.follower,
+    services: {
+      resumeGroupedInput(ctx) {
+        ports.services.mediaGroup.resume(ctx);
+        ports.services.textGroup.resume(ctx);
+      },
+      suspendGroupedInput: TextGroups.createTelegramGroupedInputClearer({
+        clearMediaGroups: ports.services.mediaGroup.suspend,
+        clearTextGroups: ports.services.textGroup.suspend,
+      }),
+      delivery: ports.services.delivery,
+      polling: ports.services.polling,
+      capabilityMonitor: ports.services.capabilityMonitor,
+      queueWatchdog: ports.services.queueWatchdog,
+    },
+  };
+}
+
 export function createTelegramBridgeSessionLifecycleAssembly<
   TQueueItem,
   TModel = unknown,

package/lib/polling.ts

@@ -351,6 +351,7 @@ export interface TelegramThreadCapabilityStateRuntime {
   setBusPollingStarted(started: boolean): void;
   isTopicModeUnavailable(): boolean;
   setTopicModeUnavailable(unavailable: boolean): void;
+  isBusRuntimeEnabled(): boolean;
   shouldForceFreshLeaderThread(): boolean;
   setForceFreshLeaderThread(forceFresh: boolean): void;
 }
@@ -458,6 +459,7 @@ export function createTelegramThreadCapabilityStateRuntime(): TelegramThreadCapa
     setTopicModeUnavailable(unavailable) {
       topicModeUnavailable = unavailable;
     },
+    isBusRuntimeEnabled: () => !topicModeUnavailable,
     shouldForceFreshLeaderThread: () => forceFreshLeaderThread,
     setForceFreshLeaderThread(forceFresh) {
       forceFreshLeaderThread = forceFresh;

package/lib/queue.ts

@@ -2133,13 +2133,19 @@ export interface TelegramDeferredQueueDispatchRuntime<TContext = unknown> {
   request: (dispatchNextQueuedTelegramTurn: (ctx: TContext) => void) => void;
 }
 
+/**
+ * Production debounce for deferred queue dispatch; the factory defaults to this
+ * so the entrypoint wires ports instead of policy constants.
+ */
+export const TELEGRAM_DEFERRED_DISPATCH_DELAY_MS = 50;
+
 export function createTelegramDeferredQueueDispatchRuntime<TContext = unknown>(
   deps: TelegramDeferredQueueDispatchRuntimeDeps = {},
 ): TelegramDeferredQueueDispatchRuntime<TContext> {
   let boundContext: TContext | undefined;
   let generation = 0;
   const timers = new Set<ReturnType<typeof setTimeout>>();
-  const delayMs = deps.delayMs ?? 0;
+  const delayMs = deps.delayMs ?? TELEGRAM_DEFERRED_DISPATCH_DELAY_MS;
   const setTimer =
     deps.setTimer ??
     ((callback: () => void, ms: number): ReturnType<typeof setTimeout> =>

package/lib/sync.ts

@@ -486,6 +486,8 @@ export async function ensureTelegramLeaderThreadBinding(
   return ownTarget;
 }
 
+export const TELEGRAM_SYNC_SLICE_TARGET_BINDINGS = "target-bindings";
+
 export const TELEGRAM_SYNC_SLICES = [
   "bot-identity",
   "bot-capabilities",
@@ -493,7 +495,7 @@ export const TELEGRAM_SYNC_SLICES = [
   "allowed-user",
   "topic-capability",
   "topic-state",
-  "target-bindings",
+  TELEGRAM_SYNC_SLICE_TARGET_BINDINGS,
   "reservations",
   "transport-health",
 ] as const;

package/package.json

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