@llblab/pi-kit 0.36.2 → 0.37.0

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

@@ -36,6 +36,7 @@ import {
   TelegramApiAuthorityError,
   type TelegramApiCallOptions,
 } from "./telegram-api.ts";
+import type { TelegramTarget } from "./target.ts";
 import type { TelegramSessionReplacementIntent } from "./threads.ts";
 import {
   acquireTelegramUpdateRouting,
@@ -624,6 +625,7 @@ export interface TelegramBridgeCommandStartPollingResult {
 }
 
 export interface TelegramBridgeCommandRegistrationDeps {
+  handleInternalAction?: TelegramSessionActionRuntime["handleInternalAction"];
   promptForConfig: (
     ctx: ExtensionCommandContext,
     profileName?: string,
@@ -789,6 +791,7 @@ export function registerTelegramBridgeCommands(
   pi: ExtensionAPI,
   deps: TelegramBridgeCommandRegistrationDeps,
 ): void {
+  const handleInternalAction = deps.handleInternalAction;
   pi.registerCommand("telegram-setup", {
     description: "<profile> — Configure Telegram bot token",
     handler: async (args, ctx) => {
@@ -804,9 +807,21 @@ export function registerTelegramBridgeCommands(
       ctx.ui.notify(deps.getStatusLines({ verbose }).join("\n"), "info");
     },
   });
-  pi.registerCommand("telegram-connect", {
+  pi.registerCommand(TELEGRAM_CONNECT_COMMAND_NAME, {
     description: "<profile> — Start Telegram bridge",
     handler: async (args, ctx) => {
+      const words = args.trim().split(/\s+/);
+      // Service dispatch never inherits profile activation or explicit-connect recovery authority.
+      if (words.some(word =>
+        word.toLowerCase().startsWith(TELEGRAM_INTERNAL_COMMAND_FLAG),
+      )) {
+        if (words[0] !== TELEGRAM_INTERNAL_COMMAND_FLAG || !handleInternalAction) {
+          ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
+          return;
+        }
+        await handleInternalAction(words.slice(1).join(" "), ctx);
+        return;
+      }
       const sessionGeneration = deps.getSessionGeneration?.();
       let intentId: string | undefined;
       // Pi context getters throw after replacement; check plain intent/generation first.
@@ -1194,34 +1209,38 @@ export interface TelegramCommandTargetRuntimeDeps<TContext> {
   ) => void;
   getAdmissionScope?: () => string | undefined;
   getAdmissionJournalBinding?: () => string | undefined;
+  /** Ordinary reply destination selected before publication, not resend authority. */
+  getReplyTarget?: (
+    message: TelegramCommandRuntimeMessage,
+  ) => TelegramTarget | undefined;
   onControlQueued?: (
     message: TelegramCommandRuntimeMessage,
     receipt: TelegramQueueAdmissionReceipt,
   ) => void;
   showStatus: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   openModelMenu: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   openSettingsMenu?: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   sendTextReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     text: string,
     options?: {
       parseMode?: "HTML";
@@ -1336,6 +1355,7 @@ export function createTelegramCommandTargetQueueRuntime<
       createControlItem,
       enqueueControlItem: controlQueueController.enqueue,
     }),
+    getReplyTarget: deps.getReplyTarget,
     getAdmissionScope: deps.getAdmissionScope,
     getAdmissionJournalBinding: deps.getAdmissionJournalBinding,
     onControlQueued: deps.onControlQueued,
@@ -1352,6 +1372,25 @@ export function createTelegramCommandTargetRuntime<
 >(
   deps: TelegramCommandTargetRuntimeDeps<TContext>,
 ): TelegramCommandTargetRuntime<TMessage, TContext> {
+  const getReplyTarget = (
+    message: TMessage,
+    options?: Pick<TelegramApiCallOptions, "assertAuthority">,
+  ) => {
+    const source = getTelegramCommandMessageTarget(message);
+    const recipient = options?.assertAuthority
+      ? undefined
+      : deps.getReplyTarget?.(message);
+    if (!recipient) return source;
+    if (recipient.chatId !== source.chatId)
+      throw new Error("Telegram command reply cannot change its recipient chat.");
+    if (source.threadId !== undefined && recipient.threadId === undefined)
+      throw new Error("Telegram command cannot move a Thread reply to All.");
+    return {
+      ...recipient,
+      replyToMessageId:
+        recipient.threadId === source.threadId ? source.replyToMessageId : undefined,
+    };
+  };
   return {
     enqueueControlItem: (message, ctx, controlType, statusSummary, execute) => {
       const sourceUpdateId = message.pi_telegram_source_update_id;
@@ -1381,7 +1420,7 @@ export function createTelegramCommandTargetRuntime<
       );
     },
     showStatus: (message, ctx, options) => {
-      const target = getTelegramCommandMessageTarget(message);
+      const target = getReplyTarget(message, options);
       return deps.showStatus(
         target.chatId,
         target.replyToMessageId,
@@ -1391,7 +1430,7 @@ export function createTelegramCommandTargetRuntime<
       );
     },
     openModelMenu: (message, ctx, options) => {
-      const target = getTelegramCommandMessageTarget(message);
+      const target = getReplyTarget(message, options);
       return deps.openModelMenu(
         target.chatId,
         target.replyToMessageId,
@@ -1401,7 +1440,7 @@ export function createTelegramCommandTargetRuntime<
       );
     },
     openSettingsMenu: async (message, ctx, options) => {
-      const target = getTelegramCommandMessageTarget(message);
+      const target = getReplyTarget(message, options);
       if (!deps.openSettingsMenu) {
         await deps.sendTextReply(
           target.chatId,
@@ -1423,7 +1462,7 @@ export function createTelegramCommandTargetRuntime<
       );
     },
     sendTextReply: async (message, text, options) => {
-      const target = getTelegramCommandMessageTarget(message);
+      const target = getReplyTarget(message, options);
       const assertAuthority = options?.assertAuthority,
         send = deps.sendTextReply;
       const capturedOptions = { ...options, target };
@@ -2217,6 +2256,7 @@ export function createTelegramCommandHandlerTargetRuntime<
     }),
     appendControlItem: deps.appendControlItem,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    getReplyTarget: deps.getReplyTarget,
     getAdmissionScope: deps.getAdmissionScope,
     getAdmissionJournalBinding: deps.getAdmissionJournalBinding,
     onControlQueued: deps.onControlQueued,
@@ -4157,18 +4197,16 @@ async function handleTelegramCommandRuntime<
   );
 }
 
-export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
-export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION =
-  "Internal Telegram command cannot be run manually";
+export const TELEGRAM_CONNECT_COMMAND_NAME = "telegram-connect";
+export const TELEGRAM_INTERNAL_COMMAND_FLAG = "--internal";
 export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE =
-  "This internal Telegram command cannot be run manually.";
+  "This internal Telegram action cannot be run manually.";
 
 function delayTelegramSessionAction(delayMs: number): Promise<void> {
   return new Promise<void>((resolve) => setTimeout(resolve, delayMs));
 }
 
 export interface TelegramSessionActionRuntimeDeps {
-  registerCommand: Pi.ExtensionAPI["registerCommand"];
   sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];
   notifyResult: (
     target: { chatId: number; threadId?: number; messageId: number },
@@ -4251,7 +4289,6 @@ function createTelegramSessionReplacementSettlementRuntime<TContext>(deps: {
 }
 
 export interface TelegramSessionActionAssemblyDeps {
-  registerCommand: Pi.ExtensionAPI["registerCommand"];
   sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];
   store: {
     load: () => Promise<void>;
@@ -4333,7 +4370,6 @@ export function createTelegramSessionActionAssembly(
     report(new Error("Telegram new-session result delivery failed."));
   };
   const action = createTelegramSessionActionRuntime({
-    registerCommand: deps.registerCommand,
     sendUserMessage: deps.sendUserMessage,
     notifyResult(target, result) {
       return sendTerminalResult(target, result);
@@ -4465,7 +4501,10 @@ type TelegramPendingInternalAction = {
 };
 
 export interface TelegramSessionActionRuntime {
-  register: () => void;
+  handleInternalAction: (
+    args: string,
+    ctx: Pi.ExtensionCommandContext,
+  ) => Promise<void>;
   scheduleAfterUpdate: (
     updateId: number,
     target: { chatId: number; threadId?: number; messageId: number },
@@ -4486,7 +4525,6 @@ export function createTelegramSessionActionRuntime(
       }
     | undefined;
   let pendingAction: TelegramPendingInternalAction | undefined;
-  let registered = false;
 
   const reportFailure = (error: unknown): void => {
     try {
@@ -4497,37 +4535,34 @@ export function createTelegramSessionActionRuntime(
   };
 
   return {
-    register() {
-      if (registered) return;
-      registered = true;
-      deps.registerCommand(TELEGRAM_INTERNAL_COMMAND_NAME, {
-        description: TELEGRAM_INTERNAL_COMMAND_DESCRIPTION,
-        handler: async (args, ctx) => {
-          const action = pendingAction;
-          if (!action || args.trim() !== action.token) {
-            ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
-            return;
-          }
-          pendingAction = undefined;
-          switch (action.kind) {
-            case "replace-session":
-              try {
-                await deps.prepareReplacement?.(
-                  ctx,
-                  action.updateId,
-                  action.target,
-                );
-                const result = await ctx.newSession();
-                if (result.cancelled)
-                  await deps.notifyResult(action.target, "cancelled");
-              } catch (error) {
-                reportFailure(error);
-                await deps.notifyResult(action.target, "failure");
-              }
-              return;
+    async handleInternalAction(args, ctx) {
+      const action = pendingAction;
+      const [operation, token, ...extra] = args.trim().split(/\s+/);
+      if (
+        !action || operation !== "new" ||
+        token !== action.token || extra.length !== 0
+      ) {
+        ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
+        return;
+      }
+      pendingAction = undefined;
+      switch (action.kind) {
+        case "replace-session":
+          try {
+            await deps.prepareReplacement?.(
+              ctx,
+              action.updateId,
+              action.target,
+            );
+            const result = await ctx.newSession();
+            if (result.cancelled)
+              await deps.notifyResult(action.target, "cancelled");
+          } catch (error) {
+            reportFailure(error);
+            await deps.notifyResult(action.target, "failure");
           }
-        },
-      });
+          return;
+      }
     },
     scheduleAfterUpdate(updateId, target) {
       if (pendingUpdateId !== undefined || pendingAction !== undefined)
@@ -4546,9 +4581,10 @@ export function createTelegramSessionActionRuntime(
       pendingAction = { kind: "replace-session", token, updateId, target };
       void Promise.resolve()
         .then(() =>
-          deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME} ${token}`, {
-            expandPromptTemplates: true,
-          }),
+          deps.sendUserMessage(
+            `/${TELEGRAM_CONNECT_COMMAND_NAME} ${TELEGRAM_INTERNAL_COMMAND_FLAG} new ${token}`,
+            { expandPromptTemplates: true },
+          ),
         )
         .catch((error) => {
           pendingAction = undefined;

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

@@ -92,7 +92,6 @@ export default function (pi: Pi.ExtensionAPI) {
     getCommands,
     getThinkingLevel,
     sendUserMessage,
-    registerCommand,
     setActiveTools,
     setModel,
     setThinkingLevel,
@@ -310,7 +309,6 @@ export default function (pi: Pi.ExtensionAPI) {
     captureAuthority: captureTelegramStateAuthority,
   });
   const sessionActionAssembly = Commands.createTelegramSessionActionAssembly({
-    registerCommand,
     sendUserMessage,
     store: threadStore,
     getProfileName: configStore.getActiveProfileName,
@@ -1364,6 +1362,27 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getAdmissionScope: getTelegramUpdateAdmissionScope,
     getAdmissionJournalBinding: getTelegramQueueJournalBinding,
+    getCommandReplyTarget(message) {
+      if (
+        message.chat.type !== "private" ||
+        "business_connection_id" in message ||
+        !Updates.getTelegramUpdateExecutionFence(message) ||
+        lockRuntime.owns()
+      ) return undefined;
+      Updates.assertTelegramUpdateExecutionCurrent(message);
+      const binding = resolveTelegramFollowerJournalBinding();
+      const target = telegramBusFollowerRegistrationState.getTarget();
+      if (
+        !telegramBusFollowerRegistrationState.isRegistered() ||
+        !binding ||
+        binding.recoveryKey !==
+          followerAdmissionLifecycleRuntime.getJournalBindingKey() ||
+        !target ||
+        (threadStore.getBotState().threadMode === "enabled" &&
+          target.threadId === undefined)
+      ) throw new Error("Telegram command reply lost its registered recipient.");
+      return { ...target };
+    },
     beginCommandEffectWork: publicationRuntime.beginWork,
     getMessageOwnership: messageOwnershipRuntime.getForwardOwnership,
     recordMessageOwnership: messageOwnershipRuntime.recordRouted,
@@ -1763,16 +1782,6 @@ export default function (pi: Pi.ExtensionAPI) {
           },
         );
       },
-      recoverRejectedRecipientTarget(error) {
-        const rejected =
-          error instanceof TelegramApi.TelegramApiFollowerNotAllowedError
-            ? error.requestTarget
-            : undefined;
-        const current = telegramBusFollowerRegistrationState.getTarget();
-        return rejected && current?.threadId !== undefined
-          ? { rejected, current: { chatId: current.chatId, threadId: current.threadId } }
-          : undefined;
-      },
       prepareUpdateForExecution(update) {
         return BusFollower.prepareTelegramBusFollowerJournaledUpdateForExecution(
           update,
@@ -2822,9 +2831,9 @@ export default function (pi: Pi.ExtensionAPI) {
       },
     }.reset,
   );
-  sessionActionsRuntime.register();
   Bindings.registerTelegramCommandsAndTools({
     pi,
+    handleInternalAction: sessionActionsRuntime.handleInternalAction,
     agentDir: Paths.resolveAgentDir(),
     configStore,
     persistConfig: persistTelegramConfigWithSync,

package/node_modules/@llblab/pi-telegram/lib/menu-settings.ts

@@ -90,7 +90,7 @@ export interface TelegramSettingsMenuCallbackDeps extends TelegramSettingsMutati
 export interface TelegramSettingsMenuRuntime<TContext> {
   openSettingsMenu: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,

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

@@ -264,7 +264,7 @@ export interface TelegramMenuActionRuntimeDeps<
   canOfferInFlightModelSwitch: (ctx: TContext) => boolean;
   sendTextReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     text: string,
     options?: {
       target?: { chatId: number; threadId?: number };
@@ -294,21 +294,21 @@ export interface TelegramMenuActionRuntime<
   ) => Promise<void>;
   sendStatusMessage: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   openModelMenu: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   openThinkingMenu: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,

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

@@ -1499,6 +1499,8 @@ export interface TelegramInboundRouteRuntimeDeps<
   getCurrentInstanceId?: () => string | undefined;
   getAdmissionScope?: () => string | undefined;
   getAdmissionJournalBinding?: () => string | undefined;
+  getCommandReplyTarget?:
+    Commands.TelegramCommandTargetRuntimeDeps<TContext>["getReplyTarget"];
   getMessageOwnership?: Updates.TelegramMessageOwnershipLookup;
   getTargetOwnership?: Updates.TelegramTargetOwnershipLookup;
   recordMessageOwnership?: Updates.TelegramMessageOwnershipRecorder;
@@ -1640,7 +1642,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   ) => Promise<void>;
   openSettingsMenu?: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     ctx: TContext,
     threadId?: number,
     options?: Pick<TelegramApiCallOptions, "assertAuthority">,
@@ -1728,7 +1730,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   startGuestPlaceholder?: (inlineMessageId: string) => void;
   sendTextReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     text: string,
     options?: {
       parseMode?: "HTML";
@@ -10181,6 +10183,7 @@ export function createTelegramInboundRouteRuntime<
     appendControlItem: deps.queueMutationRuntime.append,
     getAdmissionScope: deps.getAdmissionScope,
     getAdmissionJournalBinding: deps.getAdmissionJournalBinding,
+    getReplyTarget: deps.getCommandReplyTarget,
     onControlQueued: (message, receipt) =>
       reportQueueAdmission([message], [receipt]),
     showStatus: deps.menuActions.sendStatusMessage,

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

@@ -1049,17 +1049,21 @@ export class TelegramApiStaleTargetError extends Error {
   }
 }
 
-/** The leader's exact refusal of a follower API call outside that follower's own Thread; carries only the requested target. */
+/** A follower API refusal; legacy text alone does not prove the request was rejected before execution. */
 export class TelegramApiFollowerNotAllowedError extends Error {
   readonly requestTarget: { chatId: number; threadId: number } | undefined;
+  /** Present only after a structured pre-execution refusal matches the requested API method. */
+  readonly rejectedRequestMethod: string | undefined;
 
   constructor(
     message: string,
     requestTarget?: { chatId: number; threadId: number },
+    rejectedRequestMethod?: string,
   ) {
     super(message);
     this.name = "TelegramApiFollowerNotAllowedError";
     this.requestTarget = requestTarget ? { ...requestTarget } : undefined;
+    this.rejectedRequestMethod = rejectedRequestMethod;
   }
 }
 
@@ -2086,7 +2090,8 @@ export function createTelegramBridgeApiRuntime(
     notBeforeMs: number;
   };
   const chatActionGates = new Map<string, ChatActionGate>();
-  const chatActionChatGates = new Map<string, ChatActionGate>();
+  // Pin shared cooldowns until every concurrent Thread settles; this state never owns their sends.
+  const chatActionChatGates = new Map<string, { pendingRequests: number; notBeforeMs: number }>();
   const getChatActionKeys = (
     method: string,
     body: Record<string, unknown>,
@@ -2126,7 +2131,7 @@ export function createTelegramBridgeApiRuntime(
         }
       }
       for (const [key, candidate] of chatActionChatGates) {
-        if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
+        if (candidate.pendingRequests === 0 && nowMs >= candidate.notBeforeMs) {
           chatActionChatGates.delete(key);
         }
       }
@@ -2142,11 +2147,10 @@ export function createTelegramBridgeApiRuntime(
         if (chatActionChatGates.size >= chatActionMaxGates) {
           return true as TResponse;
         }
-        chatGate = { notBeforeMs: 0 };
+        chatGate = { pendingRequests: 0, notBeforeMs: 0 };
         chatActionChatGates.set(chatActionKeys.chat, chatGate);
       }
       if (gate.inFlight) return (await gate.inFlight) as TResponse;
-      if (chatGate.inFlight) return true as TResponse;
       if (nowMs < gate.notBeforeMs || nowMs < chatGate.notBeforeMs) {
         return true as TResponse;
       }
@@ -2194,10 +2198,10 @@ export function createTelegramBridgeApiRuntime(
         })
         .finally(() => {
           if (gate.inFlight === request) gate.inFlight = undefined;
-          if (chatGate.inFlight === request) chatGate.inFlight = undefined;
+          chatGate.pendingRequests--;
         });
       gate.inFlight = request;
-      chatGate.inFlight = request;
+      chatGate.pendingRequests++;
       return request;
     }
     try {

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

@@ -10495,7 +10495,6 @@ export interface TelegramUpdateAdmissionLifecycleAssemblyDeps<
     | "getRecipientBindingKey"
     | "hasAuthority"
     | "prepareUpdateForExecution"
-    | "recoverRejectedRecipientTarget"
   >;
   leader: {
     resolveBinding: () =>
@@ -10508,9 +10507,6 @@ export interface TelegramUpdateAdmissionLifecycleAssemblyDeps<
     isRegistered: () => boolean;
     getGeneration: () => string | undefined;
     prepareUpdateForExecution: (update: TUpdate) => TUpdate;
-    recoverRejectedRecipientTarget?: NonNullable<
-      TelegramUpdateAdmissionWorkerRuntimeDeps<TUpdate, TContext>["recoverRejectedRecipientTarget"]
-    >;
     /** Session succession before worker creation, under the exact generation-fenced binding. */
     prepareBinding?: (
       binding: TelegramUpdateAdmissionLifecycleJournalBinding & {
@@ -10535,13 +10531,6 @@ export type TelegramUpdateAdmissionWorkerRuntimeDeps<
     execution?: TelegramUpdateExecutionFence,
   ) => Promise<void>;
   prepareUpdateForExecution?: (update: TUpdate) => TUpdate;
-  /**
-   * Recipient-only recovery for a journaled message whose own Thread changed (for example after its Thread was re-created):
-   * classifies a leader refusal of a reply to the original Thread and returns that Thread plus the owner's current one.
-   */
-  recoverRejectedRecipientTarget?: (error: unknown) =>
-    | { rejected: { chatId: number; threadId: number }; current: TelegramTarget & { threadId: number } }
-    | undefined;
   registry?: TelegramUpdateHandlerRegistry;
 };
 
@@ -10668,7 +10657,6 @@ export function createTelegramUpdateAdmissionWorkerRuntime<
       const typedUpdate = update as TUpdate;
       const prepared = deps.prepareUpdateForExecution?.(typedUpdate) ?? typedUpdate;
       // Journal/source evidence remains the original; only the warm released handler projection changes destination.
-      // Journal/source evidence remains the original; only the warm released handler projection changes destination.
       const projectTo = (destination: TelegramTarget & { threadId: number }): TUpdate => ({ ...prepared,
         ...(prepared.message ? { message: prepared.message.message_thread_id === destination.threadId ? { ...prepared.message }
           : withoutTelegramTurnReplyAnchor({ ...prepared.message, message_thread_id: destination.threadId, reply_to_message: undefined }) } : {}),
@@ -10686,17 +10674,8 @@ export function createTelegramUpdateAdmissionWorkerRuntime<
         if (await deps.settleTerminalExecutionFailure?.(error)) {
           return { kind: "complete" };
         }
-        // The leader refused a reply to a Thread this recipient no longer owns (re-created after the input was journaled).
-        // Re-run once against its current Thread; any other failure, or a second refusal, keeps the ordinary retry state.
-        const recovery = !target ? deps.recoverRejectedRecipientTarget?.(error) : undefined;
-        const message = prepared.message ?? prepared.edited_message;
-        if (recovery && message && message.message_thread_id === recovery.rejected.threadId &&
-            message.chat?.id === recovery.rejected.chatId && recovery.current.chatId === recovery.rejected.chatId &&
-            recovery.current.threadId !== recovery.rejected.threadId) {
-          deps.recordRuntimeEvent?.("inbound-worker", error, { phase: "recipient-target-recovery", updateId: update.update_id,
-            chatId: recovery.current.chatId, staleThreadId: recovery.rejected.threadId, threadId: recovery.current.threadId });
-          return await executeUpdate(projectTo(recovery.current), ctx, signal);
-        }
+        // A refused reply proves only that send was not issued, not that the handler made no prior effects.
+        // Leave failure settlement to the worker's retry policy; never re-enter the handler to recover delivery here.
         throw error;
       }
     },
@@ -10777,9 +10756,6 @@ export function createTelegramUpdateAdmissionLifecycleAssembly<
         spendHistoricalInput: undefined,
         onHeldSourcesPrepared: undefined,
         prepareUpdateForExecution: deps.follower.prepareUpdateForExecution,
-        ...(deps.follower.recoverRejectedRecipientTarget
-          ? { recoverRejectedRecipientTarget: deps.follower.recoverRejectedRecipientTarget }
-          : {}),
       });
     },
     recordRuntimeEvent: deps.recordRuntimeEvent,

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

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

package/node_modules/@llblab/pi-telegram/scripts/run-macos-tests.mjs

@@ -0,0 +1,43 @@
+/**
+ * Deterministic macOS CI test shards
+ * Zones: CI, test execution
+ * Keeps real-process tests isolated and partitions the remaining files without changing test deadlines.
+ */
+import { spawnSync } from "node:child_process";
+import { readdirSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const [shard, phase, mode, ...extra] = process.argv.slice(2);
+if (!["0", "1"].includes(shard) || !["process", "remaining"].includes(phase) ||
+    (mode !== undefined && mode !== "--list") || extra.length) {
+  throw new Error("Usage: run-macos-tests.mjs <0|1> <process|remaining> [--list]");
+}
+const root = fileURLToPath(new URL("..", import.meta.url));
+const entries = readdirSync(join(root, "tests"), { withFileTypes: true })
+  .filter((entry) => entry.name.endsWith(".test.ts"));
+if (entries.some((entry) => !entry.isFile()))
+  throw new Error("The CI test inventory must contain only regular test files.");
+const names = entries.map((entry) => entry.name).sort();
+const processTest = "process-shutdown.test.ts";
+if (!names.includes(processTest)) throw new Error("The real-process test suite is missing.");
+const files = (phase === "process"
+  ? (shard === "0" ? [processTest] : [])
+  : names.filter((name) => name !== processTest).filter((_, index) => index % 2 === Number(shard)))
+  .map((name) => `tests/${name}`);
+if (mode === "--list") {
+  console.log(JSON.stringify(files));
+} else if (files.length) {
+  console.log(`macOS shard ${Number(shard) + 1}/2 ${phase}: ${files.length} test file(s)`);
+  const result = spawnSync(process.execPath, [
+    "--experimental-strip-types", "--import", "./tests/fixtures/canonical-tmpdir.ts",
+    "--test", "--test-concurrency=1", `--test-reporter=${phase === "process" ? "spec" : "dot"}`,
+    ...files,
+  ], {
+    cwd: root,
+    stdio: "inherit",
+    env: { ...process.env, PATH: [join(root, "node_modules", ".bin"), process.env.PATH].filter(Boolean).join(delimiter) },
+  });
+  if (result.error) throw result.error;
+  process.exitCode = result.status ?? 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.36.2",
+  "version": "0.37.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -50,7 +50,7 @@
     "@llblab/pi-codex-usage": "0.13.2",
     "@llblab/pi-grow-loop": "0.9.0",
     "@llblab/pi-state-flow": "0.26.5",
-    "@llblab/pi-telegram": "0.57.7",
+    "@llblab/pi-telegram": "0.58.1",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [