@llblab/pi-telegram 0.18.2 → 0.18.4

package/BACKLOG.md

@@ -2,16 +2,45 @@
 
 _Current deterministic status: Threaded Mode implementation, native typing/activity status, regression coverage, docs/context reconciliation, typecheck, full tests, pack check, audit, Domain DAG validation, context validation, and core live Threaded Mode smoke are green. This backlog intentionally tracks only release-relevant remaining work: native Windows smoke, evidence-gated Telegram client follow-ups, and upstream Pi API blockers._
 
+## P0 — Live Threaded Mode Regression Sweep
+
+Context: live Linux testing exposed regressions around prompt dispatch readiness, visible thread rename noise during automatic leader reclaim, status thread-name fallback flicker, and follower voice/update forwarding health. These are local runtime correctness issues and must be validated before returning to Windows smoke.
+
+Open work:
+
+- [x] Hide minimal model-menu one-page pagination and keep scope tabs progressive.
+- [x] Add immediate-plus-deferred inbound prompt dispatch so queued prompts do not wait for a later `/reload` or command.
+- [x] Stop automatic leader reclaim/reconciliation paths from visibly calling `editForumTopic` for internal identity restoration.
+- [x] Prevent leader auto-claim of an unknown unbound thread while another live thread target exists, covering same-directory leader/follower smear risk.
+- [x] Prefer local live leader/follower target labels over stale shared thread-store records when building prompt prefixes.
+- [x] Permit follower-safe bot identity reads and own-chat native activity through the leader API proxy without granting cross-thread message/file/topic writes.
+- [x] Preserve leader thread-name fallback in live status state to reduce `Dune`/generic `Telegram` flicker.
+- [ ] Live smoke on Linux with one leader and one follower:
+  - [x] clean-state pass after removing `tmp/telegram` so stale diagnostic snapshots do not obscure live behavior;
+  - [ ] dirty-state pass with old `state.json`/`logs.jsonl` present to prove live locks, bus registration, target ownership, and reconciliation override stale diagnostics;
+  - [x] follower thread receives raw voice/message updates through the leader bus;
+  - [x] follower-local handlers from that instance's `telegram.json` process voice independently;
+  - [x] same-directory leader/follower sessions keep distinct thread bindings;
+  - [ ] leader reload recovers without duplicate visible thread renames;
+  - [ ] prompts dispatch without a second command;
+  - [ ] status remains stable around thread name and role while active turns start/end.
+- [ ] Add/keep proactive race protections so `state.json` never becomes authoritative over live lock ownership, bus registration, or current target identity.
+
+Done when: local Linux live Threaded Mode smoke is stable for leader reload, follower connect, prompt dispatch, voice forwarding, and status naming without visible rename noise.
+
 ## P0 — Native Windows Threaded Mode Support
 
-Context: Threaded Mode uses a local leader/follower IPC bus. Unix-like platforms use Node `net` over Unix sockets; native Windows uses Node `net` named-pipe paths. The product expectation is identical behavior across both transports: leader/follower registration, heartbeats, forwarded Telegram API calls, thread target preservation, lifecycle cleanup, and shutdown semantics should not depend on socket-vs-pipe transport.
+Context: Threaded Mode uses a local leader/follower IPC bus. Unix-like platforms use Node `net` over Unix sockets; native Windows uses Node `net` named-pipe paths. The product expectation is identical behavior across both transports: leader/follower registration, heartbeats, forwarded Telegram API calls, thread target preservation, lifecycle cleanup, and shutdown semantics should not depend on socket-vs-pipe transport. This remains after the local Linux regression sweep is green.
 
 Open work:
 
 - [ ] Live smoke Threaded Mode on native Windows without WSL.
   - Scope: leader/follower `/telegram-connect`, follower heartbeat, forwarded Bot API calls, restore flows, lifecycle announcements, shutdown cleanup, and reconnect/reload behavior.
+  - Observed: a same-directory follower can see a live leader lock but fail registration with `connect ENOENT \\.\\pipe\\...`, leaving the follower disconnected during leader reload/hot activation timing.
+  - Observed: Windows/QEMU live polling/dispatch can lag until reload; inbound messages appear to increase the extension queue count, but the next queued item is not dispatched promptly.
   - Baseline: deterministic path tests run everywhere, and a Windows-only named-pipe roundtrip regression runs when the suite executes on `win32`. Live Windows smoke remains unavailable in this environment.
-- [ ] If Windows live smoke exposes pipe-specific behavior, add a minimized regression at the bus transport boundary before changing higher-level Threaded Mode logic.
+- [x] Add a minimized registration-boundary regression for transient leader endpoint startup races.
+- [x] Add a session-bound queue dispatch watchdog so queued Telegram work can recover if a one-shot wakeup/timer is missed.
 
 Done when: Threaded Mode leader/follower operation works on native Windows with the same safety guarantees as Unix-like systems, and unsupported transport assumptions are covered by tests/docs.
 

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+## 0.18.4: Windows Threaded Mode hotfix
+
+- `[Windows IPC]` Follower registration now retries transient local bus connection failures while the leader named pipe/socket is still coming online. Impact: a same-directory Windows follower is less likely to fail `/telegram-connect` with `connect ENOENT \\.\\pipe\\...` during leader reload or hot Threaded Mode activation.
+- `[Queue]` A session-bound queue dispatch watchdog now retries dispatch while Telegram work remains queued. Impact: if a platform drops the one-shot deferred dispatch wakeup, queued Telegram messages can resume without waiting for a manual `/reload`.
+
+## 0.18.3: Threaded Mode live hotfix
+
+- `[Threaded Mode]` Inbound Telegram prompts now request an immediate dispatch and a session-bound deferred retry. Impact: hosts where Pi is not yet dispatch-ready at update handling time no longer need a later `/reload` or command to process the queued prompt.
+- `[Thread Lifecycle]` Automatic leader reclaim/reconciliation paths no longer call `editForumTopic` just to restore internal thread identity, and an unknown unbound thread is no longer auto-claimed by the leader while another live thread target exists. Prompt thread labels now prefer the local live leader/follower target over stale shared thread-store records. Impact: ordinary prompts and voice messages should not produce duplicate Telegram service messages such as `renamed the thread to ...`, and a same-directory follower thread is less likely to be smeared onto the leader binding or mislabeled in prompts.
+- `[Threaded Mode]` Follower Bot API authorization now permits safe bot identity reads and chat-level typing/activity within the follower's assigned chat, while preserving thread-scoped write restrictions for messages/files/topic mutation. Impact: forwarded follower updates no longer fail just because native activity/capability paths use the aggregate chat surface.
+- `[Status]` Leader target assignment now carries the live thread name into status fallback state. Impact: the status bar is less likely to flicker from `Dune Leader/Active` to generic `Telegram Leader` when the current active turn or thread-store lookup changes.
+- `[Model Menu]` The Telegram model menu now hides one-page pagination controls and keeps scope tabs hidden unless scoped models exist. Impact: the minimal model menu shows only main-menu navigation and the available models.
+
 ## 0.18.2: setup pairing start hotfix
 
 - `[Setup]` `/telegram-setup` now updates the live in-memory config immediately after persisting the validated bot token and before starting polling. Impact: first-time setup no longer shows `Send /start...` followed by `Telegram bot is not configured`, and `/start` can be received without restarting Pi.

package/index.ts

@@ -73,6 +73,7 @@ export default function (pi: Pi.ExtensionAPI) {
     BusFollower.createTelegramBusFollowerRegistrationState();
   let telegramBusLeaderTarget: Config.TelegramProactivePushTarget | undefined;
   let telegramBusLeaderSlot: string | undefined;
+  let telegramBusLeaderThreadName: string | undefined;
   let telegramTopicModeUnavailable = false;
   let telegramTopicProvisioningCount = 0;
   const messageOwnershipStore = Ownership.createTelegramMessageOwnershipStore();
@@ -279,7 +280,8 @@ export default function (pi: Pi.ExtensionAPI) {
       if (threadStore.getBotState().threadMode === "disabled") return undefined;
       return (
         getCurrentThreadRecord()?.threadName ??
-        telegramBusFollowerRegistrationState.getThreadName()
+        telegramBusFollowerRegistrationState.getThreadName() ??
+        telegramBusLeaderThreadName
       );
     },
   });
@@ -452,6 +454,12 @@ export default function (pi: Pi.ExtensionAPI) {
       ...promptDispatchRuntime,
       sendUserMessage,
     }).dispatchNext;
+  const queueDispatchWatchdogRuntime =
+    Queue.createTelegramQueueDispatchWatchdogRuntime({
+      hasQueuedItems: telegramQueueStore.hasQueuedItems,
+      dispatchNextQueuedTelegramTurn,
+      recordRuntimeEvent,
+    });
   const nativeMarkdownDraftSender =
     TelegramApi.createTelegramNativeMarkdownDraftSender({
       sendMessageDraft,
@@ -647,6 +655,22 @@ export default function (pi: Pi.ExtensionAPI) {
         followers: telegramBusFollowerRegistry.list(),
       });
     },
+    getLocalThreadLabelForTarget(target) {
+      const followerTarget = telegramBusFollowerRegistrationState.getTarget();
+      if (
+        followerTarget?.chatId === target.chatId &&
+        followerTarget.threadId === target.threadId
+      ) {
+        return telegramBusFollowerRegistrationState.getThreadName();
+      }
+      if (
+        telegramBusLeaderTarget?.chatId === target.chatId &&
+        telegramBusLeaderTarget.threadId === target.threadId
+      ) {
+        return telegramBusLeaderThreadName;
+      }
+      return undefined;
+    },
     getCurrentLeaderEpoch,
     getThreadReconciliationMachineState() {
       return threadReconciliationRuntime.getState();
@@ -681,6 +705,7 @@ export default function (pi: Pi.ExtensionAPI) {
     dispatchNextQueuedTelegramTurn,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
+    hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,
     startTypingLoop: promptDispatchRuntime.startTypingLoop,
     stopTypingLoop: typing.stop,
     answerCallbackQuery,
@@ -880,6 +905,7 @@ export default function (pi: Pi.ExtensionAPI) {
         setLeaderTarget(input) {
           telegramBusLeaderTarget = input.target;
           telegramBusLeaderSlot = input.slot;
+          telegramBusLeaderThreadName = input.threadName;
         },
         onProvisioningStart() {
           telegramTopicProvisioningCount += 1;
@@ -1099,6 +1125,7 @@ export default function (pi: Pi.ExtensionAPI) {
       clearLeaderTarget() {
         telegramBusLeaderTarget = undefined;
         telegramBusLeaderSlot = undefined;
+        telegramBusLeaderThreadName = undefined;
       },
       getSyncState() {
         return telegramSyncState;
@@ -1147,8 +1174,10 @@ export default function (pi: Pi.ExtensionAPI) {
       async onSessionStart(event, ctx) {
         await lockedPollingRuntime.onSessionStart(event, ctx);
         telegramThreadCapabilityMonitor.start(ctx);
+        queueDispatchWatchdogRuntime.start(ctx);
       },
       async onSessionShutdown() {
+        queueDispatchWatchdogRuntime.stop();
         telegramThreadCapabilityMonitor.stop();
       },
     },

package/lib/bus-follower.ts

@@ -22,6 +22,8 @@ import {
 
 export const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2_500;
 export const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30_000;
+export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS = 10;
+export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS = 150;
 
 const TELEGRAM_FOLLOWER_SESSION_HANDOFF_KEY =
   "__piTelegramFollowerSessionHandoff";
@@ -150,6 +152,8 @@ export interface TelegramBusFollowerRegistrationRuntimeDeps<
   getPid?: () => number;
   timeoutMs?: number;
   registrationTimeoutMs?: number;
+  registrationRetryAttempts?: number;
+  registrationRetryDelayMs?: number;
   heartbeatMs?: number;
   recordRuntimeEvent?: (
     category: string,
@@ -364,6 +368,19 @@ function isTelegramStaleContextError(error: unknown): boolean {
   );
 }
 
+function isRetryableTelegramBusRegistrationError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const code = (error as NodeJS.ErrnoException).code;
+  return code === "ENOENT" || code === "ECONNREFUSED" || code === "EPIPE";
+}
+
+function delayTelegramBusFollowerRegistration(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
 export function createTelegramBusFollowerSessionReplacementSuspender(
   deps: TelegramBusFollowerSessionReplacementSuspenderDeps,
 ): () => Promise<void> {
@@ -588,6 +605,12 @@ export function createTelegramBusFollowerRegistrationRuntime<
   const heartbeatMs = deps.heartbeatMs ?? 1000;
   const registrationTimeoutMs =
     deps.registrationTimeoutMs ?? deps.timeoutMs ?? 30000;
+  const registrationRetryAttempts =
+    deps.registrationRetryAttempts ??
+    TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS;
+  const registrationRetryDelayMs =
+    deps.registrationRetryDelayMs ??
+    TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS;
   let heartbeatInterval: ReturnType<typeof setInterval> | undefined;
   let activeLeaderSocketPath: string | undefined;
   let activeAuthSecret: string | undefined;
@@ -646,30 +669,54 @@ export function createTelegramBusFollowerRegistrationRuntime<
       await deps.startReceiving?.();
       activeAuthSecret = deps.getLeaderAuthSecret?.(leader);
       deps.setActiveAuthSecret?.(activeAuthSecret);
+      const createRegistrationEnvelope = (): Extract<
+        TelegramBusEnvelope,
+        { kind: "follower.register" }
+      > => ({
+        kind: "follower.register",
+        requestId: deps.createRequestId(),
+        auth: activeAuthSecret,
+        registration: {
+          instanceId: deps.instanceId,
+          profileKey:
+            deps.getProfileKey?.(ctx) ??
+            (ctx.cwd ? `cwd:${ctx.cwd}` : undefined),
+          threadName:
+            deps.getThreadName?.(ctx) ??
+            (ctx.cwd ? basename(ctx.cwd) : undefined),
+          cwd: ctx.cwd,
+          pid: getPid(),
+          busSocketPath: deps.followerBusSocketPath,
+          connectedAtMs: getNowMs(),
+        },
+      });
       let response: TelegramBusEnvelope | undefined;
       try {
-        response = await sendTelegramBusLocalEnvelope({
-          socketPath: leaderSocketPath,
-          timeoutMs: registrationTimeoutMs,
-          envelope: {
-            kind: "follower.register",
-            requestId: deps.createRequestId(),
-            auth: activeAuthSecret,
-            registration: {
-              instanceId: deps.instanceId,
-              profileKey:
-                deps.getProfileKey?.(ctx) ??
-                (ctx.cwd ? `cwd:${ctx.cwd}` : undefined),
-              threadName:
-                deps.getThreadName?.(ctx) ??
-                (ctx.cwd ? basename(ctx.cwd) : undefined),
-              cwd: ctx.cwd,
-              pid: getPid(),
-              busSocketPath: deps.followerBusSocketPath,
-              connectedAtMs: getNowMs(),
-            },
-          },
-        });
+        for (let attempt = 1; ; attempt += 1) {
+          try {
+            response = await sendTelegramBusLocalEnvelope({
+              socketPath: leaderSocketPath,
+              timeoutMs: registrationTimeoutMs,
+              envelope: createRegistrationEnvelope(),
+            });
+            break;
+          } catch (error) {
+            if (
+              attempt >= registrationRetryAttempts ||
+              !isRetryableTelegramBusRegistrationError(error)
+            ) {
+              throw error;
+            }
+            deps.recordRuntimeEvent?.("bus", error, {
+              phase: "follower-register-retry",
+              attempt,
+              socketPath: leaderSocketPath,
+            });
+            await delayTelegramBusFollowerRegistration(
+              registrationRetryDelayMs,
+            );
+          }
+        }
       } catch (error) {
         stopHeartbeat();
         activeLeaderSocketPath = undefined;

package/lib/bus-leader.ts

@@ -68,7 +68,11 @@ export interface TelegramBusLeaderTargetProvisionerDeps<TContext> {
   ) => void;
   getSyncState: () => Sync.TelegramSyncState;
   setSyncState: (state: Sync.TelegramSyncState) => void;
-  setLeaderTarget: (input: { target: TelegramTarget; slot?: string }) => void;
+  setLeaderTarget: (input: {
+    target: TelegramTarget;
+    slot?: string;
+    threadName?: string;
+  }) => void;
   onProvisioningStart?: () => void;
   onProvisioningEnd?: () => void;
   recordRuntimeEvent: (
@@ -476,7 +480,11 @@ export function createTelegramBusLeaderTargetProvisioner<TContext>(
       deps.onProvisioningEnd?.();
     }
     if (!ownTarget) return;
-    deps.setLeaderTarget({ target: ownTarget.target, slot: ownTarget.slot });
+    deps.setLeaderTarget({
+      target: ownTarget.target,
+      slot: ownTarget.slot,
+      threadName: ownTarget.threadName,
+    });
     const nowMs = getNowMs();
     let syncState = deps.getSyncState();
     syncState = Sync.markTelegramSyncSliceFresh(syncState, "target-bindings", {

package/lib/bus.ts

@@ -127,6 +127,12 @@ export function isTelegramFollowerApiCallAllowed(input: {
     if (target.threadId === undefined) return true;
     return matchesId(record.message_thread_id, target.threadId);
   };
+  const isTargetChatScoped = (body: unknown): boolean => {
+    if (!target) return false;
+    if (!body || typeof body !== "object" || Array.isArray(body)) return false;
+    const record = body as Record<string, unknown>;
+    return matchesId(record.chat_id, target.chatId);
+  };
   if (input.method === "downloadFile") return true;
   if (input.method === "call") {
     const apiMethod = input.args[0];
@@ -137,6 +143,8 @@ export function isTelegramFollowerApiCallAllowed(input: {
     ) {
       return true;
     }
+    if (apiMethod === "getMe") return true;
+    if (apiMethod === "sendChatAction") return isTargetChatScoped(input.args[1]);
     return allowedCallMethods.has(apiMethod) && isTargetScoped(input.args[1]);
   }
   if (input.method === "callMultipart") {

package/lib/menu-model.ts

@@ -1023,23 +1023,16 @@ export function buildModelMenuReplyMarkup(
     menuPage.page === 0 ? menuPage.pageCount - 1 : menuPage.page - 1;
   const nextPage =
     menuPage.page === menuPage.pageCount - 1 ? 0 : menuPage.page + 1;
-  rows.push(
-    menuPage.pageCount > 1
-      ? [
-          { text: "⬅️", callback_data: `model:page:${previousPage}` },
-          {
-            text: `${menuPage.page + 1}/${menuPage.pageCount}`,
-            callback_data: "model:pages",
-          },
-          { text: "➡️", callback_data: `model:page:${nextPage}` },
-        ]
-      : [
-          {
-            text: `${menuPage.page + 1}/${menuPage.pageCount}`,
-            callback_data: "model:pages",
-          },
-        ],
-  );
+  if (menuPage.pageCount > 1) {
+    rows.push([
+      { text: "⬅️", callback_data: `model:page:${previousPage}` },
+      {
+        text: `${menuPage.page + 1}/${menuPage.pageCount}`,
+        callback_data: "model:pages",
+      },
+      { text: "➡️", callback_data: `model:page:${nextPage}` },
+    ]);
+  }
   rows.push(
     ...menuPage.items.map((entry, index) => [
       {

package/lib/queue.ts

@@ -1920,6 +1920,76 @@ export function createTelegramDeferredQueueDispatchRuntime<TContext = unknown>(
   };
 }
 
+// --- Dispatch Watchdog Runtime ---
+
+export interface TelegramQueueDispatchWatchdogRuntime<TContext = unknown> {
+  start: (ctx: TContext) => void;
+  stop: () => void;
+  poke: () => void;
+}
+
+export interface TelegramQueueDispatchWatchdogRuntimeDeps<
+  TContext = unknown,
+> extends TelegramRuntimeEventRecorderPort {
+  hasQueuedItems: () => boolean;
+  dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  intervalMs?: number;
+  setInterval?: (
+    callback: () => void,
+    ms: number,
+  ) => ReturnType<typeof setInterval>;
+  clearInterval?: (timer: ReturnType<typeof setInterval>) => void;
+}
+
+export function createTelegramQueueDispatchWatchdogRuntime<
+  TContext = unknown,
+>(
+  deps: TelegramQueueDispatchWatchdogRuntimeDeps<TContext>,
+): TelegramQueueDispatchWatchdogRuntime<TContext> {
+  const intervalMs = deps.intervalMs ?? 1000;
+  const setIntervalFn: NonNullable<
+    TelegramQueueDispatchWatchdogRuntimeDeps<TContext>["setInterval"]
+  > = deps.setInterval ?? ((callback, ms) => setInterval(callback, ms));
+  const clearIntervalFn: NonNullable<
+    TelegramQueueDispatchWatchdogRuntimeDeps<TContext>["clearInterval"]
+  > = deps.clearInterval ?? ((timer) => clearInterval(timer));
+  let ctx: TContext | undefined;
+  let interval: ReturnType<typeof setInterval> | undefined;
+  let dispatchInFlight = false;
+  const tick = (): void => {
+    if (ctx === undefined || dispatchInFlight || !deps.hasQueuedItems()) return;
+    dispatchInFlight = true;
+    try {
+      deps.dispatchNextQueuedTelegramTurn(ctx);
+    } catch (error) {
+      deps.recordRuntimeEvent?.("dispatch", error, {
+        phase: "queue-watchdog",
+      });
+    } finally {
+      dispatchInFlight = false;
+    }
+  };
+  const stop = (): void => {
+    ctx = undefined;
+    if (!interval) return;
+    clearIntervalFn(interval);
+    interval = undefined;
+  };
+  return {
+    start: (nextCtx) => {
+      ctx = nextCtx;
+      if (!interval) {
+        const nextInterval = setIntervalFn(tick, intervalMs);
+        interval = nextInterval;
+        nextInterval.unref?.();
+      }
+      tick();
+    },
+    stop,
+    poke: tick,
+  };
+}
+
 // --- Dispatch Runtime ---
 
 export interface TelegramPromptDeliveryOptions {

package/lib/routing.ts

@@ -415,6 +415,9 @@ export interface TelegramInboundRouteRuntimeDeps<
   getMessageOwnership?: Updates.TelegramMessageOwnershipLookup;
   getTargetOwnership?: Updates.TelegramTargetOwnershipLookup;
   getLiveThreadTargets?: () => Queue.TelegramQueueTarget[];
+  getLocalThreadLabelForTarget?: (
+    target: Queue.TelegramQueueTarget,
+  ) => string | undefined;
   getCurrentLeaderEpoch?: () => number | string | undefined;
   getThreadReconciliationMachineState?: () =>
     | ThreadReconciler.ThreadReconciliationMachineState
@@ -484,6 +487,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
+  hasDeferredDispatchContext?: () => boolean;
   startTypingLoop?: (
     ctx: TContext,
     chatId?: number,
@@ -593,6 +597,17 @@ export function createTelegramInboundRouteRuntime<
   const guidedUnboundTopicKeys = new Set<string>();
   let nextUnboundRerouteId = 0;
   let nextAllTabCommandId = 0;
+  const requestDispatchNextQueuedTelegramTurn = (ctx: TContext): void => {
+    deps.dispatchNextQueuedTelegramTurn(ctx);
+    if (
+      deps.requestDeferredDispatchNextQueuedTelegramTurn &&
+      deps.hasDeferredDispatchContext?.() !== false
+    ) {
+      deps.requestDeferredDispatchNextQueuedTelegramTurn(
+        deps.dispatchNextQueuedTelegramTurn,
+      );
+    }
+  };
   const prunePendingUnboundReroutes = () => {
     const nowMs = Date.now();
     for (const [id, entry] of pendingUnboundReroutes) {
@@ -712,7 +727,7 @@ export function createTelegramInboundRouteRuntime<
       };
       deps.queueMutationRuntime.append(turn, ctx);
       deps.updateStatus(ctx);
-      deps.dispatchNextQueuedTelegramTurn(ctx);
+      requestDispatchNextQueuedTelegramTurn(ctx);
     },
   });
   const cloneTelegramMessagesForThread = (
@@ -1257,7 +1272,7 @@ export function createTelegramInboundRouteRuntime<
               context,
             );
             deps.updateStatus(context);
-            deps.dispatchNextQueuedTelegramTurn(context);
+            requestDispatchNextQueuedTelegramTurn(context);
           },
         },
       );
@@ -1350,10 +1365,18 @@ export function createTelegramInboundRouteRuntime<
       const chatId = message.chat.id;
       const threadId = message.message_thread_id;
       if (!threadId) return undefined;
+      const localLabel = deps.getLocalThreadLabelForTarget?.({
+        chatId,
+        threadId,
+      });
+      if (localLabel) return localLabel;
       const records = deps.threadStore.list();
+      const currentInstanceId = deps.getCurrentInstanceId?.();
       for (const r of records) {
         if (r.target.chatId !== chatId || r.target.threadId !== threadId)
           continue;
+        if (currentInstanceId && r.instanceId && r.instanceId !== currentInstanceId)
+          continue;
         return r.threadName &&
           Threads.isTelegramTopicThreadNameValidForSlot(r.threadName, r.slot)
           ? r.threadName
@@ -1380,7 +1403,7 @@ export function createTelegramInboundRouteRuntime<
       statusSummary: "continue",
     };
     deps.queueMutationRuntime.append(continueTurn, ctx);
-    deps.dispatchNextQueuedTelegramTurn(ctx);
+    requestDispatchNextQueuedTelegramTurn(ctx);
   };
   const reservedCommandNames = () =>
     new Set(Commands.getTelegramReservedCommandNames());
@@ -1454,7 +1477,7 @@ export function createTelegramInboundRouteRuntime<
         : { ...turn, replyToMessageId: 0 };
     },
     updateStatus: deps.updateStatus,
-    dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    dispatchNextQueuedTelegramTurn: requestDispatchNextQueuedTelegramTurn,
   }).enqueue;
   const sendUnboundRerouteChooserNow = async (
     messages: TMessage[],
@@ -1831,7 +1854,7 @@ export function createTelegramInboundRouteRuntime<
       Queue.appendTelegramQueueItem(items, guestTurn),
     );
     deps.updateStatus(ctx);
-    deps.dispatchNextQueuedTelegramTurn(ctx);
+    requestDispatchNextQueuedTelegramTurn(ctx);
   };
   return Updates.createTelegramPairedUpdateRuntime<TContext, TUpdate>({
     getAllowedUserId: deps.configStore.getAllowedUserId,
@@ -1951,7 +1974,13 @@ export function createTelegramInboundRouteRuntime<
       ]).trim();
       const instanceId = deps.getCurrentInstanceId?.();
       const leaderProfileKey = getLeaderTopicProfileKey(ctx, instanceId);
-      const existing = deps.threadStore.list().find((r) => {
+      const records = deps.threadStore.list();
+      const routableRecords = getTelegramRoutableThreadRecords(
+        records,
+        deps.getLiveThreadTargets?.(),
+      );
+      const hasAnyRoutableThread = routableRecords.length > 0;
+      const existing = records.find((r) => {
         return (
           r.target.chatId === target.chatId &&
           r.target.threadId === target.threadId
@@ -2003,7 +2032,8 @@ export function createTelegramInboundRouteRuntime<
             deps.threadStore.list(),
             leaderProfileKey,
             instanceId,
-          )
+          ) &&
+          !hasAnyRoutableThread
         ) {
           const priorLeaderRecord =
             deps.threadStore.getByProfileKey(leaderProfileKey);
@@ -2039,25 +2069,6 @@ export function createTelegramInboundRouteRuntime<
             slot,
           });
           await deps.threadStore.persist();
-          if (deps.callApi) {
-            try {
-              await deps.callApi("editForumTopic", {
-                chat_id: target.chatId,
-                message_thread_id: target.threadId,
-                name: Threads.getTelegramTopicTitleForThreadName(
-                  threadName,
-                  slot,
-                ),
-              });
-            } catch (renameError) {
-              deps.recordRuntimeEvent?.("telegram", renameError, {
-                phase: "leader-topic-reclaim-rename",
-                chatId: target.chatId,
-                threadId: target.threadId,
-                slot,
-              });
-            }
-          }
           deps.recordRuntimeEvent?.(
             "bus",
             "Bus leader reclaimed unbound thread",
@@ -2106,13 +2117,8 @@ export function createTelegramInboundRouteRuntime<
         );
         return;
       }
-      const records = deps.threadStore.list();
       const command = getKnownTelegramAllTabCommand(text);
-      if (
-        command &&
-        getTelegramRoutableThreadRecords(records, deps.getLiveThreadTargets?.())
-          .length > 0
-      ) {
+      if (command && hasAnyRoutableThread) {
         if (
           await sendAllTabCommandChooser(command, text, message as TMessage, {
             target: { chatId: target.chatId, threadId: target.threadId },
@@ -2172,23 +2178,6 @@ export function createTelegramInboundRouteRuntime<
               slot,
             });
             await deps.threadStore.persist();
-            try {
-              await deps.callApi("editForumTopic", {
-                chat_id: target.chatId,
-                message_thread_id: target.threadId,
-                name: Threads.getTelegramTopicTitleForThreadName(
-                  threadName,
-                  slot,
-                ),
-              });
-            } catch (renameError) {
-              deps.recordRuntimeEvent?.("telegram", renameError, {
-                phase: "leader-topic-unbound-reclaim-rename",
-                chatId: target.chatId,
-                threadId: target.threadId,
-                slot,
-              });
-            }
             deps.recordRuntimeEvent?.(
               "bus",
               "Bus leader reclaimed stale-current unbound thread",
@@ -2208,7 +2197,8 @@ export function createTelegramInboundRouteRuntime<
       }
       if (
         leaderProfileKey &&
-        !hasActiveLeaderTopic(records, leaderProfileKey, instanceId)
+        !hasActiveLeaderTopic(records, leaderProfileKey, instanceId) &&
+        !hasAnyRoutableThread
       ) {
         const priorLeaderRecord =
           deps.threadStore.getByProfileKey(leaderProfileKey);
@@ -2254,25 +2244,6 @@ export function createTelegramInboundRouteRuntime<
           slot,
         });
         await deps.threadStore.persist();
-        if (deps.callApi) {
-          try {
-            await deps.callApi("editForumTopic", {
-              chat_id: target.chatId,
-              message_thread_id: target.threadId,
-              name: Threads.getTelegramTopicTitleForThreadName(
-                threadName,
-                slot,
-              ),
-            });
-          } catch (renameError) {
-            deps.recordRuntimeEvent?.("telegram", renameError, {
-              phase: "leader-topic-reclaim-rename",
-              chatId: target.chatId,
-              threadId: target.threadId,
-              slot,
-            });
-          }
-        }
         deps.recordRuntimeEvent?.(
           "bus",
           "Bus leader reclaimed unbound thread",

package/package.json

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