@llblab/pi-telegram 0.52.1 → 0.53.0

package/dist/lib/polling.js

@@ -14,7 +14,8 @@ export const TELEGRAM_GET_UPDATES_CONFLICT_STOP_LIMIT = 10;
 const TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_LIMIT = 3;
 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;
+const TELEGRAM_POLLING_RETRY_BASE_MS = 1_000;
+const TELEGRAM_POLLING_RETRY_MAX_MS = 30_000;
 const TELEGRAM_GET_UPDATES_GRACE_MS = 10_000;
 // Standard Telegram DM polling does not expose ordinary message-deletion events.
 // Business deletions belong to a separate namespace and default routing ignores them.
@@ -51,6 +52,11 @@ export class TelegramPersistentGetUpdatesConflictError extends Error {
         this.count = count;
     }
 }
+/** Exponential backoff for non-conflict polling/admission failures. */
+export function getTelegramPollingRetryDelayMs(consecutiveFailures) {
+    const exponent = Math.max(0, Math.min(consecutiveFailures - 1, 16));
+    return Math.min(TELEGRAM_POLLING_RETRY_BASE_MS * 2 ** exponent, TELEGRAM_POLLING_RETRY_MAX_MS);
+}
 export class TelegramGetUpdatesTimeoutError extends Error {
     timeoutMs;
     constructor(timeoutMs) {
@@ -152,7 +158,10 @@ export function createTelegramDurablePollingRuntimeAssembly(deps) {
             }
             catch (error) {
                 try {
-                    deps.recordRuntimeEvent?.("polling", error, { phase: "batch-preparation", updateCount: updates.length });
+                    deps.recordRuntimeEvent?.("polling", error, {
+                        phase: "batch-preparation",
+                        updateCount: updates.length,
+                    });
                 }
                 catch {
                     // Already-published input must still reach the worker if diagnostics fail.
@@ -356,8 +365,13 @@ export function startTelegramPollingRuntime(ctx, deps) {
             deps.setPollingController(undefined);
         if (!ownsPromise && !ownsController)
             return;
-        deps.onPollingStopped?.(controller.signal.aborted ? "requested" : persistentConflict
-            ? "persistent-conflict" : failed ? "failed" : "completed");
+        deps.onPollingStopped?.(controller.signal.aborted
+            ? "requested"
+            : persistentConflict
+                ? "persistent-conflict"
+                : failed
+                    ? "failed"
+                    : "completed");
         // Detach the inner promise before outer teardown calls polling.stop().
         if (persistentConflict && !controller.signal.aborted) {
             try {
@@ -367,12 +381,15 @@ export function startTelegramPollingRuntime(ctx, deps) {
                 else {
                     deps.stopTypingLoop();
                     deps.recordRuntimeEvent?.("polling", persistentConflict, {
-                        phase: "persistent-conflict", count: persistentConflict.count,
+                        phase: "persistent-conflict",
+                        count: persistentConflict.count,
                     });
                 }
             }
             catch (error) {
-                deps.recordRuntimeEvent?.("polling", error, { phase: "conflict-stand-down" });
+                deps.recordRuntimeEvent?.("polling", error, {
+                    phase: "conflict-stand-down",
+                });
             }
             if (deps.getPollingController() || deps.getPollingPromise())
                 return;
@@ -429,7 +446,9 @@ export function createTelegramThreadCapabilityOrchestration(deps) {
             const expected = generation;
             return () => expected === generation;
         },
-        invalidate() { generation++; },
+        invalidate() {
+            generation++;
+        },
     };
     const capabilityDeps = {
         lifecycle,
@@ -537,6 +556,29 @@ function hasTelegramThreadCapabilityBindings(store) {
             record.status !== "stale");
     }) ?? false);
 }
+/** Falls back to classic polling, recording a failed restore durably; false once the attempt is stale. */
+async function restoreTelegramClassicPolling(ctx, phase, deps, isCurrent) {
+    try {
+        await deps.startClassicPolling(ctx);
+        return isCurrent();
+    }
+    catch (classicError) {
+        if (!isCurrent())
+            return false;
+        deps.topicTargetStore.setBotState({
+            threadMode: "disabled",
+            updatedAtMs: (deps.getNowMs ?? Date.now)(),
+            lastReconcileAction: `${phase}-classic-restore-failed`,
+        });
+        await deps.topicTargetStore.persist();
+        if (!isCurrent())
+            return false;
+        deps.recordEvent("bus", classicError, {
+            phase: `${phase}-classic-restore`,
+        });
+        return true;
+    }
+}
 export async function applyTelegramThreadCapability(ctx, threadModeEnabled, phase, deps, isCurrent = deps.lifecycle?.capture() ?? (() => true)) {
     if (!isCurrent())
         return;
@@ -574,26 +616,8 @@ export async function applyTelegramThreadCapability(ctx, threadModeEnabled, phas
             deps.setPollingStartedWithTelegramBus(false);
             if (hadLiveThreadTransport)
                 deps.suspendLiveThreadTarget?.();
-            try {
-                await deps.startClassicPolling(ctx);
-                if (!isCurrent())
-                    return;
-            }
-            catch (classicError) {
-                if (!isCurrent())
-                    return;
-                deps.topicTargetStore.setBotState({
-                    threadMode: "disabled",
-                    updatedAtMs: (deps.getNowMs ?? Date.now)(),
-                    lastReconcileAction: `${phase}-classic-restore-failed`,
-                });
-                await deps.topicTargetStore.persist();
-                if (!isCurrent())
-                    return;
-                deps.recordEvent("bus", classicError, {
-                    phase: `${phase}-classic-restore`,
-                });
-            }
+            if (!(await restoreTelegramClassicPolling(ctx, phase, deps, isCurrent)))
+                return;
         }
         deps.updateStatus(ctx);
         return;
@@ -635,26 +659,8 @@ export async function applyTelegramThreadCapability(ctx, threadModeEnabled, phas
                     return;
                 deps.setTopicModeUnavailable(true);
             }
-            try {
-                await deps.startClassicPolling(ctx);
-                if (!isCurrent())
-                    return;
-            }
-            catch (classicError) {
-                if (!isCurrent())
-                    return;
-                deps.topicTargetStore.setBotState({
-                    threadMode: "disabled",
-                    updatedAtMs: (deps.getNowMs ?? Date.now)(),
-                    lastReconcileAction: `${phase}-classic-restore-failed`,
-                });
-                await deps.topicTargetStore.persist();
-                if (!isCurrent())
-                    return;
-                deps.recordEvent("bus", classicError, {
-                    phase: `${phase}-classic-restore`,
-                });
-            }
+            if (!(await restoreTelegramClassicPolling(ctx, phase, deps, isCurrent)))
+                return;
             deps.updateStatus(ctx);
             if (threadModeUnavailable)
                 return;
@@ -753,11 +759,17 @@ export function createTelegramThreadAwarePollingPorts(deps) {
     };
     const restoreFollowerWithOwner = async (ctx, owner) => {
         if (!(await refreshFollowerState())) {
-            deps.recordEvent("bus", "Telegram follower auto-connect skipped: Threaded Mode is not enabled.", { phase: "follower-auto-connect-skip", reason: "thread-mode-unavailable" });
+            deps.recordEvent("bus", "Telegram follower auto-connect skipped: Threaded Mode is not enabled.", {
+                phase: "follower-auto-connect-skip",
+                reason: "thread-mode-unavailable",
+            });
             return undefined;
         }
         if (!deps.hasRememberedWorkspaceBinding?.(ctx)) {
-            deps.recordEvent("bus", "Telegram follower auto-connect skipped: no binding for this session.", { phase: "follower-auto-connect-skip", reason: "session-binding-unavailable" });
+            deps.recordEvent("bus", "Telegram follower auto-connect skipped: no binding for this session.", {
+                phase: "follower-auto-connect-skip",
+                reason: "session-binding-unavailable",
+            });
             return undefined;
         }
         return deps.restoreFollowerWithLeader?.(ctx, owner);
@@ -892,7 +904,9 @@ export function createTelegramThreadCapabilityMonitor(deps) {
                     try {
                         stop();
                     }
-                    catch { /* Timer shutdown must not escape the callback. */ }
+                    catch {
+                        /* Timer shutdown must not escape the callback. */
+                    }
                     try {
                         deps.recordEvent("bus", error, { phase: "capability-monitor" });
                     }
@@ -1103,12 +1117,14 @@ export async function runTelegramPollLoop(deps) {
     if (!deps.config.botToken)
         return;
     let consecutiveGetUpdatesConflicts = 0;
+    let consecutiveFailures = 0;
     const retryConflict = async () => {
         consecutiveGetUpdatesConflicts += 1;
         if (consecutiveGetUpdatesConflicts >= TELEGRAM_GET_UPDATES_CONFLICT_STOP_LIMIT) {
             throw new TelegramPersistentGetUpdatesConflictError(consecutiveGetUpdatesConflicts);
         }
-        await deps.sleep(consecutiveGetUpdatesConflicts < TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_LIMIT
+        await deps.sleep(consecutiveGetUpdatesConflicts <
+            TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_LIMIT
             ? TELEGRAM_GET_UPDATES_CONFLICT_FAST_RETRY_MS
             : TELEGRAM_GET_UPDATES_CONFLICT_SLOW_RETRY_MS, deps.signal);
     };
@@ -1171,6 +1187,7 @@ export async function runTelegramPollLoop(deps) {
                 onPhaseChange: deps.onPhaseChange,
                 recordRuntimeEvent: deps.recordRuntimeEvent,
             });
+            consecutiveFailures = 0;
             currentUpdateId = undefined;
         }
         catch (error) {
@@ -1190,8 +1207,10 @@ export async function runTelegramPollLoop(deps) {
                     : {}),
             });
             consecutiveGetUpdatesConflicts = 0;
+            consecutiveFailures += 1;
             deps.onErrorStatus(getTelegramPollingErrorMessage(error));
-            await deps.sleep(TELEGRAM_POLLING_RETRY_MS, deps.signal);
+            // Cap the pause, not retry count: outages must recover without manual reconnect.
+            await deps.sleep(getTelegramPollingRetryDelayMs(consecutiveFailures), deps.signal);
             if (deps.signal.aborted)
                 return;
             deps.onStatusReset();

package/dist/lib/preview.js

@@ -3,8 +3,8 @@
  * Zones: telegram outbound, native rich markdown drafts
  * Owns safe draft preview selection, runtime updates, and preview finalization
  */
-import { normalizeTelegramNativeMarkdown } from "./replies.js";
 import { stripTelegramCommentMarkupForPreview } from "./outbound-markup.js";
+import { isTelegramMarkdownFenceClosing, normalizeTelegramNativeMarkdown, parseTelegramMarkdownFenceOpening, } from "./replies.js";
 import { getTelegramTargetThreadParams, } from "./target.js";
 import { shouldSuppressPreviewForVoice } from "./voice.js";
 const TELEGRAM_DRAFT_ID_MAX = 2_147_483_647;
@@ -73,9 +73,15 @@ export function createTelegramAssistantPreviewRuntime(deps) {
                 clearPreview: async (chatId, options) => {
                     if (controller.getState() !== state || !isDeliveryActive())
                         return;
-                    await controller.prepareClear(chatId, { ...options, isDeliveryActive })();
+                    await controller.prepareClear(chatId, {
+                        ...options,
+                        isDeliveryActive,
+                    })();
                 },
-                finalizeMarkdownPreview: prepareTelegramNativeMarkdownPreviewFinalizer({ ...finalizerDeps, isDeliveryActive }),
+                finalizeMarkdownPreview: prepareTelegramNativeMarkdownPreviewFinalizer({
+                    ...finalizerDeps,
+                    isDeliveryActive,
+                }),
             };
         },
         ...createTelegramAssistantMessagePreviewHooks({
@@ -130,7 +136,10 @@ export function createTelegramPreviewController(deps) {
         createState: () => createTelegramPreviewRuntimeState(),
         resetState: () => {
             generation += 1;
-            setState({ ...createTelegramPreviewRuntimeState(), nextDraftAt: state?.nextDraftAt });
+            setState({
+                ...createTelegramPreviewRuntimeState(),
+                nextDraftAt: state?.nextDraftAt,
+            });
         },
         invalidate: () => {
             generation += 1;
@@ -143,8 +152,15 @@ export function createTelegramPreviewController(deps) {
             sealTelegramPreviewState(state);
             const prior = state.publicationPromise ?? state.flushPromise ?? state.precedingFlush;
             let settle;
-            state.publicationPromise = new Promise((resolve) => { settle = resolve; });
-            return { wait: async () => { await prior?.catch(() => { }); }, settle };
+            state.publicationPromise = new Promise((resolve) => {
+                settle = resolve;
+            });
+            return {
+                wait: async () => {
+                    await prior?.catch(() => { });
+                },
+                settle,
+            };
         },
         prepareClear: (chatId, options) => {
             const admittedState = state;
@@ -154,7 +170,8 @@ export function createTelegramPreviewController(deps) {
                     return;
                 await clearTelegramPreview(chatId, runtime, {
                     ...options,
-                    isDeliveryActive: () => runtime.canSend?.() !== false && options?.isDeliveryActive?.() !== false,
+                    isDeliveryActive: () => runtime.canSend?.() !== false &&
+                        options?.isDeliveryActive?.() !== false,
                 });
             };
         },
@@ -208,7 +225,8 @@ async function handleTelegramAssistantMessagePreviewStart(message, deps) {
     // Carry the previous delivery boundary; permanent text remains with its publication owner.
     next.draftId = state?.draftId;
     next.nextDraftAt = state?.nextDraftAt;
-    next.precedingFlush = state?.publicationPromise ?? state?.flushPromise ?? state?.precedingFlush;
+    next.precedingFlush =
+        state?.publicationPromise ?? state?.flushPromise ?? state?.precedingFlush;
     deps.setState(next);
 }
 async function handleTelegramAssistantMessagePreviewUpdate(message, deps) {
@@ -280,7 +298,9 @@ export async function clearTelegramPreview(chatId, deps, options = {}) {
     if (options.isDeliveryActive?.() === false)
         return;
     deps.setState(undefined);
-    if (state.mode === "draft" && state.draftId !== undefined && deps.canSend?.() !== false) {
+    if (state.mode === "draft" &&
+        state.draftId !== undefined &&
+        deps.canSend?.() !== false) {
         try {
             await deps.sendDraft(chatId, state.draftId, undefined, {
                 ...getTelegramTargetThreadParams(options.target ?? { chatId }),
@@ -423,9 +443,8 @@ function updateTelegramDraftInlineStateForLine(line, state) {
     }
 }
 function updateTelegramDraftBlockStateForLine(line, state) {
-    const fenceMatch = line.match(/^ {0,3}(`{3,}|~{3,})/);
     if (state.fence) {
-        if (new RegExp(`^ {0,3}${state.fence.marker}{${state.fence.length},}\\s*$`).test(line)) {
+        if (isTelegramMarkdownFenceClosing(line, state.fence)) {
             state.fence = undefined;
         }
         return true;
@@ -435,12 +454,9 @@ function updateTelegramDraftBlockStateForLine(line, state) {
             state.displayMath = false;
         return true;
     }
-    if (fenceMatch) {
-        const markerText = fenceMatch[1] ?? "```";
-        state.fence = {
-            marker: markerText[0],
-            length: markerText.length,
-        };
+    const openingFence = parseTelegramMarkdownFenceOpening(line);
+    if (openingFence) {
+        state.fence = openingFence;
         return true;
     }
     if (line.trim() === "$$") {
@@ -523,7 +539,9 @@ async function performTelegramPreviewFlush(chatId, state, deps, options = {}) {
         state.nextDraftAt = Date.now() + (deps.minDraftIntervalMs ?? 0);
         try {
             const delivered = await deps.sendDraft(chatId, draftId, normalizeTelegramNativeMarkdown(snapshot.text), { ...getTelegramTargetThreadParams(options.target ?? { chatId }) });
-            if (delivered === false || deps.getState() !== state || deps.canSend?.() === false)
+            if (delivered === false ||
+                deps.getState() !== state ||
+                deps.canSend?.() === false)
                 return;
             deps.setDraftSupport("supported");
             state.mode = "draft";
@@ -584,7 +602,9 @@ export async function flushTelegramPreview(chatId, deps, options = {}) {
                 });
                 break;
             }
-        } while (deps.getState() === state && !state.sealed && state.flushRequested);
+        } while (deps.getState() === state &&
+            !state.sealed &&
+            state.flushRequested);
     })();
     try {
         await state.flushPromise;

package/dist/lib/process-identity.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Process identity and liveness proofs
+ * Zones: shared utils, multi-instance bus, durable admission
+ * Owns PID liveness probes and stable Linux/macOS/Windows process-birth identity. Only an absent PID or a
+ * mismatched birth proof establishes death; inaccessible metadata stays unverifiable.
+ */
+export declare function isProcessAlive(pid: number): boolean;
+interface TelegramProcessBirthIdentityOptions {
+    platform?: NodeJS.Platform;
+    readProcStat?: (pid: number) => string;
+    readDarwinProcessStart?: (pid: number) => string;
+    readWindowsProcessStart?: (pid: number) => string;
+}
+export type TelegramProcessLiveness = "alive" | "dead" | "unverifiable";
+interface TelegramProcessLivenessOptions extends TelegramProcessBirthIdentityOptions {
+    isProcessAlive?: (pid: number) => boolean;
+}
+export declare function getTelegramProcessBirthIdentity(pid: number, fallbackGeneration: number | string, options?: TelegramProcessBirthIdentityOptions): string;
+export declare function getTelegramProcessLiveness(owner: {
+    processId: number;
+    processBirthId: string;
+}, options?: TelegramProcessLivenessOptions): TelegramProcessLiveness;
+export declare function getTelegramProcessBirthIdentityLiveness(processBirthId: string, options?: TelegramProcessLivenessOptions): TelegramProcessLiveness;
+export {};

package/dist/lib/process-identity.js

@@ -0,0 +1,133 @@
+/**
+ * Process identity and liveness proofs
+ * Zones: shared utils, multi-instance bus, durable admission
+ * Owns PID liveness probes and stable Linux/macOS/Windows process-birth identity. Only an absent PID or a
+ * mismatched birth proof establishes death; inaccessible metadata stays unverifiable.
+ */
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { platform as getPlatform } from "node:os";
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // Only an absent PID proves death; permission and unexpected failures do not.
+        return error.code !== "ESRCH";
+    }
+}
+function readDarwinProcessStart(pid) {
+    return execFileSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+/** Creation time in UTC 100 ns ticks; PowerShell ships with every supported Windows and needs no native addon. */
+function readWindowsProcessStart(pid) {
+    const root = process.env.SystemRoot ?? "C:\\Windows";
+    return execFileSync(`${root}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`,
+    ], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 10_000,
+        windowsHide: true,
+    }).trim();
+}
+/** The current process never changes birth, so its slow Windows proof is read once; other PIDs are never cached. */
+let ownWindowsBirthProof;
+function getTelegramProcessBirthProof(pid, options = {}) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return { status: "unverifiable" };
+    const platform = options.platform ?? getPlatform();
+    if (platform === "linux") {
+        try {
+            const stat = (options.readProcStat ??
+                ((targetPid) => readFileSync(`/proc/${targetPid}/stat`, "utf8")))(pid);
+            const closeParen = stat.lastIndexOf(")");
+            const fields = stat
+                .slice(closeParen + 2)
+                .trim()
+                .split(/\s+/u);
+            const startTicks = fields[19];
+            if (startTicks) {
+                return { status: "proven", identity: `${pid}:start:${startTicks}` };
+            }
+        }
+        catch {
+            /* inaccessible process metadata */
+        }
+    }
+    else if (platform === "darwin") {
+        try {
+            const startedAt = (options.readDarwinProcessStart ?? readDarwinProcessStart)(pid);
+            if (startedAt) {
+                const fingerprint = createHash("sha256")
+                    .update(startedAt)
+                    .digest("hex")
+                    .slice(0, 16);
+                return { status: "proven", identity: `${pid}:start:${fingerprint}` };
+            }
+        }
+        catch {
+            /* inaccessible process metadata */
+        }
+    }
+    else if (platform === "win32") {
+        const injected = options.readWindowsProcessStart;
+        if (!injected && pid === process.pid && ownWindowsBirthProof)
+            return ownWindowsBirthProof;
+        let proof = { status: "unverifiable" };
+        try {
+            const ticks = (injected ?? readWindowsProcessStart)(pid);
+            if (/^\d+$/u.test(ticks))
+                proof = { status: "proven", identity: `${pid}:start:${ticks}` };
+        }
+        catch {
+            /* inaccessible process metadata, including another user's process */
+        }
+        if (!injected && pid === process.pid && proof.status === "proven")
+            ownWindowsBirthProof = proof;
+        return proof;
+    }
+    return { status: "unverifiable" };
+}
+export function getTelegramProcessBirthIdentity(pid, fallbackGeneration, options = {}) {
+    const proof = getTelegramProcessBirthProof(pid, options);
+    return proof.status === "proven"
+        ? proof.identity
+        : `${pid}:generation:${fallbackGeneration}`;
+}
+export function getTelegramProcessLiveness(owner, options = {}) {
+    const processAlive = options.isProcessAlive ?? isProcessAlive;
+    if (!processAlive(owner.processId))
+        return "dead";
+    const proof = getTelegramProcessBirthProof(owner.processId, options);
+    if (proof.status === "unverifiable")
+        return "unverifiable";
+    return proof.identity === owner.processBirthId ? "alive" : "dead";
+}
+export function getTelegramProcessBirthIdentityLiveness(processBirthId, options = {}) {
+    const match = /^(\d+):(start|generation):(.+)$/u.exec(processBirthId);
+    if (!match)
+        return "unverifiable";
+    const processId = Number(match[1]);
+    if (!Number.isSafeInteger(processId) || processId <= 0)
+        return "unverifiable";
+    const processAlive = options.isProcessAlive ?? isProcessAlive;
+    if (!processAlive(processId))
+        return "dead";
+    if (match[2] === "generation")
+        return "unverifiable";
+    const proof = getTelegramProcessBirthProof(processId, options);
+    if (proof.status === "unverifiable")
+        return "unverifiable";
+    return proof.identity === processBirthId ? "alive" : "dead";
+}

package/dist/lib/prompts.js

@@ -121,13 +121,8 @@ export function buildTelegramBridgeSystemPrompt(options) {
         : "";
     return {
         systemPrompt: Array.isArray(basePrompt)
-            ? [
-                ...basePrompt,
-                options.localSystemPromptSuffix + telegramSuffix,
-            ]
-            : basePrompt +
-                options.localSystemPromptSuffix +
-                telegramSuffix,
+            ? [...basePrompt, options.localSystemPromptSuffix + telegramSuffix]
+            : basePrompt + options.localSystemPromptSuffix + telegramSuffix,
     };
 }
 export function createTelegramBeforeAgentStartHook(options = {}) {

package/dist/lib/queue.d.ts

@@ -188,9 +188,7 @@ export declare function createTelegramQueueAdmissionReceipt(options: {
     scope: string;
     sourceUpdateIds: readonly number[];
 }): TelegramQueueAdmissionReceipt | undefined;
-export declare function isTelegramQueueItemDurablyAdmitted<TContext = unknown>(item: TelegramQueueItem<TContext>, isReceiptCommitted: (receipt: TelegramQueueAdmissionReceipt) => boolean): boolean;
 export declare function getTelegramQueueLaneContract(lane: TelegramQueueLane): TelegramQueueLaneContract;
-export declare function getTelegramQueueItemAdmissionMode(item: Pick<TelegramQueueItem, "queueLane">): TelegramQueueAdmissionMode;
 export declare function isTelegramQueueItemAdmissionValid(item: Pick<TelegramQueueItem, "kind" | "queueLane">): boolean;
 export declare function assertTelegramQueueItemAdmissionValid(item: Pick<TelegramQueueItem, "kind" | "queueLane" | "admissionReceipts">): void;
 export declare function createTelegramQueueStore<TContext = unknown>(initialItems?: TelegramQueueItem<TContext>[]): TelegramQueueStateStore<TContext>;
@@ -202,6 +200,13 @@ export declare function createTelegramTransportStampedQueueStore<TContext>(store
 export declare function countExecutableTelegramQueueItems<TContext = unknown>(items: readonly TelegramQueueItem<TContext>[]): number;
 export declare function createTelegramQueueItemCountGetter<TContext = unknown>(store: Pick<TelegramQueueStore<TContext>, "getQueuedItems">): () => number;
 export declare function createTelegramActiveTurnStore<TTurn extends PendingTelegramTurn = PendingTelegramTurn>(): TelegramActiveTurnStore<TTurn>;
+/** Current captured targets only; skipped/receipt-held items remain work, never historical census. */
+export declare function observeTelegramTargetQueueWork(target: TelegramQueueTarget & {
+    threadId: number;
+}, activeTurn: Pick<TelegramQueueItemBase, "chatId" | "target"> | undefined, items: readonly Pick<TelegramQueueItemBase, "chatId" | "target">[]): {
+    protected: boolean;
+    unknown: boolean;
+};
 export declare function partitionTelegramQueueItemsForHistory<TContext = unknown>(items: TelegramQueueItem<TContext>[]): {
     historyTurns: PendingTelegramTurn[];
     remainingItems: TelegramQueueItem<TContext>[];
@@ -586,7 +591,7 @@ export interface TelegramSessionShutdownRuntimeDeps<TQueueItem> {
     clearAbort: () => void;
     stopPolling: () => Promise<void>;
 }
-export interface TelegramSessionLifecycleHookRuntimeDeps<TContext, TQueueItem, TModel = unknown> extends TelegramRuntimeEventRecorderPort {
+export interface TelegramSessionLifecycleHookRuntimeDeps<TContext, TQueueItem, TModel = unknown> extends TelegramRuntimeEventRecorderPort, Omit<TelegramSessionShutdownRuntimeDeps<TQueueItem>, "isSessionActive" | "discardQueuedItems" | "applyState"> {
     getCurrentModel: (ctx: TContext) => TModel | undefined;
     loadConfig: () => Promise<void>;
     applySessionStartState: (state: TelegramSessionStartState<TModel>) => void;
@@ -594,20 +599,8 @@ export interface TelegramSessionLifecycleHookRuntimeDeps<TContext, TQueueItem, T
     prepareTempDir: () => Promise<unknown>;
     updateStatus: (ctx: TContext) => void;
     isSessionActive?: (ctx: TContext) => boolean;
-    unbindDeferredDispatchContext?: () => void;
     discardQueuedItems?: (ctx: TContext) => void;
     applySessionShutdownState: (state: TelegramSessionShutdownState<TQueueItem>) => void;
-    clearPendingMediaGroups: () => void;
-    clearModelMenuState: () => void;
-    getActiveTurnChatId: () => number | undefined;
-    getActiveTurnTarget?: () => TelegramQueueTarget | undefined;
-    clearPreview: (chatId: number, options?: {
-        target?: TelegramQueueTarget;
-    }) => Promise<void>;
-    previewShutdownTimeoutMs?: number;
-    clearActiveTurn: () => void;
-    clearAbort: () => void;
-    stopPolling: () => Promise<void>;
 }
 export type TelegramSessionLifecycleHookEvent = unknown;
 export declare function createTelegramSessionStateApplier<TQueueItem, TModel>(deps: TelegramSessionStateApplierDeps<TQueueItem, TModel>): TelegramSessionStateApplier<TQueueItem, TModel>;
@@ -648,6 +641,8 @@ export interface TelegramPromptEnqueueRuntimeDeps<TMessage, TContext = unknown>
     updateStatus: () => void;
     dispatchNextQueuedTelegramTurn: () => void;
     assertExecutionCurrent?: () => void;
+    /** Input-specific relocation must not fold or replace unrelated queued work. */
+    preserveQueued?: boolean;
     onQueued?: (turn: PendingTelegramTurn) => void;
 }
 export interface TelegramPromptEnqueueControllerDeps<TMessage, TContext = unknown> extends TelegramQueueStore<TContext> {
@@ -660,7 +655,10 @@ export interface TelegramPromptEnqueueControllerDeps<TMessage, TContext = unknow
     assertExecutionCurrent?: (messages: TMessage[]) => void;
 }
 export interface TelegramPromptEnqueueController<TMessage, TContext = unknown> {
-    enqueue: (messages: TMessage[], ctx: TContext, onQueued?: (turn: PendingTelegramTurn) => void) => Promise<PendingTelegramTurn>;
+    enqueue: (messages: TMessage[], ctx: TContext, onQueued?: (turn: PendingTelegramTurn) => void, options?: {
+        assertCurrent?: () => void;
+        preserveQueued?: boolean;
+    }) => Promise<PendingTelegramTurn>;
 }
 export declare function buildTelegramSessionStartState<TModel = unknown>(currentModel: TModel | undefined): TelegramSessionStartState<TModel>;
 export declare function buildTelegramSessionShutdownState<TQueueItem>(): TelegramSessionShutdownState<TQueueItem>;