@llblab/pi-kit 0.35.0 → 0.35.2

package/node_modules/@llblab/pi-telegram/dist/lib/polling.js

@@ -471,6 +471,7 @@ export function createTelegramThreadCapabilityOrchestration(deps) {
         isTopicModeUnavailableError: deps.isTopicModeUnavailableError,
         updateStatus: deps.updateStatus,
         recordEvent: deps.recordEvent,
+        failureLog: deps.failureLog,
     };
     return {
         monitor: createTelegramThreadCapabilityMonitor(capabilityDeps),
@@ -813,8 +814,37 @@ export function createTelegramThreadCapabilityMonitor(deps) {
     let generation = 0;
     let transitionPromise;
     let consecutiveDisabledProbes = 0;
+    // An absent leader endpoint repeats one identical probe failure every interval; the port collapses the run.
+    // Running it through one guard keeps a faulty diagnostics port from breaking probes or the interval callback.
+    const capabilityFailureLog = {
+        record(error, details) {
+            try {
+                deps.failureLog.record(error, details);
+            }
+            catch {
+                // Monitor diagnostics cannot create an uncaught interval exception.
+            }
+        },
+        settled() {
+            try {
+                deps.failureLog.settled();
+            }
+            catch {
+                // Monitor diagnostics cannot fail a completed probe.
+            }
+        },
+        reset() {
+            try {
+                deps.failureLog.reset();
+            }
+            catch {
+                // Monitor diagnostics cannot fail a monitor stop.
+            }
+        },
+    };
     const stop = () => {
         generation += 1;
+        capabilityFailureLog.reset();
         if (interval)
             clearInterval(interval);
         interval = undefined;
@@ -832,6 +862,7 @@ export function createTelegramThreadCapabilityMonitor(deps) {
             .then(async (threadModeEnabled) => {
             if (!isCurrent())
                 return;
+            capabilityFailureLog.settled();
             if (threadModeEnabled === undefined) {
                 if (deps.topicTargetStore.getBotState().threadMode !== "enabled" &&
                     !deps.getPollingStartedWithTelegramBus() &&
@@ -879,12 +910,7 @@ export function createTelegramThreadCapabilityMonitor(deps) {
             .catch((error) => {
             if (!isCurrent())
                 return;
-            try {
-                deps.recordEvent("bus", error, { phase: "capability-monitor" });
-            }
-            catch {
-                // Monitor diagnostics cannot create an unhandled interval rejection.
-            }
+            capabilityFailureLog.record(error);
         })
             .finally(() => {
             if (transitionPromise === tracked)
@@ -911,12 +937,7 @@ export function createTelegramThreadCapabilityMonitor(deps) {
                     catch {
                         /* Timer shutdown must not escape the callback. */
                     }
-                    try {
-                        deps.recordEvent("bus", error, { phase: "capability-monitor" });
-                    }
-                    catch {
-                        // Monitor diagnostics cannot create an uncaught interval exception.
-                    }
+                    capabilityFailureLog.record(error);
                 }
             }, intervalMs);
             interval.unref?.();

package/node_modules/@llblab/pi-telegram/dist/lib/queue.d.ts

@@ -506,10 +506,14 @@ export interface TelegramAgentEndRuntimeDeps<TTurn extends PendingTelegramTurn,
     }) => Promise<void>;
     sendGuestReply?: (guestQueryId: string, markdown: string) => Promise<void>;
     /** Replaces the early guest ACK with the final text. */
-    editGuestReply?: (inlineMessageId: string, markdown: string) => Promise<void>;
+    editGuestReply?: (inlineMessageId: string, markdown: string, options?: {
+        assertAuthority?: () => void;
+    }) => Promise<void>;
     /** Cancels the animated guest placeholder before the final edit. */
     stopGuestPlaceholder?: (inlineMessageId: string) => Promise<void>;
-    sendGuestAttachment?: (turn: TTurn, attachment: QueuedAttachment, caption?: string) => Promise<void>;
+    sendGuestAttachment?: (turn: TTurn, attachment: QueuedAttachment, caption?: string, options?: {
+        isDeliveryActive?: () => boolean;
+    }) => Promise<void>;
     sendGuestVoiceReply?: (turn: TTurn, plan: TelegramAgentEndOutboundReplyPlan<TReplyMarkup>, caption?: string) => Promise<void>;
     planOutboundReply?: (markdown: string) => TelegramAgentEndOutboundReplyPlan<TReplyMarkup>;
     sendOutboundReplyArtifacts?: (turn: TTurn, plan: TelegramAgentEndOutboundReplyPlan, options?: {

package/node_modules/@llblab/pi-telegram/dist/lib/queue.js

@@ -1377,13 +1377,55 @@ export async function handleTelegramAgentEndRuntime(deps) {
                 });
             }
         }
-        if (turn.guestInlineMessageId && deps.editGuestReply) {
-            const experimentText = assistant.errorMessage
+        if (!isDeliveryActive())
+            return;
+        if (turn.guestInlineMessageId) {
+            let experimentText = assistant.errorMessage
                 ? "Telegram bridge: Pi failed while processing the request."
                 : finalText;
+            const [attachment] = turn.queuedAttachments;
+            if (!assistant.errorMessage && attachment) {
+                try {
+                    if (!deps.sendGuestAttachment)
+                        throw new Error("Guest attachment delivery is unavailable.");
+                    await deps.sendGuestAttachment(turn, attachment, finalText || undefined, { isDeliveryActive });
+                    if (isDeliveryActive() && endPlan.shouldDispatchNext)
+                        deps.dispatchNextQueuedTelegramTurn();
+                    return;
+                }
+                catch (error) {
+                    deps.recordRuntimeEvent?.("delivery", error, {
+                        phase: "guest-attachment", guestQueryId: turn.guestQueryId,
+                    });
+                    if (!isDeliveryActive())
+                        return;
+                    if (isTelegramApiCommitUnknownError(error)) {
+                        if (endPlan.shouldDispatchNext)
+                            deps.dispatchNextQueuedTelegramTurn();
+                        return;
+                    }
+                    experimentText = "Telegram bridge could not deliver the requested attachment. Please retry in a normal bot chat.";
+                }
+            }
+            else if (!assistant.errorMessage && hasOutboundArtifacts) {
+                experimentText = [finalText, "Telegram Guest Mode cannot replace an inline placeholder with a voice note. Please request MP3 audio or use a normal bot chat."].filter(Boolean).join("\n\n");
+            }
+            if (!deps.editGuestReply) {
+                deps.recordRuntimeEvent?.("delivery", new Error("Guest inline reply editing is unavailable."), {
+                    phase: "guest-ack-edit", guestQueryId: turn.guestQueryId,
+                });
+                if (endPlan.shouldDispatchNext)
+                    deps.dispatchNextQueuedTelegramTurn();
+                return;
+            }
             if (experimentText) {
                 try {
-                    await deps.editGuestReply(turn.guestInlineMessageId, experimentText);
+                    await deps.editGuestReply(turn.guestInlineMessageId, experimentText, {
+                        assertAuthority() {
+                            if (!isDeliveryActive())
+                                throw new Error("Guest reply edit lost authority.");
+                        },
+                    });
                     deps.recordRuntimeEvent?.("guest", new Error("Guest ACK edited the guest answer"), { phase: "guest-ack-edited", guestQueryId: turn.guestQueryId });
                 }
                 catch (error) {
@@ -1419,7 +1461,7 @@ export async function handleTelegramAgentEndRuntime(deps) {
         const [guestAttachment] = turn.queuedAttachments;
         if (guestAttachment && deps.sendGuestAttachment) {
             try {
-                await deps.sendGuestAttachment(turn, guestAttachment, finalText || undefined);
+                await deps.sendGuestAttachment(turn, guestAttachment, finalText || undefined, { isDeliveryActive });
             }
             catch (error) {
                 deps.recordRuntimeEvent?.("delivery", error, {

package/node_modules/@llblab/pi-telegram/dist/lib/replies.d.ts

@@ -163,8 +163,12 @@ export declare function createGuestMarkdownReplyEditor(deps: {
     editGuestInlineMessage: (inlineMessageId: string, content: {
         richMessage?: TelegramInputRichMessage;
         text?: string;
+    }, options?: {
+        assertAuthority?: () => void;
     }) => Promise<void>;
-}): (inlineMessageId: string, markdown: string) => Promise<void>;
+}): (inlineMessageId: string, markdown: string, options?: {
+    assertAuthority?: () => void;
+}) => Promise<void>;
 /**
  * Guest Mode placeholder rotation: the early ACK is the first placeholder
  * frame and the runtime steps the remaining frames once per interval, moving

package/node_modules/@llblab/pi-telegram/dist/lib/replies.js

@@ -578,11 +578,11 @@ export function createGuestMarkdownReplySender(deps) {
  * chat/message pair.
  */
 export function createGuestMarkdownReplyEditor(deps) {
-    return async (inlineMessageId, markdown) => {
+    return async (inlineMessageId, markdown, options) => {
         const [richMarkdown = markdown] = splitTelegramNativeMarkdown(markdown);
         await deps.editGuestInlineMessage(inlineMessageId, {
             richMessage: { markdown: richMarkdown },
-        });
+        }, options);
     };
 }
 /**

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

@@ -211,6 +211,8 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     canUsePreDispatchRebind?: (recipient?: Threads.TelegramWorkspaceRestoreRecipient) => boolean;
     /** Strict complete namespace plus exact current/historical references; only an empty result clears journal protection. */
     inspectTemporaryThreadSources?: (target: Queue.TelegramQueueTarget, requiredJournalBindingKeys: readonly string[], ownInputs?: readonly Threads.TelegramTemporaryThreadInput[]) => readonly number[] | undefined;
+    /** Explicit cleanup-only recovery; never called by a read-only protection observer. */
+    recoverTemporaryThreadDeadQueueOwners?: (target: Queue.TelegramQueueTarget, requiredJournalBindingKeys: readonly string[], ownInputs: readonly Threads.TelegramTemporaryThreadInput[], isCurrent: () => boolean) => number;
     /** Quiet period after the last cancelled input before one cleanup attempt; defaults to 0 ms. */
     temporaryThreadCleanupDelayMs?: number;
     /** Live-rebind cleanup attempt pacing; the bounded window ends in `not-issued`, never a time-based deletion. */

package/node_modules/@llblab/pi-telegram/dist/lib/routing.js

@@ -4574,6 +4574,100 @@ export function createTelegramInboundRouteRuntime(deps) {
         }
         await promptEnqueue(messages, ctx);
     };
+    /** Local menu acceptance owns a one-shot effect; source removal and cleanup precede its release, never its replay. */
+    const stageTemporaryRerouteMenu = async (pending, command, messages, ctx, assertRecipientCurrent, completion) => {
+        const original = pending.messages[0];
+        const cap = captureTemporaryThreadAuthority(ctx);
+        const temporary = pending.temporaryThread ?? findCreatedTemporaryThread(pending.sourceTarget);
+        if (!cap?.isCurrent() || !temporary)
+            return undefined;
+        let accept, resume;
+        const accepted = new Promise(resolve => { accept = resolve; });
+        const released = new Promise(resolve => { resume = resolve; });
+        const admission = {
+            assertSourceCurrent() {
+                if (!completion.isCurrent())
+                    throw new Error("Rerouted menu source authority changed.");
+            },
+            assertRecipientCurrent,
+            reportCompleted() {
+                const result = completion.reportCompleted();
+                accept(result);
+                return result;
+            },
+            async beforeEffects() {
+                if (!(await released))
+                    throw new Error("Rerouted menu execution was not released.");
+            },
+        };
+        const prepare = command.name === "start" ? commandHandler.prepareSelectedStartCommand
+            : command.name === "help" ? commandHandler.prepareSelectedHelpCommand : commandHandler.prepareSelectedMenuCommand;
+        const dispatch = prepare(command, messages, ctx, admission);
+        if (!dispatch)
+            return undefined;
+        const execution = dispatch().catch(error => {
+            deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-execution" });
+            return false;
+        });
+        if (!(await Promise.race([accepted, execution.then(() => false)]))) {
+            resume(false);
+            await execution;
+            return undefined;
+        }
+        return async () => {
+            let allowEffects = false;
+            try {
+                const confirmed = await new Promise(resolve => {
+                    let done = false, unsubscribe;
+                    const signal = Updates.getTelegramUpdateExecutionFence(original)?.signal;
+                    const finish = (result) => {
+                        if (done)
+                            return;
+                        done = true;
+                        clearTimeout(timer);
+                        unsubscribe?.();
+                        signal?.removeEventListener("abort", abort);
+                        resolve(result);
+                    };
+                    const abort = () => finish(false);
+                    const observe = () => {
+                        if (!cap.isCurrent() || !completion.isCurrent())
+                            finish(false);
+                        else if (completion.inspectCompletion())
+                            finish(true);
+                    };
+                    const timer = setTimeout(abort, deps.liveRebindCommandCompletionTimeoutMs ?? 8_000);
+                    timer.unref?.();
+                    unsubscribe = Updates.subscribeTelegramDeferredSourceCompletion(original, observe);
+                    signal?.addEventListener("abort", abort, { once: true });
+                    if (signal?.aborted)
+                        abort();
+                    else
+                        observe();
+                });
+                if (!confirmed)
+                    throw new Error("Rerouted menu source removal is unconfirmed; execution remains suppressed.");
+                assertRecipientCurrent();
+                cancelTemporaryThreadCleanup(temporary.token);
+                try {
+                    await runTemporaryThreadCleanup(temporary.token, cap, false);
+                }
+                catch (error) {
+                    // Cleanup uncertainty retains its canonical grant, not command execution authority or a retry license.
+                    deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-cleanup" });
+                }
+                assertRecipientCurrent();
+                allowEffects = true;
+            }
+            catch (error) {
+                deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-release" });
+            }
+            finally {
+                resume(allowEffects);
+                await execution;
+            }
+        };
+    };
     const finalizePendingReroute = async (rerouteId, pending, query, successMessage, assertExecutionCurrent = Updates.createTelegramUpdateExecutionFenceGuard(query), retainRecord = false) => {
         assertExecutionCurrent();
         const dismissed = await dismissRerouteChooserMessage(query, assertExecutionCurrent);
@@ -4888,9 +4982,17 @@ export function createTelegramInboundRouteRuntime(deps) {
             if (!cancelledCurrent())
                 return;
             entry = cap.adopt(entry);
-            if (!entry ||
-                !cap.isCurrent() ||
-                isRerouteTargetProtected(target, undefined, entry))
+            if (!entry || !cap.isCurrent())
+                return;
+            if (isRerouteTargetProtected(target, undefined, entry) && deps.recoverTemporaryThreadDeadQueueOwners &&
+                store.inspectTemporaryThreadTarget(entry, cap.authority)?.kind === "temporary") {
+                const inputs = Threads.getTelegramTemporaryThreadInputs(entry);
+                const removed = deps.recoverTemporaryThreadDeadQueueOwners(target, [cap.journalBindingKey, ...inputs.map(input => input.journalBindingKey)], inputs, cap.isCurrent);
+                if (removed > 0)
+                    deps.recordRuntimeEvent?.("routing", "Discarded historical queue receipts from confirmed-dead owners before temporary Thread cleanup.", { phase: "temporary-thread-dead-owner-recovery", removedUpdateCount: removed });
+            }
+            // Recovery is not deletion authority: recapture every ordinary protection after the journal CAS.
+            if (!cap.isCurrent() || isRerouteTargetProtected(target, undefined, entry))
                 return;
             const issued = store.issueTemporaryThreadCleanup(entry, cap.authority);
             if (!issued || !cap.isCurrent())
@@ -5911,7 +6013,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         await deps.answerCallbackQuery(query.id);
         return true;
     };
-    const executeUnboundRerouteCallbackOperation = async (query, ctx) => {
+    const executeUnboundRerouteCallbackOperation = async (query, ctx, afterAdmission) => {
         const parsed = parseTelegramUnboundRerouteCallbackData(query.data);
         if (!parsed)
             return false;
@@ -6432,7 +6534,21 @@ export function createTelegramInboundRouteRuntime(deps) {
         const localMessages = pending.rerouteCopies
             ? cloneTelegramMessagesForThread(pending.messages, parsed.threadId, pending.rerouteCopies.bySourceUpdateId)
             : reroutedMessages;
-        await dispatchPendingRerouteMessages(pending, localMessages, ctx);
+        const command = pending.dispatchKind === "command"
+            ? getLiveRebindMenu(localMessages) ?? getLiveRebindHelp(localMessages) : undefined;
+        const completion = pending.rerouteCopies && command
+            ? Updates.prepareTelegramDeferredSourceCompletion(pending.messages[0]) : undefined;
+        if (command && completion) {
+            const release = await stageTemporaryRerouteMenu(pending, command, localMessages, ctx, assertRerouteCurrent, completion);
+            if (!release) {
+                await deps.answerCallbackQuery(query.id, "Command acceptance unconfirmed; not resending");
+                return true;
+            }
+            afterAdmission(release);
+        }
+        else {
+            await dispatchPendingRerouteMessages(pending, localMessages, ctx);
+        }
         assertRerouteCurrent();
         pending.messages = [];
         return completeRoutedReroute();
@@ -6441,14 +6557,22 @@ export function createTelegramInboundRouteRuntime(deps) {
         const parsed = parseTelegramUnboundRerouteCallbackData(query.data);
         if (!parsed)
             return false;
-        return withPendingRerouteSelection(parsed.rerouteId, query, () => {
-            if (!deps.runWorkspaceOperation)
-                return executeUnboundRerouteCallbackOperation(query, ctx);
-            return deps.runWorkspaceOperation({
-                operationId: `workspace-reroute:${query.id}`,
-                operationKind: "workspace.route-unbound-thread",
-                scopes: [{ kind: "profile" }],
-            }, () => executeUnboundRerouteCallbackOperation(query, ctx));
+        return withPendingRerouteSelection(parsed.rerouteId, query, async () => {
+            let release;
+            const operation = () => executeUnboundRerouteCallbackOperation(query, ctx, value => { release = value; });
+            try {
+                if (!deps.runWorkspaceOperation)
+                    return await operation();
+                return await deps.runWorkspaceOperation({
+                    operationId: `workspace-reroute:${query.id}`,
+                    operationKind: "workspace.route-unbound-thread",
+                    scopes: [{ kind: "profile" }],
+                }, operation);
+            }
+            finally {
+                // Keep the exact source references, but release the non-reentrant Workspace gate before cleanup.
+                await release?.();
+            }
         });
     };
     const handleUnboundRerouteCallback = async (query, ctx) => {

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.d.ts

@@ -4,6 +4,15 @@
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 import * as Machine from "./machine.ts";
+/**
+ * Structural port for run-collapsing diagnostics: a repeated identical failure extends its run instead of logging
+ * again, and the closing success records one outcome. The composition root owns the collapsed implementation.
+ */
+export interface TelegramRepeatedFailureLogPort {
+    record: (error: unknown, details?: Record<string, unknown>) => void;
+    settled: () => void;
+    reset: () => void;
+}
 export interface TelegramRuntimeQueueCounters {
     nextQueuedTelegramItemOrder: number;
     nextQueuedTelegramControlOrder: number;
@@ -103,6 +112,8 @@ export interface TelegramRuntimeEventRecorderPort {
     recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
 }
 export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntimeEventRecorderPort {
+    /** Collapses one sustained presence failure run; the caller supplies its owner. */
+    failureLog: TelegramRepeatedFailureLogPort;
     typing: TelegramRuntimeTypingPort;
     getDefaultChatId: () => number | undefined;
     sendTypingAction: (chatId: number, options?: {

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.js

@@ -162,6 +162,34 @@ function updateTelegramRuntimeStatusSafely(updateStatus, ctx, options) {
 }
 export function createTelegramTypingLoopStarter(deps) {
     let currentOwner;
+    // An unreachable transport repeats one identical presence failure every tick; the port collapses the run.
+    // Running it through one guard keeps a faulty diagnostics port from escaping the in-flight action owner.
+    const typingFailureLog = {
+        record(error, details) {
+            try {
+                deps.failureLog.record(error, details);
+            }
+            catch {
+                // Typing diagnostics cannot escape the in-flight action owner.
+            }
+        },
+        settled() {
+            try {
+                deps.failureLog.settled();
+            }
+            catch {
+                // A successful presence outranks its own diagnostic.
+            }
+        },
+        reset() {
+            try {
+                deps.failureLog.reset();
+            }
+            catch {
+                // Typing diagnostics cannot fail a loop stop.
+            }
+        },
+    };
     return (ctx, chatId, options) => {
         const sessionGeneration = deps.getSessionGeneration?.();
         const transportAuthority = deps.getTransportAuthority?.();
@@ -214,6 +242,7 @@ export function createTelegramTypingLoopStarter(deps) {
                                 throw new Error("Typing context authority changed.");
                         },
                     });
+                    typingFailureLog.settled();
                 }
                 catch (error) {
                     if (!active)
@@ -222,19 +251,13 @@ export function createTelegramTypingLoopStarter(deps) {
                         deps.typing.stop();
                         return;
                     }
-                    try {
-                        deps.recordRuntimeEvent?.("typing", error, {
-                            chatId: targetChatId,
-                        });
-                    }
-                    catch {
-                        // Typing diagnostics cannot escape the in-flight action owner.
-                    }
+                    typingFailureLog.record(error, { chatId: targetChatId });
                 }
             },
             shouldContinue: canContinue,
             onStopped: () => {
                 active = false;
+                typingFailureLog.reset();
                 if (currentOwner === owner)
                     currentOwner = undefined;
             },

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

@@ -299,6 +299,8 @@ export interface TelegramApiCallOptions {
     sleep?: (ms: number) => Promise<void>;
     /** Observability hook fired before a 429 retry wait, never for 5xx waits. */
     onRetryWait?: (wait: TelegramApiRetryWait) => void;
+    /** Caller-owned expected failure: still thrown, but the caller records the outcome instead of the API log. */
+    isExpectedError?: (error: unknown) => boolean;
 }
 export declare class TelegramApiAuthorityError extends Error {
     readonly requestIssued: boolean;
@@ -343,6 +345,12 @@ export interface TelegramAnswerGuestQueryOptions {
     result?: TelegramGuestCachedMediaResult;
 }
 export interface TelegramEditGuestInlineMessageContent {
+    /** Cached media only: inline edits cannot upload a new local file. */
+    media?: {
+        type: "photo" | "document" | "audio";
+        media: string;
+        caption?: string;
+    };
     text?: string;
     richMessage?: TelegramInputRichMessage;
     parseMode?: "HTML";
@@ -465,13 +473,12 @@ export interface TelegramBridgeApiRuntime extends Pick<TelegramApiClient, "call"
     answerCallbackQuery: (callbackQueryId: string, text?: string, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
     answerGuestQuery: (guestQueryId: string, text?: string, options?: TelegramAnswerGuestQueryOptions) => Promise<void>;
     /**
-     * Temporary Guest Mode ACK experiment: answers the guest query and returns
-     * the sent inline message id so the final answer can edit that early reply.
-     * Requires direct transport ownership; Telegram does not document editing
-     * guest answers, so this exists only to falsify that behavior live.
+     * Answers the guest query and retains the sent inline message id for final
+     * text or cached-media replacement. Requires direct transport ownership;
+     * actual guest-media rendering remains live-client gated.
      */
     answerGuestQueryForInlineMessage: (guestQueryId: string, text?: string, options?: TelegramAnswerGuestQueryOptions) => Promise<string | undefined>;
-    editGuestInlineMessage: (inlineMessageId: string, content: TelegramEditGuestInlineMessageContent) => Promise<void>;
+    editGuestInlineMessage: (inlineMessageId: string, content: TelegramEditGuestInlineMessageContent, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
     deleteMessage: (chatId: number, messageId: number) => Promise<void>;
     prepareTempDir: () => Promise<number>;
 }

package/node_modules/@llblab/pi-telegram/dist/lib/telegram-api.js

@@ -1134,7 +1134,8 @@ export function createTelegramBridgeApiRuntime(deps) {
                     "Telegram API deleteMessage failed: HTTP 400: Bad Request: message to delete not found") {
                 return true;
             }
-            deps.recordRuntimeEvent("api", error, withTelegramTransportDiagnostics(error, { method }));
+            if (!options?.isExpectedError?.(error))
+                deps.recordRuntimeEvent("api", error, withTelegramTransportDiagnostics(error, { method }));
             throw error;
         }
     };
@@ -1267,14 +1268,31 @@ export function createTelegramBridgeApiRuntime(deps) {
             const sent = await callRecorded("answerGuestQuery", buildTelegramAnswerGuestQueryBody(guestQueryId, text, options));
             return sent?.inline_message_id;
         },
-        editGuestInlineMessage: async (inlineMessageId, content) => {
+        editGuestInlineMessage: async (inlineMessageId, content, options) => {
+            if (content.media) {
+                try {
+                    const result = await callRecorded("editMessageMedia", {
+                        inline_message_id: inlineMessageId,
+                        media: content.media,
+                    }, { ...options, maxAttempts: 1, retryRateLimit: false });
+                    if (result !== true)
+                        throw new Error("Missing inline edit acknowledgement.");
+                }
+                catch (error) {
+                    // Only a parsed rejection permits replacing this attempt with a failure notice.
+                    if (isTelegramApiRequestRejected(error, "editMessageMedia"))
+                        throw error;
+                    throw new TelegramApiCommitUnknownError("editMessageMedia", error);
+                }
+                return;
+            }
             await callRecorded("editMessageText", {
                 inline_message_id: inlineMessageId,
                 ...(content.richMessage
                     ? { rich_message: content.richMessage }
                     : { text: content.text }),
                 ...(content.parseMode ? { parse_mode: content.parseMode } : {}),
-            });
+            }, options);
         },
         prepareTempDir: () => prepareTelegramTempDir(deps.tempDir, deps.tempFileMaxAgeMs),
         deleteMessage: (chatId, messageId) => callRecorded("deleteMessage", {

package/node_modules/@llblab/pi-telegram/dist/lib/thread-reconciler.js

@@ -339,7 +339,11 @@ export async function applyThreadReconciliationPlan(plan, ports) {
             }
             let deleteConfirmed = false;
             let superseded = false;
-            for (const method of ports.skipCloseBeforeDelete
+            // Private-chat topics (positive chat ids) cannot be closed; Telegram only supports closeForumTopic in forums.
+            const skipClose = ports.skipCloseBeforeDelete ||
+                (action.kind === "close-delete-graceful-shutdown-topic" &&
+                    action.target.chatId > 0);
+            for (const method of skipClose
                 ? ["deleteForumTopic"]
                 : ["closeForumTopic", "deleteForumTopic"]) {
                 if (ports.isCleanupTargetProtected?.(action.target, action)) {

package/node_modules/@llblab/pi-telegram/dist/lib/threads.d.ts

@@ -157,6 +157,10 @@ export interface TelegramWorkspaceExternalProtectionEvidence {
     acceptedWork: TelegramWorkspaceProtectionState;
     deliveryAuthority: TelegramWorkspaceProtectionState;
 }
+/** Per-binding probe; `withSnapshot` lets one occupancy capture share binding-independent evidence reads. */
+export type TelegramWorkspaceExternalProtectionCapture = ((binding: TelegramWorkspaceThreadBinding) => TelegramWorkspaceExternalProtectionEvidence) & {
+    withSnapshot?: <T>(capture: () => T) => T;
+};
 export interface TelegramWorkspaceSlotOccupancySnapshot {
     bindings: TelegramWorkspaceSlotOccupancy[];
     reservedSlots: string[];
@@ -549,7 +553,7 @@ export interface TelegramTopicTargetStore {
         bindingUpdatedAtMs: number;
     }, isCurrent: () => boolean) => Promise<boolean>;
     /** Caller must separately prove no external live owner, accepted work, or delivery authority. */
-    captureWorkspaceSlotOccupancy: (getExternalProtection: (binding: TelegramWorkspaceThreadBinding) => TelegramWorkspaceExternalProtectionEvidence, options?: {
+    captureWorkspaceSlotOccupancy: (getExternalProtection: TelegramWorkspaceExternalProtectionCapture, options?: {
         expectedRetirement?: TelegramWorkspaceRetirementIntent;
     }) => TelegramWorkspaceSlotOccupancySnapshot;
     hasWorkspaceBinding: (cwd: string, sessionId?: string) => boolean;