@llblab/pi-telegram 0.22.1 → 0.23.1

package/index.ts

@@ -155,11 +155,6 @@ export default function (pi: Pi.ExtensionAPI) {
       contextStore: telegramSessionContextStore,
     });
   const activeTurnRuntime = Queue.createTelegramActiveTurnStore();
-  const proactivePushChatIdGetter =
-    Config.createTelegramProactivePushChatIdGetter({
-      getActiveTurnChatId: activeTurnRuntime.getChatId,
-      getAllowedUserId: configStore.getAllowedUserId,
-    });
   const proactivePushTargetGetter =
     Config.createTelegramProactivePushTargetGetter({
       getActiveTurnTarget: activeTurnRuntime.getTarget,
@@ -171,6 +166,8 @@ export default function (pi: Pi.ExtensionAPI) {
       },
       getAllowedUserId: configStore.getAllowedUserId,
     });
+  const proactivePushChatIdGetter =
+    Config.createTelegramProactivePushChatIdGetter(proactivePushTargetGetter);
   const buttonActionStore = Outbound.createTelegramButtonActionStore();
   const pendingModelSwitchStore =
     Model.createPendingModelSwitchStore<
@@ -220,14 +217,11 @@ export default function (pi: Pi.ExtensionAPI) {
       scheduleSnapshotPersist: runtimeDiagnostics.scheduleSnapshotPersist,
     });
   const recordThreadReconciliationPlan = threadReconciliationRuntime.recordPlan;
-  const markTelegramConfigSyncChange =
-    telegramSyncStateRuntime.markConfigChange;
-  const persistTelegramConfigWithSync = async function (
-    nextConfig?: Config.TelegramConfig,
-  ) {
-    await configStore.persist(nextConfig);
-    markTelegramConfigSyncChange("config-persist");
-  };
+  const persistTelegramConfigWithSync =
+    Sync.createTelegramConfigSyncPersister<Config.TelegramConfig>({
+      persist: configStore.persist,
+      markConfigChange: telegramSyncStateRuntime.markConfigChange,
+    });
   const currentInstanceThreadRuntime =
     Threads.createTelegramCurrentInstanceThreadRuntime({
       instanceId: telegramInstanceId,
@@ -271,7 +265,7 @@ export default function (pi: Pi.ExtensionAPI) {
       getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
       getFollowerSlot: telegramBusFollowerRegistrationState.getSlot,
       getFollowerThreadName: telegramBusFollowerRegistrationState.getThreadName,
-      getCurrentIdentity: getCurrentInstanceThreadIdentity,
+      getCurrentIdentity: currentInstanceThreadRuntime.getRestorationIdentity,
     });
   const statusRuntime = Status.createTelegramBridgeStatusRuntime<
     Pi.ExtensionContext,
@@ -347,6 +341,9 @@ export default function (pi: Pi.ExtensionAPI) {
       },
       getRegistrationGeneration:
         telegramBusFollowerRegistrationState.getGeneration,
+      getForwardCommentBatchPosition:
+        textGroupRuntime.getPreparedForwardingPosition,
+      recordRuntimeEvent,
       timeoutMs: 30_000,
     });
   const telegramApiRuntime = BusApi.createTelegramBusAwareApiRuntime({
@@ -445,8 +442,45 @@ export default function (pi: Pi.ExtensionAPI) {
         });
       },
     });
+  const { sendTextReply, sendMarkdownReply } =
+    Outbound.createTelegramOutboundTextReplyRuntime({
+      sendTextReply: replyRuntime.sendTextReply,
+      sendMarkdownReply: replyRuntime.sendMarkdownReply,
+      execCommand: CommandTemplates.execCommandTemplate,
+      getHandlers: configStore.getOutboundHandlers,
+      recordRuntimeEvent,
+    });
+  const assistantOutputBindingRuntime =
+    Bindings.createTelegramAssistantOutputBindingRuntime({
+      isEnabled: configControls.isProactivePushEnabled,
+      authority: {
+        getPreferredTarget: proactivePushTargetGetter,
+        getFallbackChatId: proactivePushChatIdGetter,
+        getTransportStamp: telegramTransportStampRuntime.getStamp,
+        isTransportStampActive: telegramTransportStampRuntime.isActive,
+        ownsDirect: lockRuntime.owns,
+        getDirectEpoch: lockRuntime.getOwnedLeaderEpoch,
+        isFollowerRegistered:
+          telegramBusFollowerRegistrationState.isRegistered,
+        getFollowerGeneration:
+          telegramBusFollowerRegistrationState.getGeneration,
+      },
+      sender: {
+        recordOwnership: messageOwnershipRuntime.recordLocal,
+        sendMessage,
+        sendRichMessage,
+        editMessage: editTelegramMessageText,
+        getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+        execCommand: CommandTemplates.execCommandTemplate,
+        getHandlers: configStore.getOutboundHandlers,
+        recordRuntimeEvent,
+      },
+      recordRuntimeEvent,
+    });
+  const assistantOutputRuntime = assistantOutputBindingRuntime.runtime;
   const activityRuntime = Activity.createTelegramActivityBridgeRuntime({
     generation: deliveryGenerationSeed,
+    observeEvent: assistantOutputBindingRuntime.observeEvent,
     recordFailure(handlerId, event, error) {
       recordRuntimeEvent("activity", error, {
         handlerId,
@@ -455,14 +489,6 @@ export default function (pi: Pi.ExtensionAPI) {
       });
     },
   });
-  const { sendTextReply, sendMarkdownReply } =
-    Outbound.createTelegramOutboundTextReplyRuntime({
-      sendTextReply: replyRuntime.sendTextReply,
-      sendMarkdownReply: replyRuntime.sendMarkdownReply,
-      execCommand: CommandTemplates.execCommandTemplate,
-      getHandlers: configStore.getOutboundHandlers,
-      recordRuntimeEvent,
-    });
   const dispatchNextQueuedTelegramTurn =
     Queue.createTelegramQueueDispatchRuntime({
       ...telegramQueueStore,
@@ -622,9 +648,7 @@ export default function (pi: Pi.ExtensionAPI) {
       callApi: callTelegramApi,
       isTopicProvisioningActive: telegramProvisioningActivity.isActive,
       getCurrentLeaderEpoch,
-      getThreadReconciliationMachineState() {
-        return threadReconciliationRuntime.getState();
-      },
+      getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
       recordThreadReconciliationPlan,
       getSyncState: telegramSyncStateRuntime.getState,
       setSyncState: telegramSyncStateRuntime.setState,
@@ -650,9 +674,7 @@ export default function (pi: Pi.ExtensionAPI) {
     recordMessageOwnership: messageOwnershipRuntime.recordRouted,
     ...inboundBusProjectionRuntime,
     getCurrentLeaderEpoch,
-    getThreadReconciliationMachineState() {
-      return threadReconciliationRuntime.getState();
-    },
+    getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
     recordThreadReconciliationPlan,
     handleTelegramTopicLifecycleUpdate: topicLifecycleSync,
     handleTelegramThreadTargetObserved(_target, ctx) {
@@ -744,13 +766,13 @@ export default function (pi: Pi.ExtensionAPI) {
       receiver: {
         socketPath: getTelegramBusFollowerSocketPath,
         instanceId: telegramInstanceId,
-        getContext() {
-          return telegramSessionContextStore.get();
-        },
+        getContext: telegramSessionContextStore.get,
         getAuthSecret() {
           return telegramActiveBusAuthSecret;
         },
         ...forwardedRouteHandlers,
+        prepareForwardedMessage:
+          textGroupRuntime.prepareForwardedMessage,
         recordRuntimeEvent,
       },
       targetReplacement: {
@@ -766,17 +788,13 @@ export default function (pi: Pi.ExtensionAPI) {
       },
       recovery: {
         registrationState: telegramBusFollowerRegistrationState,
-        getLeaderState() {
-          return lockRuntime.getState();
-        },
+        getLeaderState: lockRuntime.getState,
         setLifecyclePhase(phase) {
           telegramBusLifecycleOverridePhase = phase;
         },
         updateStatus,
         promoteToLeader: promoteTelegramBusFollowerToLeader,
-        getActiveContext() {
-          return telegramSessionContextStore.get();
-        },
+        getActiveContext: telegramSessionContextStore.get,
         recordRuntimeEvent,
       },
       registration: {
@@ -784,9 +802,7 @@ export default function (pi: Pi.ExtensionAPI) {
         getFollowerBusSocketPath: getTelegramBusFollowerSocketPath,
         getLeaderSocketPath: getTelegramBusSocketPath,
         registrationState: telegramBusFollowerRegistrationState,
-        isContextActive(ctx) {
-          return telegramSessionContextStore.isCurrent(ctx);
-        },
+        isContextActive: telegramSessionContextStore.isCurrent,
         createRequestId: telegramBusFollowerClients.createRequestId,
         getLeaderAuthSecret(owner) {
           return owner.busSecret;
@@ -794,12 +810,7 @@ export default function (pi: Pi.ExtensionAPI) {
         setActiveAuthSecret(secret) {
           telegramActiveBusAuthSecret = secret;
         },
-        getThreadName() {
-          return undefined;
-        },
-        getProfileKey() {
-          return getTelegramManualFollowerProfileKey();
-        },
+        getProfileKey: getTelegramManualFollowerProfileKey,
         recordRuntimeEvent,
       },
     });
@@ -812,6 +823,7 @@ export default function (pi: Pi.ExtensionAPI) {
     deleteWebhook,
     getUpdates,
     persistConfig: persistTelegramConfigWithSync,
+    prepareUpdateBatch: textGroupRuntime.prepareUpdateBatch,
     handleUpdate: Updates.createTelegramUpdateHandle({
       defaultHandle: inboundRouteRuntime.handleUpdate,
     }),
@@ -819,17 +831,13 @@ export default function (pi: Pi.ExtensionAPI) {
     updateStatus,
     recordRuntimeEvent,
   });
-  const recoverStaleTelegramTopicApiError = function (
-    apiBody: unknown,
-    error: unknown,
-  ) {
-    return Sync.recoverStaleTelegramTopicApiError(apiBody, error, {
+  const recoverStaleTelegramTopicApiError =
+    Sync.createTelegramStaleTopicApiErrorRecoveryRuntime({
       topicTargetStore: threadStore,
       getSyncState: telegramSyncStateRuntime.getState,
       setSyncState: telegramSyncStateRuntime.setState,
       recordEvent: recordRuntimeEvent,
     });
-  };
   const authorizeFollowerApiCall = Bus.createTelegramFollowerApiCallAuthorizer({
     isMessageOwned: messageOwnershipRuntime.isOwnedByFollower,
   });
@@ -851,9 +859,7 @@ export default function (pi: Pi.ExtensionAPI) {
       },
       getAllowedUserId: configStore.getAllowedUserId,
       instanceId: telegramInstanceId,
-      getCwd(ctx) {
-        return typeof ctx.cwd === "string" ? ctx.cwd : undefined;
-      },
+      getCwd: Pi.getExtensionContextCwd,
       getTelegramProfile: getActiveTelegramThreadProfile,
       shouldForceFreshUnnamed:
         telegramThreadCapabilityState.shouldForceFreshLeaderThread,
@@ -865,9 +871,7 @@ export default function (pi: Pi.ExtensionAPI) {
       downloadFile: directTelegramApiRuntime.downloadFile,
       recoverStaleTargetError: recoverStaleTelegramTopicApiError,
       getCurrentLeaderEpoch,
-      getThreadReconciliationMachineState() {
-        return threadReconciliationRuntime.getState();
-      },
+      getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
       recordThreadReconciliationPlan,
       getSyncState: telegramSyncStateRuntime.getState,
       setSyncState: telegramSyncStateRuntime.setState,
@@ -937,6 +941,8 @@ export default function (pi: Pi.ExtensionAPI) {
       getCurrentLeaderEpoch,
       getLeaderTarget: telegramBusLeaderState.getTarget,
       clearLeaderTarget: telegramBusLeaderState.clear,
+      disconnectFollowerThread:
+        telegramBusFollowerRegistration.disconnectFromLeader,
       getSyncState: telegramSyncStateRuntime.getState,
       setSyncState: telegramSyncStateRuntime.setState,
       stopPolling: lockedPollingRuntime.stop,
@@ -970,6 +976,10 @@ export default function (pi: Pi.ExtensionAPI) {
         registrationRuntime: telegramBusFollowerRegistration,
         instanceId: telegramInstanceId,
         suspendPolling: lockedPollingRuntime.suspend,
+        isLeader: lockRuntime.owns,
+        getLeaderBinding: currentInstanceThreadRuntime.getRestorationIdentity,
+        getActiveContext: telegramSessionContextStore.get,
+        getActiveProfileName: getActiveTelegramThreadProfile,
         getLeaderState: lockRuntime.getState,
         updateStatus,
         recordRuntimeEvent,
@@ -1000,6 +1010,11 @@ export default function (pi: Pi.ExtensionAPI) {
     activeTurnRuntime,
     lockedPollingRuntime,
     stopPolling: disconnectTelegramAndDeleteCurrentThread,
+    getDisconnectThreadName() {
+      const record = findCurrentThreadRecord();
+      if (!record?.target.threadId) return undefined;
+      return record.threadName ?? "current Telegram thread";
+    },
     onTransportChanged: deliveryLifecycleRuntime.onSessionStart,
     getStatusLines,
     buttonActionStore,
@@ -1026,6 +1041,7 @@ export default function (pi: Pi.ExtensionAPI) {
       onModelSelect: currentModelRuntime.onModelSelect,
     },
     activityRuntime,
+    assistantOutputRuntime,
     configStore,
     abort,
     typing,
@@ -1048,15 +1064,10 @@ export default function (pi: Pi.ExtensionAPI) {
     deleteMessage: deleteTelegramMessage,
     sendGuestReply,
     finalizeMarkdownPreview,
-    proactivePushChatIdGetter,
     proactivePushTargetGetter,
     isProactivePushEnabled: configControls.isProactivePushEnabled,
-    canSendProactivePush(ctx) {
-      return (
-        lockOwnershipGuard.ownsContext(ctx) ||
-        telegramBusFollowerRegistrationState.isRegistered()
-      );
-    },
+    getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+    recordMessageOwnership: messageOwnershipRuntime.recordLocal,
     canSendAgentActivity(ctx) {
       return (
         lockOwnershipGuard.ownsContext(ctx) ||

package/lib/activity.ts

@@ -1,7 +1,7 @@
 /**
  * Telegram activity lifecycle normalization and extension dispatch
  * Zones: pi agent lifecycle, extension API, operational delivery
- * Owns stable handler registration, evidence-based activity/source identity, assistant segment and reasoning normalization, executed-tool and compaction events, isolated non-blocking queues, shutdown fencing, diagnostics, and fresh delivery contexts; excludes Pi hook wiring, visibility policy, Telegram rendering, and consumer-extension behavior
+ * Owns stable handler registration, evidence-based activity/source identity, assistant segment and reasoning normalization, ordered public-output projection, executed-tool and compaction events, isolated non-blocking queues, shutdown fencing, diagnostics, and fresh delivery contexts; excludes Pi hook wiring, Telegram rendering implementation, raw transport clients, and consumer-extension behavior
  */
 
 import {
@@ -91,6 +91,9 @@ export type TelegramActivityPayload =
 export type TelegramActivityEvent = TelegramActivityEnvelope &
   TelegramActivityPayload;
 
+export type TelegramAssistantSegmentEvent = TelegramActivityEnvelope &
+  Extract<TelegramActivityPayload, { type: "assistant-segment" }>;
+
 export interface TelegramActivityContext {
   activityId: string;
   sequence: number;
@@ -383,6 +386,7 @@ export function createTelegramActivityDispatcher(deps: {
 /** @internal */
 export function createTelegramActivityBridgeRuntime(deps: {
   generation: string;
+  observeEvent?: (event: TelegramActivityEvent) => void;
   recordFailure?: (
     handlerId: string,
     event: TelegramActivityEvent,
@@ -401,6 +405,11 @@ export function createTelegramActivityBridgeRuntime(deps: {
         dispatcher: createTelegramActivityDispatcher({
           recordFailure: deps.recordFailure,
         }),
+        observeEvent: deps.observeEvent,
+        recordObserverFailure: deps.recordFailure
+          ? (event, error) =>
+              deps.recordFailure!("@llblab/pi-telegram/proactive", event, error)
+          : undefined,
         now: deps.now,
       });
     },
@@ -507,6 +516,11 @@ interface PendingAssistantSegment {
 export function createTelegramActivityRuntime(deps: {
   generation: string;
   dispatcher: TelegramActivityDispatcher;
+  observeEvent?: (event: TelegramActivityEvent) => void;
+  recordObserverFailure?: (
+    event: TelegramActivityEvent,
+    error: unknown,
+  ) => void;
   now?: () => number;
 }): TelegramActivityRuntime {
   const now = deps.now ?? Date.now;
@@ -542,14 +556,20 @@ export function createTelegramActivityRuntime(deps: {
   const emit = (event: TelegramActivityPayload): void => {
     const currentActivityId = ensureActivity();
     sequence += 1;
-    deps.dispatcher.dispatch({
+    const normalizedEvent = {
       ...event,
       activityId: currentActivityId,
       sequence,
       source: activitySource,
       ...(activityTarget ? { target: activityTarget } : {}),
       timestamp: now(),
-    } as TelegramActivityEvent);
+    } as TelegramActivityEvent;
+    try {
+      deps.observeEvent?.(normalizedEvent);
+    } catch (error) {
+      deps.recordObserverFailure?.(normalizedEvent, error);
+    }
+    deps.dispatcher.dispatch(normalizedEvent);
   };
   const flushPendingSegment = (
     placement: "intermediate" | "final" | "terminal-partial",
@@ -681,3 +701,80 @@ export function createTelegramActivityRuntime(deps: {
     },
   };
 }
+
+// --- Public Assistant Output Projection ---
+
+export interface TelegramAssistantOutputRuntime {
+  start: () => void;
+  accept: (event: TelegramAssistantSegmentEvent) => void;
+  waitForIdle: () => Promise<void>;
+  stop: () => void;
+}
+
+export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(deps: {
+  isEnabled: () => boolean;
+  captureAuthority?: () => TAuthority;
+  isAuthorityActive?: (authority: TAuthority) => boolean;
+  canDeliver: (event: TelegramAssistantSegmentEvent) => boolean;
+  send: (
+    event: TelegramAssistantSegmentEvent,
+    authority: TAuthority,
+    isAuthorityActive: () => boolean,
+  ) => Promise<void>;
+  recordFailure?: (
+    event: TelegramAssistantSegmentEvent,
+    error: unknown,
+  ) => void;
+}): TelegramAssistantOutputRuntime {
+  let generation = 0;
+  let running = false;
+  let tail: Promise<void> = Promise.resolve();
+  const admitted = new Set<string>();
+  const isEligibleSource = (
+    source: TelegramAssistantSegmentEvent["source"],
+  ): boolean => source === "local" || source === "autonomous";
+
+  return {
+    start() {
+      generation += 1;
+      running = true;
+      admitted.clear();
+      tail = Promise.resolve();
+    },
+    accept(event) {
+      if (!running || !deps.isEnabled()) return;
+      if (!isEligibleSource(event.source) || !event.text.trim()) return;
+      const key = `${event.activityId}:${event.sequence}`;
+      if (admitted.has(key)) return;
+      admitted.add(key);
+      const admittedGeneration = generation;
+      const admittedAuthority = deps.captureAuthority?.();
+      tail = tail.then(async () => {
+        const isAdmittedAuthorityActive = () =>
+          running &&
+          generation === admittedGeneration &&
+          deps.isEnabled() &&
+          (deps.isAuthorityActive === undefined ||
+            deps.isAuthorityActive(admittedAuthority as TAuthority));
+        if (!isAdmittedAuthorityActive() || !deps.canDeliver(event)) return;
+        try {
+          await deps.send(
+            event,
+            admittedAuthority as TAuthority,
+            isAdmittedAuthorityActive,
+          );
+        } catch (error) {
+          deps.recordFailure?.(event, error);
+        }
+      });
+    },
+    waitForIdle() {
+      return tail;
+    },
+    stop() {
+      generation += 1;
+      running = false;
+      admitted.clear();
+    },
+  };
+}

package/lib/bindings.ts

@@ -19,6 +19,7 @@ import * as Preview from "./preview.ts";
 import * as Prompts from "./prompts.ts";
 import * as Queue from "./queue.ts";
 import * as Replies from "./replies.ts";
+import * as Routing from "./routing.ts";
 import * as Runtime from "./runtime.ts";
 import * as Setup from "./setup.ts";
 import * as Status from "./status.ts";
@@ -35,6 +36,60 @@ type TelegramRuntimeEventRecorder = (
 type TelegramBridgeStatusUpdater =
   Status.TelegramStatusRuntime<Pi.ExtensionContext>["updateStatus"];
 
+export interface TelegramAssistantOutputBindingRuntime<
+  TTransportStamp,
+> {
+  runtime: Activity.TelegramAssistantOutputRuntime;
+  observeEvent: (event: Activity.TelegramActivityEvent) => void;
+  authority: Routing.TelegramAssistantOutputAuthorityRuntime<TTransportStamp>;
+}
+
+export function createTelegramAssistantOutputBindingRuntime<
+  TTransportStamp,
+>(deps: {
+  isEnabled: () => boolean;
+  authority: {
+    getPreferredTarget: () => OutboundAttachments.TelegramQueuedOutboundAttachmentTurnView["target"] | undefined;
+    getFallbackChatId: () => number | undefined;
+    getTransportStamp: () => TTransportStamp;
+    isTransportStampActive: (stamp: TTransportStamp) => boolean;
+    ownsDirect: () => boolean;
+    getDirectEpoch: () => number | string | undefined;
+    isFollowerRegistered: () => boolean;
+    getFollowerGeneration: () => string | undefined;
+  };
+  sender: Parameters<
+    typeof OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>
+  >[0];
+  recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}): TelegramAssistantOutputBindingRuntime<TTransportStamp> {
+  const authority =
+    Routing.createTelegramAssistantOutputAuthorityRuntime(deps.authority);
+  const send =
+    OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>(
+      deps.sender,
+    );
+  const runtime = Activity.createTelegramAssistantOutputRuntime({
+    isEnabled: deps.isEnabled,
+    ...authority,
+    send,
+    recordFailure(event, error) {
+      deps.recordRuntimeEvent("proactive-push", error, {
+        activityId: event.activityId,
+        sequence: event.sequence,
+        placement: event.placement,
+      });
+    },
+  });
+  return {
+    runtime,
+    authority,
+    observeEvent(event) {
+      if (event.type === "assistant-segment") runtime.accept(event);
+    },
+  };
+}
+
 interface TelegramCommandsAndToolsBindingDeps {
   pi: Pi.ExtensionAPI;
   configStore: Config.TelegramConfigStore;
@@ -43,6 +98,7 @@ interface TelegramCommandsAndToolsBindingDeps {
   activeTurnRuntime: Queue.TelegramActiveTurnStore<Queue.PendingTelegramTurn>;
   lockedPollingRuntime: Locks.TelegramLockedPollingRuntime<Pi.ExtensionContext>;
   stopPolling?: () => Promise<void | string>;
+  getDisconnectThreadName?: () => string | undefined;
   onTransportChanged?: () => Promise<void> | void;
   getStatusLines: (
     options?: Status.TelegramBridgeStatusLineOptions,
@@ -70,6 +126,7 @@ export function registerTelegramCommandsAndTools({
   activeTurnRuntime,
   lockedPollingRuntime,
   stopPolling,
+  getDisconnectThreadName,
   onTransportChanged,
   getStatusLines,
   buttonActionStore,
@@ -186,6 +243,7 @@ export function registerTelegramCommandsAndTools({
     hasBotToken: configStore.hasBotToken,
     startPolling: lockedPollingRuntime.start,
     stopPolling: stopPolling ?? lockedPollingRuntime.stop,
+    getDisconnectThreadName,
     updateStatus,
     getProfileNames: () =>
       Config.getTelegramProfileNames(configStore.getStoredConfig()),
@@ -217,6 +275,10 @@ export function registerTelegramCommandsAndTools({
 interface TelegramLifecycleBindingDeps {
   pi: Pi.ExtensionAPI;
   activityRuntime: Activity.TelegramActivityRuntime;
+  assistantOutputRuntime: Pick<
+    Activity.TelegramAssistantOutputRuntime,
+    "start" | "stop"
+  >;
   sessionLifecycleRuntime: Pick<
     Lifecycle.TelegramLifecycleRegistrationDeps,
     "onSessionStart" | "onSessionShutdown" | "onModelSelect"
@@ -282,10 +344,14 @@ interface TelegramLifecycleBindingDeps {
     Pi.AgentEndEvent["messages"][number],
     Keyboard.TelegramInlineKeyboardMarkup
   >["finalizeMarkdownPreview"];
-  proactivePushChatIdGetter: () => number | undefined;
   proactivePushTargetGetter: () => Queue.TelegramQueueTarget | undefined;
   isProactivePushEnabled: () => boolean;
-  canSendProactivePush: (ctx: Pi.ExtensionContext) => boolean;
+  getAssistantRenderingMode: () => "rich" | "html";
+  recordMessageOwnership?: (input: {
+    chatId: number;
+    messageId: number;
+    target?: Queue.TelegramQueueTarget;
+  }) => void;
   canSendAgentActivity: (ctx: Pi.ExtensionContext) => boolean;
   isSessionContextActive: (ctx: Pi.ExtensionContext) => boolean;
   isTurnTransportActive?: (turn: Queue.PendingTelegramTurn) => boolean;
@@ -296,6 +362,7 @@ interface TelegramLifecycleBindingDeps {
 export function registerTelegramLifecycleRuntimeHooks({
   pi,
   activityRuntime,
+  assistantOutputRuntime,
   sessionLifecycleRuntime,
   configStore,
   abort,
@@ -319,10 +386,10 @@ export function registerTelegramLifecycleRuntimeHooks({
   deleteMessage,
   sendGuestReply,
   finalizeMarkdownPreview,
-  proactivePushChatIdGetter,
   proactivePushTargetGetter,
   isProactivePushEnabled,
-  canSendProactivePush,
+  getAssistantRenderingMode,
+  recordMessageOwnership,
   canSendAgentActivity,
   isSessionContextActive = () => true,
   isTurnTransportActive,
@@ -343,13 +410,20 @@ export function registerTelegramLifecycleRuntimeHooks({
       sendTextReply,
       recordRuntimeEvent,
     });
+  const richAttachmentSender =
+    OutboundAttachments.createTelegramRichOutboundAttachmentSender({
+      sendMultipart: callMultipart,
+      getRenderingMode: getAssistantRenderingMode,
+      recordOwnership: recordMessageOwnership,
+      recordRuntimeEvent,
+    });
   const sendGuestAttachment = async (
     turn: Queue.PendingTelegramTurn,
     attachment: Queue.QueuedAttachment,
     caption?: string,
   ): Promise<void> => {
     const stagingTarget = proactivePushTargetGetter();
-    const stagingChatId = stagingTarget?.chatId ?? proactivePushChatIdGetter();
+    const stagingChatId = stagingTarget?.chatId;
     if (stagingChatId === undefined) {
       throw new Error(
         "Guest attachment staging requires a paired Telegram chat",
@@ -394,7 +468,7 @@ export function registerTelegramLifecycleRuntimeHooks({
     caption?: string,
   ): Promise<void> => {
     const stagingTarget = proactivePushTargetGetter();
-    const stagingChatId = stagingTarget?.chatId ?? proactivePushChatIdGetter();
+    const stagingChatId = stagingTarget?.chatId;
     if (stagingChatId === undefined) {
       throw new Error("Guest voice staging requires a paired Telegram chat");
     }
@@ -499,16 +573,13 @@ export function registerTelegramLifecycleRuntimeHooks({
     sendMarkdownReply,
     sendTextReply,
     sendQueuedAttachments: queuedAttachmentSender,
+    sendRichAttachmentReply: richAttachmentSender,
     answerGuestQuery,
     sendGuestReply,
     sendGuestAttachment,
     sendGuestVoiceReply,
     planOutboundReply: outboundReplyPlanner,
     sendOutboundReplyArtifacts: outboundReplyArtifactSender,
-    getDefaultChatId: proactivePushChatIdGetter,
-    getDefaultTarget: proactivePushTargetGetter,
-    isProactivePushEnabled,
-    canSendProactivePush,
     recordRuntimeEvent,
     getActiveToolExecutions: lifecycle.getActiveToolExecutions,
     setActiveToolExecutions: lifecycle.setActiveToolExecutions,
@@ -522,11 +593,9 @@ export function registerTelegramLifecycleRuntimeHooks({
     if (!canSendAgentActivity(ctx)) return false;
     const turn = activeTurnRuntime.get();
     const target = turn?.target ?? proactivePushTargetGetter();
-    promptDispatchRuntime.startTypingLoop(
-      ctx,
-      turn?.chatId ?? target?.chatId ?? proactivePushChatIdGetter(),
-      { target },
-    );
+    promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, {
+      target,
+    });
     return true;
   };
   const startActiveTurnTypingLoop = (ctx: Pi.ExtensionContext): void => {
@@ -565,12 +634,14 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     async onSessionStart(event, ctx) {
       previewRuntime.invalidate();
+      assistantOutputRuntime.start();
       activityRuntime.onSessionStart?.();
       await sessionLifecycleRuntime.onSessionStart(event, ctx);
     },
     async onSessionShutdown(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       activityRuntime.onSessionShutdown();
+      assistantOutputRuntime.stop();
       compactionObserver.onSessionShutdown();
       await sessionLifecycleRuntime.onSessionShutdown(event, ctx);
     },