@llblab/pi-telegram 0.54.3 → 0.55.0

package/dist/lib/extension.js

@@ -65,6 +65,8 @@ const telegramBusProtocolIdentity = Bus.createTelegramCurrentBusProtocolIdentity
     Bus.TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT,
     Bus.TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT,
     Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE,
+    Bus.TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND,
+    Bus.TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION,
     Bus.TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE,
     Bus.TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY,
     Bus.TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE,
@@ -303,7 +305,6 @@ export default function (pi) {
     const proactivePushChatIdGetter = Config.createTelegramProactivePushChatIdGetter(proactivePushTargetGetter);
     const buttonActionStore = Outbound.createTelegramButtonActionStore();
     const planGenerativeAppOutput = Outbound.createTelegramOutboundReplyPlanner(buttonActionStore, configControls.getAssistantRenderingMode);
-    const pendingModelSwitchStore = Model.createPendingModelSwitchStore();
     const modelMenuRuntime = Menu.createTelegramModelMenuRuntime();
     const sectionRegistry = Sections.createAndBindTelegramSectionRegistry();
     const timeInjectionRuntime = TimeInjection.createTimeInjectionRuntime({
@@ -323,7 +324,24 @@ export default function (pi) {
         getBotToken: configStore.getBotToken,
     });
     const telegramQueueStore = Queue.createTelegramTransportStampedQueueStore(rawTelegramQueueStore, telegramTransportStampRuntime.getStamp);
-    const telegramApiTargetActivityRuntime = TelegramApi.createTelegramApiTargetActivityRuntime();
+    const captureCleanupDrain = Lifecycle.createTelegramSessionDrainObserver({
+        context: telegramSessionContextStore,
+        captureAuthority() {
+            const epoch = getCurrentLeaderEpoch();
+            return epoch === undefined ? undefined : {
+                epoch, operator: configStore.getAllowedUserId(), stamp: telegramTransportStampRuntime.getStamp(),
+            };
+        },
+        isAuthorityActive(authority) {
+            return getCurrentLeaderEpoch() === authority.epoch &&
+                configStore.getAllowedUserId() === authority.operator &&
+                telegramTransportStampRuntime.isActive(authority.stamp);
+        },
+        onDrained(ctx) { inboundRouteRuntime.onDeliverySettled(ctx); },
+    });
+    const telegramApiTargetActivityRuntime = TelegramApi.createTelegramApiTargetActivityRuntime({
+        captureDrain: captureCleanupDrain,
+    });
     // Retirement protection and dead-owner reclamation must inspect the same journal sources.
     const workspaceRetirementJournalPorts = {
         getActiveTurnTarget: activeTurnRuntime.getTarget,
@@ -478,6 +496,13 @@ export default function (pi) {
         instanceId: telegramInstanceId,
         listRecords: threadStore.list,
         listWorkspaceBindings: threadStore.listWorkspaceBindings,
+        resolveAutomaticDisplayTitle(binding) {
+            return ThreadDisplay.resolveTelegramInitialWorkspaceDisplayName({
+                bindings: threadStore.listWorkspaceBindings(),
+                binding,
+                mode: Config.resolveTelegramThreadDisplayMode(configStore.get()),
+            });
+        },
         getFollowerDisplayTitle: telegramBusFollowerRegistrationState.getDisplayTitle,
         getActiveTurnTarget: activeTurnRuntime.getTarget,
         getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
@@ -526,7 +551,10 @@ export default function (pi) {
         hasDispatchPending: lifecycle.hasDispatchPending,
         isCompactionInProgress: lifecycle.isCompactionInProgress,
         getActiveToolExecutions: lifecycle.getActiveToolExecutions,
-        hasPendingModelSwitch: pendingModelSwitchStore.has,
+        // Status is composed before the model-switch controller; it reads the controller's state when it renders.
+        hasPendingModelSwitch() {
+            return modelSwitchController.hasPendingSwitch();
+        },
         getQueuedItems: telegramQueueStore.getQueuedItems,
         getQueuedItemCount: Queue.countExecutableTelegramQueueItems,
         formatQueuedStatus: Queue.formatQueuedTelegramItemsStatus,
@@ -566,6 +594,11 @@ export default function (pi) {
     // --- Telegram API ---
     const directTelegramApiRuntime = TelegramApi.createDefaultTelegramBridgeApiRuntime({
         getBotToken: configStore.getBotToken,
+        isThreadedMode() {
+            return threadStore.getBotState().threadMode === "enabled" ||
+                telegramBusFollowerRegistrationState.getTarget()?.threadId !== undefined ||
+                telegramBusLeaderState.getTarget()?.threadId !== undefined;
+        },
         getBotScope() {
             const config = configStore.get();
             return (config.botUsername ??
@@ -624,9 +657,13 @@ export default function (pi) {
         lifecycle,
         typing,
         getDefaultChatId: proactivePushChatIdGetter,
+        isThreadedMode() {
+            return deliveryTargetPolicyRuntime.getTargetPolicyView().threaded === true;
+        },
         sendTypingAction,
         updateStatus,
         isContextActive: telegramSessionContextStore.isCurrent,
+        getSessionGeneration: telegramSessionContextStore.getGeneration,
         getTransportAuthority() {
             if (ownsTelegramDirectDelivery()) {
                 const epoch = getCurrentLeaderEpoch();
@@ -654,6 +691,11 @@ export default function (pi) {
     const { replyTransport, editInteractiveMessage, sendInteractiveMessage, sendSectionRichMessage, } = replyRuntime;
     const deliveryTargetPolicyRuntime = Delivery.createTelegramDeliveryTargetPolicyRuntime({
         ownsDirect: lockRuntime.owns,
+        isThreadedMode() {
+            return threadStore.getBotState().threadMode === "enabled" ||
+                telegramBusFollowerRegistrationState.getTarget()?.threadId !== undefined ||
+                telegramBusLeaderState.getTarget()?.threadId !== undefined;
+        },
         isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
         getAllowedChatId: configStore.getAllowedUserId,
         getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
@@ -665,6 +707,7 @@ export default function (pi) {
     const deliveryGenerationSeed = Delivery.createTelegramDeliveryGenerationSeed(telegramInstanceId);
     const deliveryLifecycleRuntime = Delivery.createTelegramBridgeDeliveryLifecycleHooks({
         generationSeed: deliveryGenerationSeed,
+        captureDrain: captureCleanupDrain,
         getTargetPolicyView: deliveryTargetPolicyRuntime.getTargetPolicyView,
         getTransportStamp: telegramTransportStampRuntime.getStamp,
         isTransportStampActive: telegramTransportStampRuntime.isActive,
@@ -716,6 +759,7 @@ export default function (pi) {
     });
     const { activityRuntime, activityVerbosityRuntime, assistantOutputRuntime, publicationRuntime, } = Bindings.createTelegramActivityBindingRuntime({
         generation: deliveryGenerationSeed,
+        captureDrain: captureCleanupDrain,
         assistantOutput: {
             prepareTelegramPreview: previewRuntime.preparePublication,
             authority: {
@@ -781,8 +825,6 @@ export default function (pi) {
     // --- Model And Menu Setup ---
     const modelSwitchController = Model.createTelegramModelSwitchControllerRuntime({
         isIdle,
-        getPendingModelSwitch: pendingModelSwitchStore.get,
-        setPendingModelSwitch: pendingModelSwitchStore.set,
         getActiveTurn: activeTurnRuntime.get,
         getAbortHandler: abort.getHandler,
         hasAbortHandler: abort.hasHandler,
@@ -980,7 +1022,7 @@ export default function (pi) {
         lifecycle: bridgeRuntime.lifecycle,
         isIdle,
         hasPendingMessages,
-        hasPendingControl: pendingModelSwitchStore.has,
+        hasPendingControl: modelSwitchController.hasPendingSwitch,
         publication: publicationRuntime,
         activity: activityRuntime,
         delivery: deliveryLifecycleRuntime,
@@ -1118,6 +1160,11 @@ export default function (pi) {
             return (lockRuntime.owns() &&
                 Bus.hasTelegramBusCapability(telegramBusProtocolIdentity, Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE));
         },
+        canUsePreDispatchRebind(recipient) {
+            return lockRuntime.owns() && telegramBusFollowerRegistry.list().every(function (follower) {
+                return Bus.hasTelegramBusCapability(follower.protocol, Bus.TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND);
+            }) && (recipient?.kind !== "follower" || Bus.hasTelegramBusCapability(telegramBusFollowerRegistry.get(recipient.instanceId)?.protocol, Bus.TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION));
+        },
         hasWorkspaceLiveRebindAuthority() {
             return (lockRuntime.owns() &&
                 Bus.hasTelegramBusCapability(telegramBusProtocolIdentity, Bus.TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE) &&
@@ -1732,6 +1779,7 @@ export default function (pi) {
             followerRegistry: telegramBusFollowerRegistry,
             authSecret: telegramBusAuthSecret,
             protocolIdentity: telegramBusProtocolIdentity,
+            requiresPreDispatchRebindReader() { return threadStore.hasPreDispatchRebindEvidence(); },
             selectedMenuDelivery,
             startPolling: pollingAdmissionRuntime.start,
             stopPolling: pollingAdmissionRuntime.stop,
@@ -2435,10 +2483,12 @@ export default function (pi) {
         isSessionContextActive(ctx) {
             return telegramSessionContextStore.isCurrent(ctx);
         },
+        getSessionGeneration: telegramSessionContextStore.getGeneration,
         isTurnTransportActive(turn) {
             return telegramTransportStampRuntime.isActive(turn.transportStamp);
         },
         updateStatus,
         recordRuntimeEvent,
+        onSessionSettled: inboundRouteRuntime.onSessionSettled,
     });
 }

package/dist/lib/lifecycle.d.ts

@@ -6,6 +6,7 @@
  */
 import * as BusFollower from "./bus-follower.ts";
 import type { AgentEndEvent, AgentSettledEvent, AgentStartEvent, AssistantMessageEvent, BeforeAgentStartEvent, ExtensionAPI, ExtensionContext, InputEvent, MessageEndEvent, SessionBeforeCompactEvent, SessionCompactEvent, SessionCompactFailedEvent, SessionShutdownEvent, SessionStartEvent, ToolExecutionEndEvent, ToolExecutionStartEvent, ToolExecutionUpdateEvent, UIPromptEndEvent, UIPromptStartEvent } from "./pi.ts";
+import * as Machine from "./machine.ts";
 import * as Queue from "./queue.ts";
 export declare function createAgentStartDedupHook(inner: (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>, resetReplyDedup: () => void, schedulePublication?: (task: () => Promise<void>) => void): (event: AgentStartEvent, ctx: ExtensionContext) => Promise<void>;
 type TelegramBeforeAgentStartEvent = Omit<BeforeAgentStartEvent, "systemPrompt"> & {
@@ -112,6 +113,13 @@ export interface TelegramSessionContextStore<TContext> {
 export declare function createTelegramSessionContextStore<TContext>(options?: {
     getIdentity?: (ctx: TContext) => unknown;
 }): TelegramSessionContextStore<TContext>;
+/** Capture drain hints at work admission; late completion never borrows a replacement session or transport. */
+export declare function createTelegramSessionDrainObserver<TContext, TAuthority>(deps: {
+    context: Pick<TelegramSessionContextStore<TContext>, "get" | "getGeneration" | "isCurrent">;
+    captureAuthority: () => TAuthority | undefined;
+    isAuthorityActive: (authority: TAuthority) => boolean;
+    onDrained: (ctx: TContext) => void;
+}): () => (() => void) | undefined;
 export declare function createTelegramSessionGenerationFence(store: TelegramSessionContextStore<ExtensionContext>, hooks: TelegramSessionLifecycleHooks): TelegramSessionLifecycleHooks;
 export interface TelegramBridgeSessionServiceRuntime {
     connection?: TelegramConnectionLifecycle;
@@ -192,9 +200,69 @@ export interface TelegramCompactionObserverRuntime<TContext> {
     onSessionCompactFailed: (event: SessionCompactFailedEvent, ctx: TContext) => void;
     onSessionShutdown: () => void;
 }
+/** The whole compaction-observer state; only `transitionTelegramCompactionObserver` produces a new one. */
+export interface TelegramCompactionObserverState {
+    /** The fallback timer's observation; a timer from any other one is inert. */
+    readonly observation: number | null;
+    /** The typing loop is the observer's to stop; a loop the agent already ran is never stopped by compaction. */
+    readonly typingOwned: boolean;
+    readonly nextObservation: number;
+}
+export type TelegramCompactionObserverEvent = {
+    type: "beforeCompact";
+}
+/** The outcome of the observer's own typing start, reported back by the shell. */
+ | {
+    type: "typingStarted";
+    started: boolean;
+} | {
+    type: "compacted";
+} | {
+    type: "compactFailed";
+} | {
+    type: "timerFired";
+    observation: number;
+    contextActive: boolean;
+} | {
+    type: "shutdown";
+};
+export type TelegramCompactionObserverEffect = {
+    type: "setInProgress";
+    inProgress: boolean;
+} | {
+    type: "startTyping";
+} | {
+    type: "stopTyping";
+} | {
+    type: "updateStatus";
+} | {
+    type: "armTimer";
+    observation: number;
+} | {
+    type: "cancelTimer";
+} | {
+    type: "recordTimeout";
+} | {
+    type: "abandoned";
+} | {
+    type: "requestDispatch";
+};
+export declare function createTelegramCompactionObserverState(): TelegramCompactionObserverState;
+/**
+ * Pure compaction-observer transition. A completion or failure always releases presence; the timeout releases only its
+ * own observation. Typing ownership is sticky: a repeated start while the observer's own loop runs reports `false`
+ * from the shared loop, and must not hand that loop to nobody.
+ */
+export declare function transitionTelegramCompactionObserver(state: TelegramCompactionObserverState, event: TelegramCompactionObserverEvent): Machine.TelegramMachineStep<TelegramCompactionObserverState, TelegramCompactionObserverEffect>;
+/**
+ * The shell around `transitionTelegramCompactionObserver`: it fences inactive contexts, runs effects with the calling
+ * context, reports the typing start back and owns the fallback timer, which keeps the context it was armed under.
+ */
 export declare function createTelegramCompactionObserverRuntime<TContext>(deps: TelegramCompactionObserverRuntimeDeps<TContext>): TelegramCompactionObserverRuntime<TContext>;
 export interface TelegramMessageActivityTypingDeps<TContext> {
     hasActiveTurn: () => boolean;
+    isContextActive?: (ctx: TContext) => boolean;
+    getSessionGeneration?: () => number;
     startTypingLoop: (ctx: TContext) => void;
     onMessageStart: TelegramLifecycleRegistrationDeps["onMessageStart"];
     onMessageUpdate: TelegramLifecycleRegistrationDeps["onMessageUpdate"];

package/dist/lib/lifecycle.js

@@ -6,6 +6,7 @@
  */
 import { randomUUID } from "node:crypto";
 import * as BusFollower from "./bus-follower.js";
+import * as Machine from "./machine.js";
 import * as Queue from "./queue.js";
 import { formatTelegramConnectionFailure } from "./status.js";
 import * as TextGroups from "./text-groups.js";
@@ -195,6 +196,31 @@ export function createTelegramSessionContextStore(options = {}) {
         },
     };
 }
+/** Capture drain hints at work admission; late completion never borrows a replacement session or transport. */
+export function createTelegramSessionDrainObserver(deps) {
+    return () => {
+        try {
+            const ctx = deps.context.get(), generation = deps.context.getGeneration(), authority = deps.captureAuthority();
+            if (ctx === undefined || authority === undefined)
+                return undefined;
+            return () => {
+                queueMicrotask(() => {
+                    try {
+                        if (!deps.context.isCurrent(ctx, generation) || !deps.isAuthorityActive(authority))
+                            return;
+                        const emitted = deps.onDrained(ctx);
+                        if (emitted)
+                            void Promise.resolve(emitted).catch(() => undefined);
+                    }
+                    catch { /* A drain hint is observational, not execution authority. */ }
+                });
+            };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
 export function createTelegramSessionGenerationFence(store, hooks) {
     return {
         async onSessionStart(event, ctx) {
@@ -329,76 +355,165 @@ function unrefTelegramLifecycleTimer(timer) {
     if (typeof timer.unref === "function")
         timer.unref();
 }
+export function createTelegramCompactionObserverState() {
+    return { observation: null, typingOwned: false, nextObservation: 0 };
+}
+/**
+ * Pure compaction-observer transition. A completion or failure always releases presence; the timeout releases only its
+ * own observation. Typing ownership is sticky: a repeated start while the observer's own loop runs reports `false`
+ * from the shared loop, and must not hand that loop to nobody.
+ */
+export function transitionTelegramCompactionObserver(state, event) {
+    const cancel = state.observation === null ? [] : [{ type: "cancelTimer" }];
+    const release = (...tail) => [
+        { type: "setInProgress", inProgress: false },
+        ...(state.typingOwned ? [{ type: "stopTyping" }] : []),
+        { type: "updateStatus" },
+        ...tail,
+    ];
+    switch (event.type) {
+        case "beforeCompact": {
+            const observation = state.nextObservation + 1;
+            return {
+                state: { ...state, observation, nextObservation: observation },
+                effects: [
+                    { type: "setInProgress", inProgress: true },
+                    { type: "startTyping" },
+                    { type: "updateStatus" },
+                    ...cancel,
+                    { type: "armTimer", observation },
+                ],
+            };
+        }
+        case "typingStarted":
+            return {
+                state: { ...state, typingOwned: state.typingOwned || event.started },
+                effects: [],
+            };
+        case "compacted":
+            return {
+                state: { ...state, observation: null, typingOwned: false },
+                effects: [...cancel, ...release({ type: "requestDispatch" })],
+            };
+        case "compactFailed":
+            return {
+                state: { ...state, observation: null, typingOwned: false },
+                effects: [
+                    ...cancel,
+                    ...release({ type: "abandoned" }, { type: "requestDispatch" }),
+                ],
+            };
+        case "timerFired":
+            if (state.observation !== event.observation)
+                return { state, effects: [] };
+            // A replaced context consumes its observation without releasing the replacement's presence.
+            if (!event.contextActive)
+                return { state: { ...state, observation: null }, effects: [] };
+            return {
+                state: { ...state, observation: null, typingOwned: false },
+                effects: release({ type: "recordTimeout" }, { type: "requestDispatch" }),
+            };
+        case "shutdown":
+            return {
+                state: { ...state, observation: null, typingOwned: false },
+                effects: [
+                    ...cancel,
+                    ...(state.typingOwned ? [{ type: "stopTyping" }] : []),
+                ],
+            };
+    }
+}
+/**
+ * The shell around `transitionTelegramCompactionObserver`: it fences inactive contexts, runs effects with the calling
+ * context, reports the typing start back and owns the fallback timer, which keeps the context it was armed under.
+ */
 export function createTelegramCompactionObserverRuntime(deps) {
     const timeoutMs = deps.timeoutMs ?? 300_000;
     const setTimer = deps.setTimer ?? setTimeout;
     const clearTimer = deps.clearTimer ?? clearTimeout;
     let fallbackTimer;
-    let observationGeneration = 0;
-    let typingStartedByObserver = false;
-    const clearFallbackTimer = () => {
-        observationGeneration += 1;
-        if (!fallbackTimer)
-            return;
-        clearTimer(fallbackTimer);
-        fallbackTimer = undefined;
-    };
-    // Stop only a typing loop this observer started; a pre-existing agent-owned loop is preserved.
-    const releaseCompactionPresence = (ctx) => {
-        deps.setCompactionInProgress(false);
-        if (typingStartedByObserver)
-            deps.stopTypingLoop?.();
-        typingStartedByObserver = false;
-        deps.updateStatus(ctx);
-    };
-    const requestDispatch = () => {
-        deps.requestDeferredDispatchNextQueuedTelegramTurn(deps.dispatchNextQueuedTelegramTurn);
+    // The context of the event being dispatched; effects run synchronously inside that dispatch.
+    let call;
+    const machine = Machine.createTelegramMachineRunner({
+        initial: createTelegramCompactionObserverState(),
+        transition: transitionTelegramCompactionObserver,
+        run(effect) {
+            const ctx = call;
+            switch (effect.type) {
+                case "setInProgress":
+                    deps.setCompactionInProgress(effect.inProgress);
+                    return;
+                case "startTyping": {
+                    const result = deps.startTypingLoop?.(ctx);
+                    machine.dispatch({
+                        type: "typingStarted",
+                        started: !!deps.startTypingLoop && result !== false,
+                    });
+                    return;
+                }
+                case "stopTyping":
+                    deps.stopTypingLoop?.();
+                    return;
+                case "updateStatus":
+                    deps.updateStatus(ctx);
+                    return;
+                case "armTimer": {
+                    const armedCtx = ctx;
+                    fallbackTimer = setTimer(() => {
+                        fallbackTimer = undefined;
+                        dispatchFor(armedCtx, {
+                            type: "timerFired",
+                            observation: effect.observation,
+                            contextActive: !deps.isContextActive || deps.isContextActive(armedCtx),
+                        });
+                    }, timeoutMs);
+                    unrefTelegramLifecycleTimer(fallbackTimer);
+                    return;
+                }
+                case "cancelTimer":
+                    if (fallbackTimer !== undefined)
+                        clearTimer(fallbackTimer);
+                    fallbackTimer = undefined;
+                    return;
+                case "recordTimeout":
+                    deps.recordRuntimeEvent?.("compact", new Error("Compaction observer timed out"));
+                    return;
+                case "abandoned":
+                    deps.onCompactionAbandoned?.();
+                    return;
+                case "requestDispatch":
+                    // Observer expiry releases local presence, not Pi's eventual terminal result.
+                    deps.requestDeferredDispatchNextQueuedTelegramTurn(deps.dispatchNextQueuedTelegramTurn);
+                    return;
+            }
+        },
+    });
+    const dispatchFor = (ctx, event) => {
+        const previous = call;
+        call = ctx;
+        try {
+            machine.dispatch(event);
+        }
+        finally {
+            call = previous;
+        }
     };
+    const isActive = (ctx) => !deps.isContextActive || deps.isContextActive(ctx);
     return {
         onSessionBeforeCompact: (_event, ctx) => {
-            if (deps.isContextActive && !deps.isContextActive(ctx))
-                return;
-            deps.setCompactionInProgress(true);
-            const typingStartResult = deps.startTypingLoop?.(ctx);
-            typingStartedByObserver =
-                !!deps.startTypingLoop && typingStartResult !== false;
-            deps.updateStatus(ctx);
-            clearFallbackTimer();
-            const admittedGeneration = observationGeneration;
-            fallbackTimer = setTimer(() => {
-                if (observationGeneration !== admittedGeneration)
-                    return;
-                observationGeneration += 1;
-                fallbackTimer = undefined;
-                if (deps.isContextActive && !deps.isContextActive(ctx))
-                    return;
-                releaseCompactionPresence(ctx);
-                deps.recordRuntimeEvent?.("compact", new Error("Compaction observer timed out"));
-                // Observer expiry releases local presence, not Pi's eventual terminal result.
-                requestDispatch();
-            }, timeoutMs);
-            unrefTelegramLifecycleTimer(fallbackTimer);
+            if (isActive(ctx))
+                dispatchFor(ctx, { type: "beforeCompact" });
         },
         onSessionCompact: (_event, ctx) => {
-            if (deps.isContextActive && !deps.isContextActive(ctx))
-                return;
-            clearFallbackTimer();
-            releaseCompactionPresence(ctx);
-            requestDispatch();
+            if (isActive(ctx))
+                dispatchFor(ctx, { type: "compacted" });
         },
         onSessionCompactFailed: (_event, ctx) => {
-            if (deps.isContextActive && !deps.isContextActive(ctx))
-                return;
-            clearFallbackTimer();
-            releaseCompactionPresence(ctx);
-            deps.onCompactionAbandoned?.();
-            requestDispatch();
+            if (isActive(ctx))
+                dispatchFor(ctx, { type: "compactFailed" });
         },
         onSessionShutdown: () => {
-            clearFallbackTimer();
-            if (typingStartedByObserver)
-                deps.stopTypingLoop?.();
-            typingStartedByObserver = false;
+            dispatchFor(undefined, { type: "shutdown" });
         },
     };
 }
@@ -409,7 +524,11 @@ export function createTelegramMessageActivityTypingHooks(deps) {
     };
     const handleMessageActivity = async (phase, event, ctx, inner) => {
         const typedCtx = ctx;
-        ensureTyping(typedCtx);
+        const generation = deps.getSessionGeneration?.();
+        const isCurrent = () => deps.isContextActive?.(typedCtx) !== false &&
+            (!deps.getSessionGeneration || Object.is(deps.getSessionGeneration(), generation));
+        if (isCurrent())
+            ensureTyping(typedCtx);
         try {
             await inner(event, ctx);
         }
@@ -417,7 +536,8 @@ export function createTelegramMessageActivityTypingHooks(deps) {
             deps.recordRuntimeEvent?.("message-activity", error, { phase });
         }
         finally {
-            ensureTyping(typedCtx);
+            if (isCurrent())
+                ensureTyping(typedCtx);
         }
     };
     return {

package/dist/lib/machine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure state-machine runner
+ * Zones: shared utils
+ * Owns committing a pure transition's next state, running the effects it returns and waking state waiters
+ * Knows nothing about the machines it drives: their state, events, effects, timers and transports stay with each domain
+ */
+/** One transition result: the next state plus effects as data. A machine may add fields, such as a call result. */
+export interface TelegramMachineStep<State, Effect> {
+    state: State;
+    effects: readonly Effect[];
+}
+export interface TelegramMachineRunner<State, Event, Step> {
+    readonly state: State;
+    /** Commits the next state, runs its effects (which may dispatch again), wakes waiters and returns the step. */
+    dispatch(event: Event): Step;
+    /** Resolves once `ready` holds for the committed state, checking now and after every later dispatch. */
+    waitFor(ready: (state: State) => boolean): Promise<void>;
+}
+export declare function createTelegramMachineRunner<State, Event, Effect, Step extends TelegramMachineStep<State, Effect> = TelegramMachineStep<State, Effect>>(options: {
+    initial: State;
+    transition: (state: State, event: Event) => Step;
+    run: (effect: Effect) => void;
+}): TelegramMachineRunner<State, Event, Step>;

package/dist/lib/machine.js

@@ -0,0 +1,37 @@
+/**
+ * Pure state-machine runner
+ * Zones: shared utils
+ * Owns committing a pure transition's next state, running the effects it returns and waking state waiters
+ * Knows nothing about the machines it drives: their state, events, effects, timers and transports stay with each domain
+ */
+export function createTelegramMachineRunner(options) {
+    let state = options.initial;
+    const waiters = new Set();
+    return {
+        get state() {
+            return state;
+        },
+        dispatch(event) {
+            const next = options.transition(state, event);
+            state = next.state;
+            for (const effect of next.effects)
+                options.run(effect);
+            for (const waiter of [...waiters])
+                waiter();
+            return next;
+        },
+        waitFor(ready) {
+            return new Promise((resolve) => {
+                if (ready(state))
+                    return resolve();
+                const waiter = () => {
+                    if (!ready(state))
+                        return;
+                    waiters.delete(waiter);
+                    resolve();
+                };
+                waiters.add(waiter);
+            });
+        },
+    };
+}