@llblab/pi-telegram 0.50.1 → 0.51.1

package/dist/lib/extension.js

@@ -79,7 +79,7 @@ export default function (pi) {
     const workspaceAdmissionRuntime = WorkspaceAdmission.createTelegramWorkspaceAdmissionRuntimeBinding({
         getProfileName: configStore.getActiveProfileName,
         getBotToken: configStore.getBotToken,
-        getPath: Paths.resolveTelegramWorkspaceAdmissionPath,
+        getPath: Paths.resolveTelegramWorkspaceAdmissionPathForProfile,
         owner: {
             processId: telegramProcessId,
             processBirthId: telegramQueueProcessBirthId,
@@ -146,7 +146,7 @@ export default function (pi) {
             },
             getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
         },
-        getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPath,
+        getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPathForProfile,
         getFollowerJournalPath(bindingKey, profileName) {
             return Paths.resolveTelegramFollowerJournalPath(bindingKey, undefined, profileName);
         },
@@ -295,6 +295,45 @@ export default function (pi) {
                 : "clear";
         },
     });
+    const reclaimTelegramWorkspaceDeadOwnerQueue = WorkspaceRetirement.createTelegramWorkspaceDeadOwnerQueueReclaimer({
+        getExternalProtection: captureWorkspaceExternalProtection,
+        getActiveTurnTarget: activeTurnRuntime.getTarget,
+        getQueuedItems: telegramQueueStore.getQueuedItems,
+        resolveLeaderJournal: resolveTelegramUpdateJournalBinding,
+        createFollowerJournalResolver: telegramJournalBindingRuntime.createRecipientResolver,
+        discoverFollowerJournals() {
+            return Journal.discoverTelegramFollowerJournalPaths({
+                directory: Paths.resolveTelegramTempDir(),
+                profileName: configStore.getActiveProfileName(),
+            });
+        },
+        createJournalPathResolver: telegramJournalBindingRuntime.createPathResolver,
+        withJournalReference(binding, operation) {
+            if (!binding.recoveryKey)
+                throw new Error("Telegram workspace journal reference identity is unavailable.");
+            return telegramJournalReferenceRegistry.withReference({
+                referenceClass: "workspace-retirement",
+                recoveryKey: binding.recoveryKey,
+            }, operation);
+        },
+        getRecoveryOwner() {
+            return {
+                instanceId: telegramInstanceId,
+                processId: telegramProcessId,
+                processBirthId: telegramQueueProcessBirthId,
+                sessionGeneration: telegramSessionContextStore.getGeneration(),
+            };
+        },
+        getQueueOwnerLiveness: Bus.getTelegramProcessLiveness,
+        onMutationError(error) {
+            recordRuntimeEvent("Telegram dead-owner queue reclamation was refused.", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        },
+        isBindingCurrent(binding) {
+            return WorkspaceRetirement.isCurrentTelegramWorkspaceBinding(threadStore, binding);
+        },
+    });
     const inactiveThreadCleanupReviewRuntime = ThreadCleanupManager.createTelegramInactiveThreadCleanupReviewRuntime({
         getProfileName() { return configStore.getActiveProfileName() ?? "default"; },
         listBindings: threadStore.listWorkspaceBindings,
@@ -603,7 +642,7 @@ export default function (pi) {
             editMessageText: editTelegramMessageText,
         },
     });
-    const { mutation: queueMutationRuntime, dispatchNext: dispatchNextQueuedTelegramTurn, requestNextDispatchAnnouncement, watchdog: queueDispatchWatchdogRuntime, } = Bindings.createTelegramQueueBindingRuntime({
+    const { mutation: queueMutationRuntime, dispatchNext: dispatchNextQueuedTelegramTurn, requestNextDispatchAnnouncement, cancelNextDispatchAnnouncement, watchdog: queueDispatchWatchdogRuntime, } = Bindings.createTelegramQueueBindingRuntime({
         store: telegramQueueStore,
         queue,
         lifecycle,
@@ -617,6 +656,9 @@ export default function (pi) {
         updateStatus,
         sendTextReply,
         sendUserMessage,
+        reconcileNextDispatchAnnouncementReplyOwnership(item) {
+            Replies.preserveTransportReplyDedupOnNextReset(item.chatId, item.replyToMessageId, item.target);
+        },
         recordRuntimeEvent,
     });
     const { finalizeMarkdownPreview, preparePreviewDelivery } = Outbound.createTelegramOutboundTextPreviewRuntime({
@@ -848,6 +890,7 @@ export default function (pi) {
         isContextActive: telegramSessionContextStore.isCurrent,
         dispatchNextQueuedTelegramTurn,
         requestNextDispatchAnnouncement,
+        cancelNextDispatchAnnouncement,
         requestDeferredDispatchNextQueuedTelegramTurn: deferredQueueDispatchRuntime.request,
         hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,
         startTypingLoop: promptDispatchRuntime.startTypingLoop,
@@ -1169,6 +1212,18 @@ export default function (pi) {
         getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
         runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
         captureWorkspaceExternalProtection,
+        workspaceRotation: {
+            getAdmission: workspaceAdmissionRuntime.resolve,
+            runExclusive: telegramWorkspaceOperationRuntime.runExclusive,
+            deleteThread: directTelegramApiRuntime.deleteWorkspaceThread,
+            reclaimDeadOwnerQueuedWork(binding, isCurrent) {
+                return telegramWorkspaceOperationRuntime.run({
+                    operationId: WorkspaceAdmission.createTelegramWorkspaceAdmissionOperationId(),
+                    operationKind: "workspace.reclaim-dead-owner-queue",
+                    scopes: [{ kind: "target", target: binding.target }],
+                }, reclaimTelegramWorkspaceDeadOwnerQueue.bind(undefined, binding, isCurrent));
+            },
+        },
         callApi(method, body, options) {
             return directTelegramApiRuntime.call(method, body, options);
         },
@@ -1282,6 +1337,15 @@ export default function (pi) {
         recordRuntimeEvent,
         runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
     });
+    const prepareThreadPreservationOnQuit = Sync.createTelegramPreservedLeaderQuitHandler({
+        instanceId: telegramInstanceId,
+        topicTargetStore: threadStore,
+        getCurrentLeaderEpoch,
+        getProfileName: configStore.getActiveProfileName,
+        isPollingSuspended: lockedPollingRuntime.isSuspended,
+        resolveAutomaticThreadCleanupEnabled: configControls.resolveAutomaticThreadCleanupEnabled,
+        runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
+    });
     const telegramBridgeSessionLifecycleDeps = Lifecycle.createTelegramBridgeSessionLifecycleDeps({
         contextStore: telegramSessionContextStore,
         queue: {
@@ -1335,6 +1399,7 @@ export default function (pi) {
             capabilityMonitor: telegramThreadCapabilityMonitor,
             queueWatchdog: queueDispatchWatchdogRuntime,
             guestPlaceholder: { stopAll: guestPlaceholderRuntime.stopAll },
+            prepareThreadPreservationOnQuit,
         },
     });
     const sessionLifecycleRuntime = Lifecycle.createTelegramBridgeSessionLifecycleAssembly(telegramBridgeSessionLifecycleDeps);

package/dist/lib/journal.d.ts

@@ -610,6 +610,9 @@ export interface TelegramUpdateJournalRuntimeBinding {
     runtimeKey: string;
     recoveryKey: string;
     journal: TelegramUpdateJournalStore;
+    readForProtection?: () => {
+        entries: readonly TelegramUpdateJournalEntry[];
+    };
 }
 export interface TelegramUpdateJournalRuntimeBindingResolverDeps {
     getProfileName: () => string | undefined;

package/dist/lib/journal.js

@@ -1443,6 +1443,19 @@ export function createTelegramUpdateJournalRuntimeBindingResolver(deps) {
                 profileName,
                 botIdentity,
             }),
+            readForProtection() {
+                // Protection must never turn corruption/recovery into empty-work evidence.
+                const evidence = inspectTelegramUpdateJournalFamily({
+                    directory: dirname(path), path, profile: profileName, botIdentity,
+                    limits: {
+                        maxFiles: 1024,
+                        maxBytes: TELEGRAM_UPDATE_JOURNAL_MAX_BYTES * 2,
+                        maxEntries: TELEGRAM_UPDATE_JOURNAL_MAX_ENTRIES,
+                        maxWork: TELEGRAM_UPDATE_JOURNAL_MAX_ENTRIES * 1024,
+                    },
+                });
+                return { entries: evidence.kind === "present" ? evidence.file.entries : [] };
+            },
             journal: createTelegramUpdateJournalStore({
                 path,
                 profileName,

package/dist/lib/lifecycle.d.ts

@@ -85,6 +85,7 @@ export interface TelegramBridgeSessionServiceRuntime {
     guestPlaceholder?: {
         stopAll(): void;
     };
+    prepareThreadPreservationOnQuit?: (isSessionCurrent: () => boolean) => (() => Promise<void>) | undefined;
 }
 export interface TelegramBridgeSessionLifecycleAssemblyDeps<TQueueItem, TModel = unknown> {
     contextStore: TelegramSessionContextStore<ExtensionContext>;
@@ -111,6 +112,7 @@ export interface TelegramBridgeSessionLifecyclePorts<TQueueItem, TModel = unknow
         capabilityMonitor: TelegramBridgeSessionServiceRuntime["capabilityMonitor"];
         queueWatchdog: TelegramBridgeSessionServiceRuntime["queueWatchdog"];
         guestPlaceholder?: TelegramBridgeSessionServiceRuntime["guestPlaceholder"];
+        prepareThreadPreservationOnQuit?: TelegramBridgeSessionServiceRuntime["prepareThreadPreservationOnQuit"];
     };
 }
 export declare function createTelegramBridgeSessionLifecycleDeps<TQueueItem, TModel = unknown>(ports: TelegramBridgeSessionLifecyclePorts<TQueueItem, TModel>): TelegramBridgeSessionLifecycleAssemblyDeps<TQueueItem, TModel>;

package/dist/lib/lifecycle.js

@@ -91,7 +91,8 @@ export function createTelegramSessionGenerationFence(store, hooks) {
             if (!store.isCurrent(ctx, generation))
                 return;
             await hooks.onSessionShutdown(event, ctx);
-            store.clear(ctx);
+            if (store.isCurrent(ctx, generation))
+                store.clear(ctx);
         },
     };
 }
@@ -115,6 +116,7 @@ export function createTelegramBridgeSessionLifecycleDeps(ports) {
             capabilityMonitor: ports.services.capabilityMonitor,
             queueWatchdog: ports.services.queueWatchdog,
             guestPlaceholder: ports.services.guestPlaceholder,
+            prepareThreadPreservationOnQuit: ports.services.prepareThreadPreservationOnQuit,
         },
     };
 }
@@ -144,18 +146,37 @@ export function createTelegramBridgeSessionLifecycleAssembly(deps) {
             deps.services.queueWatchdog.start(ctx);
         },
         async onSessionShutdown(event, ctx) {
-            if (!isSessionActive(ctx))
+            const generation = deps.contextStore.getGeneration();
+            const isCurrent = () => deps.contextStore.isCurrent(ctx, generation);
+            if (!isCurrent())
                 return;
+            let preserveThread;
+            if (event.reason === "quit") {
+                try {
+                    preserveThread = deps.services.prepareThreadPreservationOnQuit?.(isCurrent);
+                }
+                catch (error) {
+                    deps.follower.recordRuntimeEvent("session", error, { phase: "preserve-thread-on-quit" });
+                }
+            }
             deps.services.guestPlaceholder?.stopAll();
             await deps.services.delivery.onSessionShutdown();
-            if (!isSessionActive(ctx))
+            if (!isCurrent())
                 return;
             deps.services.queueWatchdog.stop();
             deps.services.capabilityMonitor.stop();
             await queueLifecycle.onSessionShutdown(event, ctx);
-            if (!isSessionActive(ctx))
+            if (!isCurrent())
                 return;
             await deps.services.inboundWorker.onSessionShutdown();
+            if (!isCurrent())
+                return;
+            try {
+                await preserveThread?.();
+            }
+            catch (error) {
+                deps.follower.recordRuntimeEvent("session", error, { phase: "preserve-thread-on-quit" });
+            }
         },
     };
     const followerLifecycle = appendTelegramLifecycleHooks(servicesLifecycle, {

package/dist/lib/locks.d.ts

@@ -133,6 +133,7 @@ export interface TelegramLockedPollingRuntime<TContext extends TelegramLockConte
     start: (ctx: TContext, options?: TelegramLockedPollingStartOptions) => Promise<TelegramLockedPollingStartResult>;
     stop: () => Promise<string>;
     suspend: () => Promise<void>;
+    isSuspended: () => boolean;
     onPersistentConflict: (ctx: TContext, count: number) => Promise<void>;
     onSessionStart: (_event: unknown, ctx: TContext) => Promise<void>;
     registerFollowerWithOwner?: (ctx: TContext, owner: TelegramLockEntry) => boolean | undefined | Promise<boolean | undefined>;

package/dist/lib/locks.js

@@ -551,7 +551,8 @@ export function isProcessAlive(pid) {
         return true;
     }
     catch (error) {
-        return error.code === "EPERM";
+        // Only an absent PID proves death; permission and unexpected failures do not.
+        return error.code !== "ESRCH";
     }
 }
 export function formatTelegramLockEntry(lock) {
@@ -835,6 +836,9 @@ export function createTelegramLockedPollingRuntime(deps) {
     let takeoverCandidate;
     let sessionAutoStartRun;
     let pollingGeneration = 0;
+    let suspendedGeneration;
+    let suspensionsInFlight = 0;
+    let startupsInFlight = 0;
     const ownershipCheckMs = deps.ownershipCheckMs ?? TELEGRAM_OWNERSHIP_CHECK_MS;
     const ownershipRefreshMs = deps.ownershipRefreshMs ?? TELEGRAM_OWNERSHIP_REFRESH_MS;
     const stopOwnershipWatcher = () => {
@@ -846,20 +850,30 @@ export function createTelegramLockedPollingRuntime(deps) {
         ownershipRefreshInterval = undefined;
     };
     const suspendPolling = async () => {
-        pollingGeneration += 1;
-        activeContext = undefined;
-        deps.transportMonitor?.stop();
-        deps.stopFollowerRegistration?.();
-        stopOwnershipWatcher();
-        if (sessionAutoStartRun) {
-            await sessionAutoStartRun;
+        const generation = ++pollingGeneration;
+        suspensionsInFlight += 1;
+        try {
+            activeContext = undefined;
+            deps.transportMonitor?.stop();
             deps.stopFollowerRegistration?.();
+            stopOwnershipWatcher();
+            if (sessionAutoStartRun) {
+                await sessionAutoStartRun;
+                deps.stopFollowerRegistration?.();
+            }
+            if (ownershipStop) {
+                await ownershipStop;
+                return;
+            }
+            await deps.stopPolling();
+            // Unsettled starts, overlapping stops or stale completion cannot certify quiescence.
+            if (generation === pollingGeneration && suspensionsInFlight === 1 && startupsInFlight === 0) {
+                suspendedGeneration = generation;
+            }
         }
-        if (ownershipStop) {
-            await ownershipStop;
-            return;
+        finally {
+            suspensionsInFlight -= 1;
         }
-        await deps.stopPolling();
     };
     const stopAfterOwnershipLoss = () => {
         if (ownershipStop)
@@ -906,6 +920,7 @@ export function createTelegramLockedPollingRuntime(deps) {
             return false;
         activeContext = ctx;
         startOwnershipWatcher(ctx);
+        startupsInFlight += 1;
         try {
             if (!deps.lock.refresh(snapshotLockContext(ctx))) {
                 stopOwnershipWatcher();
@@ -934,6 +949,9 @@ export function createTelegramLockedPollingRuntime(deps) {
             deps.onTransportAvailabilityChanged?.();
             throw error;
         }
+        finally {
+            startupsInFlight -= 1;
+        }
         if (!isCurrent())
             return false;
         if (deps.lock.owns(ctx)) {
@@ -1075,6 +1093,8 @@ export function createTelegramLockedPollingRuntime(deps) {
             return "Telegram bridge disconnected.";
         },
         suspend: suspendPolling,
+        isSuspended: () => suspendedGeneration === pollingGeneration &&
+            suspensionsInFlight === 0 && startupsInFlight === 0 && !sessionAutoStartRun && !ownershipStop,
         onPersistentConflict: async (ctx, count) => {
             if (activeContext === undefined || ownershipStop)
                 return;

package/dist/lib/paths.d.ts

@@ -14,6 +14,12 @@ export interface TelegramAgentDirResolutionInput {
  * 3. Fallback: `~/.pi/agent`.
  */
 export declare function resolveAgentDir(input?: TelegramAgentDirResolutionInput): string;
+/**
+ * Pure reference preflight against an independently approved resource path.
+ * Reject aliases; never repair relative historical references or redirect storage.
+ * Equality proves spelling only, not file identity, consumer closure or migration readiness.
+ */
+export declare function requireTelegramStoragePathReference(path: string, expectedPath: string): string;
 /** Telegram bridge configuration file (<agentDir>/telegram.json). */
 export declare function resolveTelegramConfigPath(): string;
 /** Telegram bridge temporary directory (<agentDir>/tmp/telegram). */
@@ -28,12 +34,16 @@ export declare function getTelegramDiagnosticsDisplayPaths(profileName?: string)
 };
 /** Durable Workspace admission ledger (<agentDir>/tmp/telegram/workspace-admission[.<profile>].json). */
 export declare function resolveTelegramWorkspaceAdmissionPath(agentDir?: string, profileName?: string): string;
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export declare function resolveTelegramWorkspaceAdmissionPathForProfile(profileName?: string): string;
 /** Durable inactive Thread cleanup work-set journal. */
 export declare function resolveTelegramThreadCleanupWorkPath(agentDir?: string, profileName?: string): string;
 /** Durable agent-authored channel post journal. */
 export declare function resolveTelegramChannelPostJournalPath(agentDir?: string, profileName?: string): string;
 /** Durable inbound update journal (<agentDir>/tmp/telegram/inbox[.<profile>].json). */
 export declare function resolveTelegramUpdateJournalPath(agentDir?: string, profileName?: string): string;
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export declare function resolveTelegramUpdateJournalPathForProfile(profileName?: string): string;
 /** Durable follower delivery journal, isolated by stable recipient binding. */
 export declare function resolveTelegramFollowerJournalPath(recipientBindingKey: string, agentDir?: string, profileName?: string): string;
 /** Runtime event log (<agentDir>/tmp/telegram/logs.jsonl). */

package/dist/lib/paths.js

@@ -9,7 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 export const TELEGRAM_DEFAULT_PROFILE_NAME = "default";
 /**
  * Resolve the agent data directory for the current Pi-compatible runtime.
@@ -33,6 +33,19 @@ export function resolveAgentDir(input = {}) {
     }
     return join(homedir(), ".pi", "agent");
 }
+/**
+ * Pure reference preflight against an independently approved resource path.
+ * Reject aliases; never repair relative historical references or redirect storage.
+ * Equality proves spelling only, not file identity, consumer closure or migration readiness.
+ */
+export function requireTelegramStoragePathReference(path, expectedPath) {
+    if (typeof path !== "string" || typeof expectedPath !== "string" ||
+        !isAbsolute(path) || resolve(path) !== path ||
+        !isAbsolute(expectedPath) || resolve(expectedPath) !== expectedPath || path !== expectedPath) {
+        throw new Error("Telegram storage reference does not match its approved absolute path.");
+    }
+    return path;
+}
 /** Telegram bridge configuration file (<agentDir>/telegram.json). */
 export function resolveTelegramConfigPath() {
     return join(resolveAgentDir(), "telegram.json");
@@ -65,6 +78,10 @@ export function getTelegramDiagnosticsDisplayPaths(profileName) {
 export function resolveTelegramWorkspaceAdmissionPath(agentDir = resolveAgentDir(), profileName) {
     return resolveTelegramProfileTempFilePath("workspace-admission", "json", agentDir, profileName);
 }
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export function resolveTelegramWorkspaceAdmissionPathForProfile(profileName) {
+    return resolveTelegramWorkspaceAdmissionPath(resolveAgentDir(), profileName);
+}
 /** Durable inactive Thread cleanup work-set journal. */
 export function resolveTelegramThreadCleanupWorkPath(agentDir = resolveAgentDir(), profileName) {
     return resolveTelegramProfileTempFilePath("thread-cleanup", "json", agentDir, profileName);
@@ -77,6 +94,10 @@ export function resolveTelegramChannelPostJournalPath(agentDir = resolveAgentDir
 export function resolveTelegramUpdateJournalPath(agentDir = resolveAgentDir(), profileName) {
     return resolveTelegramProfileTempFilePath("inbox", "json", agentDir, profileName);
 }
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export function resolveTelegramUpdateJournalPathForProfile(profileName) {
+    return resolveTelegramUpdateJournalPath(resolveAgentDir(), profileName);
+}
 /** Durable follower delivery journal, isolated by stable recipient binding. */
 export function resolveTelegramFollowerJournalPath(recipientBindingKey, agentDir = resolveAgentDir(), profileName) {
     if (!recipientBindingKey) {

package/dist/lib/polling.js

@@ -16,8 +16,8 @@ const TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_MS = 1_000;
 const TELEGRAM_GET_UPDATES_CONFLICT_SLOW_RETRY_MS = 3_000;
 const TELEGRAM_POLLING_RETRY_MS = 3_000;
 export const TELEGRAM_GET_UPDATES_GRACE_MS = 10_000;
-// Standard Telegram DM polling does not expose ordinary message-deletion events,
-// so queue removal stays reaction-driven while delete-like business updates remain defensive-only.
+// Standard Telegram DM polling does not expose ordinary message-deletion events.
+// Business deletions belong to a separate namespace and default routing ignores them.
 export const TELEGRAM_ALLOWED_UPDATES = [
     "message",
     "edited_message",

package/dist/lib/queue.d.ts

@@ -84,6 +84,8 @@ export interface PendingTelegramTurn extends TelegramQueueItemBase {
     historyText: string;
     priorityEmoji?: string;
     reactionSuppressionEmoji?: string;
+    /** Emit the explicit aborted-turn notice when /next settles this active turn. */
+    announceNextAbortOnEnd?: boolean;
     /** Turn should preferably be delivered as voice (mirror mode + user sent voice) */
     voiceReplyPreferred?: boolean;
     /** Turn must be delivered as voice (voice mode) */
@@ -165,6 +167,8 @@ export interface TelegramActiveTurnStore<TTurn extends PendingTelegramTurn = Pen
     has: () => boolean;
     set: (turn: TTurn) => void;
     clear: () => void;
+    markNextAbortAnnouncement: () => boolean;
+    clearNextAbortAnnouncement: () => boolean;
     getChatId: () => number | undefined;
     getTarget: () => TelegramQueueTarget | undefined;
     getReplyToMessageId: () => number | undefined;
@@ -391,6 +395,7 @@ export interface TelegramAgentEndPlan {
     kind: "no-turn" | "aborted" | "error" | "text" | "attachments-only" | "empty";
     shouldClearPreview: boolean;
     shouldDispatchNext: boolean;
+    shouldSendAbortMessage: boolean;
     shouldSendErrorMessage: boolean;
     shouldSendAttachmentNotice: boolean;
 }
@@ -474,7 +479,7 @@ export interface TelegramAgentEndHookRuntimeDeps<TTurn extends PendingTelegramTu
     getActiveTurn: () => TTurn | undefined;
     loadConfig?: () => Promise<void>;
     extractAssistant: (messages: readonly TMessage[]) => TelegramAgentEndAssistantResult;
-    isRecoveredAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
+    isAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
     getFoldQueuedPromptsIntoHistory: () => boolean;
     resetRuntimeState: () => void;
     isSessionActive?: (ctx: TContext) => boolean;
@@ -517,6 +522,7 @@ export declare function buildTelegramAgentEndPlan(options: {
     hasFinalText: boolean;
     hasQueuedAttachments: boolean;
     foldQueuedPromptsIntoHistory: boolean;
+    announceNextAbortOnEnd?: boolean;
 }): TelegramAgentEndPlan;
 export declare function createTelegramAgentEndHook<TTurn extends PendingTelegramTurn, TContext, TMessage, TReplyMarkup = unknown>(deps: TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage, TReplyMarkup>): (event: TelegramAgentEndHookEvent<TMessage>, ctx: TContext, assistantOverride?: TelegramAgentEndAssistantResult) => Promise<void>;
 export declare function handleTelegramAgentEndRuntime<TTurn extends PendingTelegramTurn, TReplyMarkup = unknown>(deps: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>): Promise<void>;
@@ -759,6 +765,7 @@ export interface TelegramQueueDispatchControllerDeps<TContext = unknown> extends
     }>["item"], ctx: TContext) => boolean;
     sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
+    reconcileNextDispatchAnnouncementReplyOwnership?: (item: PendingTelegramTurn) => void;
     isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
     hasPendingInboundQueueMutationForItem?: (item: TelegramQueueItem<TContext>) => boolean;
     isQueueItemAdmissionReady?: (item: TelegramQueueItem<TContext>) => boolean;
@@ -768,6 +775,7 @@ export interface TelegramQueueDispatchControllerDeps<TContext = unknown> extends
 export interface TelegramQueueDispatchController<TContext = unknown> {
     dispatchNext: (ctx: TContext) => void;
     requestNextDispatchAnnouncement: () => void;
+    cancelNextDispatchAnnouncement: () => void;
 }
 export declare function executeTelegramQueueDispatchPlan<TContext = unknown>(plan: TelegramQueueDispatchAction<TContext>, deps: TelegramDispatchRuntimeDeps<TContext>): void;
 export type TelegramQueueDispatchRuntimeDeps<TContext = unknown> = Omit<TelegramQueueDispatchControllerDeps<TContext>, "canDispatch"> & TelegramDispatchReadinessDeps<TContext>;