pi-harness-runtime 1.1.397 → 1.1.402

package/packages/skill-mcp-client/dist/types.js

@@ -0,0 +1,14 @@
+/**
+ * Skill MCP Client Types (RFC-0106)
+ */
+// Error codes
+export const ErrorCodes = {
+    INVALID_REQUEST: -32600,
+    INVALID_PARAMS: -32602,
+    METHOD_NOT_FOUND: -32601,
+    UNAUTHORIZED: -32001,
+    TIER_RESTRICTED: -32002,
+    NOT_FOUND: -32003,
+    RATE_LIMITED: -32004,
+};
+//# sourceMappingURL=types.js.map

package/packages/skill-mcp-client/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AA6GH,cAAc;AACd,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,eAAe,EAAE,CAAC,KAAK;IACvB,cAAc,EAAE,CAAC,KAAK;IACtB,gBAAgB,EAAE,CAAC,KAAK;IACxB,YAAY,EAAE,CAAC,KAAK;IACpB,eAAe,EAAE,CAAC,KAAK;IACvB,SAAS,EAAE,CAAC,KAAK;IACjB,YAAY,EAAE,CAAC,KAAK;CACZ,CAAC"}

package/packages/skill-mcp-client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/skill-mcp-client",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "description": "MCP client for Skills SaaS backend",
   "type": "module",
   "main": "./dist/index.js",

package/packages/skill-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/skill-registry",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "description": "Skill Registry for pi-harness-runtime — dynamic skill discovery and invocation",
   "type": "module",
   "main": "./dist/index.js",

package/packages/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/skills",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "description": "File-based skill system with pi.dev compatibility and Hermes self-improvement",
   "type": "module",
   "main": "src/index.ts",
@@ -22,10 +22,6 @@
       "import": "./src/scanner.ts",
       "types": "./src/scanner.ts"
     },
-    "./registry": {
-      "import": "./src/registry.ts",
-      "types": "./src/registry.ts"
-    },
     "./loader": {
       "import": "./src/loader.ts",
       "types": "./src/loader.ts"

package/packages/sprint-planner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/sprint-planner",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "type": "module",
   "description": "Sprint planning engine for pi-harness",
   "main": "dist/index.js",

package/packages/subscription-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/subscription-engine",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/task-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/task-compiler",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "description": "Task Compiler for pi-harness-runtime — produces deterministic task DAG from CompiledRequirement",
   "type": "module",
   "main": "./dist/index.js",

package/packages/telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/telegram",
-  "version": "1.1.397",
+  "version": "1.1.402",
   "description": "pi-harness-runtime — Telegram inbound/outbound",
   "type": "module",
   "main": "./src/index.js",

package/packages/telegram/src/agent-messages.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cross-instance Telegram agent message resolution and turn injection
+ * Zones: multi-instance bus, inbound routing, operational delivery
+ * Owns live target resolution, source attribution, same-target fencing, and synthetic turn construction; excludes Bot API delivery and bus transport.
+ */
+import type { TelegramBusAgentMessage, TelegramBusAgentTargetSelector, TelegramBusFollowerRegistry } from "./bus.ts";
+import type { TelegramTarget } from "./target.ts";
+export interface TelegramAgentMessageRuntimeDeps<TContext, TUpdate> {
+    instanceId: string;
+    getAllowedChatId: () => number | undefined;
+    getLeaderTarget: () => TelegramTarget | undefined;
+    getLeaderThreadName: () => string | undefined;
+    getDisplayTitle?: (target: TelegramTarget) => string | undefined;
+    followerRegistry: TelegramBusFollowerRegistry;
+    getContext: () => TContext | undefined;
+    handleUpdate: (update: TUpdate, ctx: TContext) => Promise<void>;
+    getNowMs?: () => number;
+}
+export declare function createTelegramAgentMessageRuntime<TContext, TUpdate>(deps: TelegramAgentMessageRuntimeDeps<TContext, TUpdate>): {
+    resolveTarget: (selector: TelegramBusAgentTargetSelector, sourceTarget?: TelegramTarget) => (TelegramTarget & {
+        threadId: number;
+    }) | undefined;
+    route(input: {
+        sourceTarget?: TelegramTarget;
+        sourceThreadName?: string;
+        message: TelegramBusAgentMessage;
+    }): Promise<void>;
+};

package/packages/telegram/src/agent-messages.js

@@ -0,0 +1,90 @@
+/**
+ * Cross-instance Telegram agent message resolution and turn injection
+ * Zones: multi-instance bus, inbound routing, operational delivery
+ * Owns live target resolution, source attribution, same-target fencing, and synthetic turn construction; excludes Bot API delivery and bus transport.
+ */
+import { TELEGRAM_INTERNAL_AGENT_MESSAGE } from "./updates.js";
+export function createTelegramAgentMessageRuntime(deps) {
+    const getNowMs = deps.getNowMs ?? Date.now;
+    const sameTarget = (left, right) => left?.chatId === right?.chatId && left?.threadId === right?.threadId;
+    const listLiveTargets = () => {
+        const targets = [];
+        const leaderTarget = deps.getLeaderTarget();
+        if (leaderTarget?.threadId) {
+            targets.push({
+                target: {
+                    chatId: leaderTarget.chatId,
+                    threadId: leaderTarget.threadId,
+                },
+                threadName: deps.getDisplayTitle?.(leaderTarget) ?? deps.getLeaderThreadName(),
+            });
+        }
+        for (const follower of deps.followerRegistry.list()) {
+            if (!follower.target?.threadId)
+                continue;
+            targets.push({
+                target: {
+                    chatId: follower.target.chatId,
+                    threadId: follower.target.threadId,
+                },
+                threadName: deps.getDisplayTitle?.(follower.target) ?? follower.threadName,
+            });
+        }
+        return targets;
+    };
+    const resolveTarget = (selector, sourceTarget) => {
+        const allowedChatId = deps.getAllowedChatId();
+        const chatId = selector.chatId ?? allowedChatId;
+        if (chatId === undefined || chatId !== allowedChatId)
+            return undefined;
+        const matches = listLiveTargets().filter((candidate) => {
+            if (candidate.target.chatId !== chatId)
+                return false;
+            if (selector.threadId !== undefined) {
+                return candidate.target.threadId === selector.threadId;
+            }
+            const requestedName = selector.threadName?.trim().toLocaleLowerCase();
+            return (requestedName !== undefined &&
+                requestedName.length > 0 &&
+                candidate.threadName?.trim().toLocaleLowerCase() === requestedName);
+        });
+        if (matches.length !== 1)
+            return undefined;
+        return sameTarget(matches[0].target, sourceTarget)
+            ? undefined
+            : matches[0].target;
+    };
+    return {
+        resolveTarget,
+        async route(input) {
+            const target = resolveTarget({
+                chatId: input.message.target.chatId,
+                threadId: input.message.target.threadId,
+            }, input.sourceTarget);
+            if (!target)
+                throw new Error("Telegram agent target is no longer live.");
+            const allowedChatId = deps.getAllowedChatId();
+            const ctx = deps.getContext();
+            if (allowedChatId === undefined || !ctx) {
+                throw new Error("Telegram agent turn routing is unavailable.");
+            }
+            const sourceTitle = (input.sourceTarget
+                ? deps.getDisplayTitle?.(input.sourceTarget)
+                : undefined) ?? input.sourceThreadName;
+            const sourceLabel = sourceTitle
+                ?.replace(/[\r\n\[\]]+/g, " ")
+                .trim()
+                .slice(0, 64) || "Pi";
+            const message = {
+                message_id: input.message.messageId,
+                date: Math.floor(getNowMs() / 1000),
+                chat: { id: target.chatId, type: "private" },
+                from: { id: allowedChatId, is_bot: false, first_name: "Pi Agent" },
+                message_thread_id: target.threadId,
+                pi_telegram_agent_source_thread: sourceLabel,
+                text: input.message.text,
+            };
+            await deps.handleUpdate({ message, [TELEGRAM_INTERNAL_AGENT_MESSAGE]: true }, ctx);
+        },
+    };
+}

package/packages/telegram/src/bindings.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Telegram bridge binding composition
+ * Zones: telegram, pi agent, orchestration
+ * Owns pi-facing tool, command, and lifecycle hook registration for the entrypoint
+ */
+import * as ActivityVerbosity from "./activity-verbosity.ts";
+import * as Activity from "./activity.ts";
+import * as BusApi from "./bus-api.ts";
+import type { TelegramBusFollowerCommandOwner } from "./bus-follower.ts";
+import type { TelegramBusLiveRebindWorkState } from "./bus.ts";
+import * as ChannelPosts from "./channel-posts.ts";
+import * as Commands from "./commands.ts";
+import * as Config from "./config.ts";
+import * as Delivery from "./delivery.ts";
+import * as GenerativeApps from "./generative-apps.ts";
+import * as Keyboard from "./keyboard.ts";
+import * as Lifecycle from "./lifecycle.ts";
+import * as Locks from "./locks.ts";
+import * as Menu from "./menu.ts";
+import * as Model from "./model.ts";
+import * as OutboundAttachments from "./outbound-attachments.ts";
+import * as OutboundHandlers from "./outbound.ts";
+import * as Pi from "./pi.ts";
+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";
+import type { TelegramTarget } from "./target.ts";
+import * as TelegramApi from "./telegram-api.ts";
+/** Compose any registered held command over captured recipient effects; no ordinary follower API fallback. */
+export declare function createTelegramFollowerSelectedCommandBinding<TContext, TModel extends Model.MenuModel = Model.MenuModel>(deps: {
+    ctx: TContext;
+    operationId: string;
+    registrationGeneration: string;
+    name: string;
+    target: TelegramTarget & {
+        threadId: number;
+    };
+    recipient: Pick<TelegramBusFollowerCommandOwner<TContext>, "isCurrent" | "assertRecipientCurrent">;
+    command: Pick<ReturnType<typeof Commands.createTelegramCommandHandlerTargetRuntime<Commands.TelegramCommandRuntimeMessage, TContext>>, "prepareHeldCommand" | "canPrepareHeldCommand">;
+    menu?: Omit<Menu.TelegramMenuActionRuntimeDeps<TContext, TModel>, "sendTextReply" | "sendInteractiveMessage" | "editInteractiveMessage">;
+    deliver: Parameters<typeof BusApi.createTelegramSelectedMenuTextApi>[0]["deliver"];
+    recordOwnership: NonNullable<Replies.TelegramRenderedMessageDeliveryRuntimeDeps<Menu.TelegramReplyMarkup>["recordOwnership"]>;
+}): TelegramBusFollowerCommandOwner<TContext> | undefined;
+type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
+type TelegramRuntimeEventRecorder = (category: string, error: unknown, details?: Record<string, unknown>) => void;
+type TelegramBridgeStatusUpdater = Status.TelegramStatusRuntime<Pi.ExtensionContext>["updateStatus"];
+type TelegramAgentTargetResolver = NonNullable<OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["resolveAgentTarget"]>;
+type TelegramAgentMessageRouter = NonNullable<OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["routeAgentMessage"]>;
+export interface TelegramQueueBindingRuntime<TContext> {
+    mutation: Queue.TelegramQueueMutationController<TContext>;
+    dispatchNext: (ctx: TContext) => void;
+    requestNextDispatchAnnouncement: () => void;
+    cancelNextDispatchAnnouncement: () => void;
+    watchdog: Queue.TelegramQueueDispatchWatchdogRuntime<TContext>;
+}
+export declare function createTelegramQueueBindingRuntime<TContext>(deps: {
+    store: Queue.TelegramQueueStateStore<TContext>;
+    queue: Pick<Runtime.TelegramBridgeRuntime["queue"], "allocateItemOrder">;
+    lifecycle: Pick<Runtime.TelegramBridgeRuntime["lifecycle"], "isCompactionInProgress" | "hasDispatchPending">;
+    activeTurn: Pick<Queue.TelegramActiveTurnStore, "has">;
+    admission: {
+        getSettlement: () => {
+            onItemsDiscarded: (items: readonly Queue.TelegramQueueItem<TContext>[], ctx: TContext) => boolean;
+            isItemReady: (item: Queue.TelegramQueueItem<TContext>) => boolean;
+            onPromptHandedOff?: (item: Queue.PendingTelegramTurn, ctx: TContext) => boolean;
+            onControlSettled: (item: Queue.PendingTelegramControlItem<TContext>, ctx: TContext) => void;
+        } | undefined;
+        hasPendingQueueMutationForItem: (item: Queue.TelegramQueueItem<TContext>) => boolean;
+    };
+    transportStamp: Pick<Queue.TelegramTransportStampRuntime, "isActive">;
+    deferredDispatch: Pick<Queue.TelegramDeferredQueueDispatchRuntime<TContext>, "isBound" | "getGeneration" | "isGenerationActive">;
+    promptDispatch: Runtime.TelegramPromptDispatchRuntime<TContext>;
+    isIdle: (ctx: TContext) => boolean;
+    hasPendingMessages: (ctx: TContext) => boolean;
+    updateStatus: (ctx: TContext, error?: string) => void;
+    sendTextReply: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendTextReply"];
+    sendUserMessage: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendUserMessage"];
+    reconcileNextDispatchAnnouncementReplyOwnership?: (item: Queue.PendingTelegramTurn) => void;
+    recordRuntimeEvent?: TelegramRuntimeEventRecorder;
+}): TelegramQueueBindingRuntime<TContext>;
+export interface TelegramGenerativeAppLiveSurfaceBinding {
+    get: () => GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle> | undefined;
+    set: (runtime: GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle> | undefined) => void;
+    shutdown: () => void;
+}
+export declare function createTelegramGenerativeAppLiveSurfaceBinding(): TelegramGenerativeAppLiveSurfaceBinding;
+export declare function createTelegramGenerativeAppBoundButtonActionInvoker<TQuery extends {
+    message?: {
+        chat?: {
+            id?: number;
+        };
+        message_id?: number;
+        message_thread_id?: number;
+    };
+}>(deps: {
+    agentDir: string;
+    assertExecutionCurrent: (query: TQuery) => void;
+    getExecutionFence: (query: TQuery) => GenerativeApps.GenerativeAppExecutionFence | undefined;
+    getActiveProfileName?: () => string | undefined;
+    getLiveSurfaceRuntime?: () => GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle> | undefined;
+    planOutput: ReturnType<typeof OutboundHandlers.createTelegramOutboundReplyPlanner>;
+    sendMarkdownReply: (chatId: number, replyToMessageId: number, markdown: string, options?: {
+        replyMarkup?: OutboundHandlers.TelegramOutboundButtonMarkup;
+    }) => Promise<unknown>;
+    editInteractiveMessage?: (chatId: number, messageId: number, markdown: string, mode: "markdown", replyMarkup: OutboundHandlers.TelegramOutboundButtonMarkup) => Promise<void>;
+    recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}): (action: OutboundHandlers.TelegramOutboundButtonAction, query: TQuery) => Promise<false | "new" | "edit">;
+export interface TelegramAgentMessageToolRoutingRuntime {
+    resolveAgentTarget: TelegramAgentTargetResolver;
+    routeAgentMessage: TelegramAgentMessageRouter;
+    canSendDirect: () => boolean;
+}
+export declare function createTelegramAgentMessageToolRoutingRuntime(deps: {
+    ownsLeader: () => boolean;
+    ownsDirectDelivery: () => boolean;
+    isFollowerRegistered: () => boolean;
+    getSourceTarget: () => TelegramTarget | undefined;
+    getSourceThreadName: () => string | undefined;
+    local: {
+        resolveTarget: (selector: Parameters<TelegramAgentTargetResolver>[0], sourceTarget?: TelegramTarget) => Awaited<ReturnType<TelegramAgentTargetResolver>> | undefined;
+        route: (input: {
+            sourceTarget?: TelegramTarget;
+            sourceThreadName?: string;
+            message: Parameters<TelegramAgentMessageRouter>[0];
+        }) => Promise<void>;
+    };
+    follower: {
+        resolveTarget: TelegramAgentTargetResolver;
+        routeMessage: TelegramAgentMessageRouter;
+    };
+}): TelegramAgentMessageToolRoutingRuntime;
+export interface TelegramAssistantOutputBindingRuntime<TTransportStamp> {
+    runtime: Activity.TelegramAssistantOutputRuntime;
+    observeEvent: (event: Activity.TelegramActivityEvent) => void;
+    authority: Routing.TelegramAssistantOutputAuthorityRuntime<TTransportStamp>;
+}
+export declare function createTelegramAssistantOutputBindingRuntime<TTransportStamp>(deps: {
+    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];
+    waitForActivityIdle?: () => Promise<void>;
+    prepareTelegramPreview?: () => Activity.TelegramAssistantOutputPreparation | undefined;
+    enqueue?: Activity.TelegramActivityPublicationRuntime["enqueue"];
+    recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}): TelegramAssistantOutputBindingRuntime<TTransportStamp>;
+type TelegramAssistantOutputAuthority<TTransportStamp> = ReturnType<Routing.TelegramAssistantOutputAuthorityRuntime<TTransportStamp>["captureAuthority"]>;
+export interface TelegramBridgePublicationRuntime {
+    enqueue: Activity.TelegramActivityPublicationRuntime["enqueue"];
+    reserve: Activity.TelegramActivityPublicationRuntime["reserve"];
+    hasPending: Activity.TelegramActivityPublicationRuntime["hasPending"];
+    beginWork: Activity.TelegramActivityPublicationRuntime["beginWork"];
+    hasUnconfirmed: Activity.TelegramActivityPublicationRuntime["hasUnconfirmed"];
+    capture: () => {
+        target?: Queue.TelegramQueueTarget;
+        isCurrent: () => boolean;
+    };
+}
+export interface TelegramActivityBindingRuntime {
+    publicationRuntime: TelegramBridgePublicationRuntime;
+    activityRuntime: Activity.TelegramActivityRuntime;
+    activityVerbosityRuntime: ActivityVerbosity.TelegramActivityVerbosityRuntime;
+    assistantOutputRuntime: Activity.TelegramAssistantOutputRuntime;
+}
+/** Compose public activity fanout, verbosity, and assistant output ordering. */
+export declare function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
+    generation: string;
+    assistantOutput: Omit<Parameters<typeof createTelegramAssistantOutputBindingRuntime<TTransportStamp>>[0], "waitForActivityIdle" | "enqueue">;
+    activityVerbosity: Omit<Parameters<typeof ActivityVerbosity.createTelegramActivityVerbosityRuntime<TelegramAssistantOutputAuthority<TTransportStamp>>>[0], "captureAuthority" | "isAuthorityActive" | "recordFailure" | "enqueue">;
+}): TelegramActivityBindingRuntime;
+/** Fresh current work projection; a snapshot is not a cleanup grant or target-application ACK. */
+export declare function createTelegramLiveTargetWorkObserver<TContext>(deps: {
+    queue: Pick<Queue.TelegramQueueStateStore<TContext>, "getQueuedItems">;
+    activeTurn: Pick<Queue.TelegramActiveTurnStore, "get">;
+    lifecycle: Pick<Runtime.TelegramBridgeRuntime["lifecycle"], "hasDispatchPending" | "isCompactionInProgress" | "getActiveToolExecutions">;
+    isIdle(ctx: TContext): boolean;
+    hasPendingMessages(ctx: TContext): boolean;
+    hasPendingControl(): boolean;
+    publication: Pick<TelegramBridgePublicationRuntime, "hasPending" | "hasUnconfirmed">;
+    activity: Pick<Activity.TelegramActivityRuntime, "hasPending">;
+    delivery: Pick<ReturnType<typeof Delivery.createTelegramDeliveryLifecycleHooks>, "hasPendingTarget">;
+    api: Pick<TelegramApi.TelegramApiTargetActivityRuntime, "hasPendingTarget">;
+}): (target: TelegramTarget & {
+    threadId: number;
+}, ctx: TContext) => TelegramBusLiveRebindWorkState;
+interface TelegramCommandsAndToolsBindingDeps {
+    pi: Pi.ExtensionAPI;
+    agentDir: string;
+    configStore: Config.TelegramConfigStore;
+    persistConfig: (config?: Config.TelegramConfig) => Promise<void>;
+    setup: Setup.TelegramSetupGuard;
+    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) => string[];
+    buttonActionStore: OutboundHandlers.TelegramButtonActionStore;
+    sendMarkdownReply: (chatId: number, replyToMessageId: number | undefined, markdown: string, options?: {
+        replyMarkup?: unknown;
+        target?: {
+            chatId: number;
+            threadId?: number;
+        };
+    }) => Promise<number | undefined>;
+    sendChannelMarkdownMessage: NonNullable<OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["sendChannelMarkdownMessage"]>;
+    sendChannelMediaMessage: NonNullable<OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["sendChannelMediaMessage"]>;
+    listChannelPosts: ChannelPosts.TelegramChannelPostJournalStore["list"];
+    mutateChannelPost(input: {
+        action: "edit" | "delete";
+        operationId: string;
+        mutationId: string;
+        markdown?: string;
+    }): Promise<ChannelPosts.TelegramChannelPostRecord>;
+    callMultipart: OutboundHandlers.TelegramVoiceReplySenderDeps["sendMultipart"];
+    getDefaultChatId: () => number | undefined;
+    getDefaultTarget?: () => OutboundAttachments.TelegramQueuedOutboundAttachmentTurnView["target"];
+    resolveAgentTarget?: OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["resolveAgentTarget"];
+    routeAgentMessage?: OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["routeAgentMessage"];
+    canSendDirect: () => boolean;
+    setGenerativeAppLiveSurfaceRuntime?: (runtime: GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle> | undefined) => void;
+    updateStatus: TelegramBridgeStatusUpdater;
+    isContextCurrent: (ctx: Pi.ExtensionContext) => boolean;
+    getSessionGeneration: () => number;
+    connectionIntent: NonNullable<Commands.TelegramBridgeCommandRegistrationDeps["connectionIntent"]>;
+    recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}
+export declare function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }: TelegramCommandsAndToolsBindingDeps): void;
+interface TelegramLifecycleBindingDeps {
+    pi: Pi.ExtensionAPI;
+    publicationRuntime: TelegramBridgePublicationRuntime;
+    activityRuntime: Activity.TelegramActivityRuntime;
+    activityVerbosityRuntime?: ActivityVerbosity.TelegramActivityVerbosityRuntime;
+    diagnostics?: {
+        onSessionStart(): void;
+        onSessionShutdown(): Promise<void>;
+    };
+    assistantOutputRuntime: Pick<Activity.TelegramAssistantOutputRuntime, "start" | "beginTurn" | "hasAdmittedTelegramIntermediate" | "waitForIdle" | "stop">;
+    sessionLifecycleRuntime: Pick<Lifecycle.TelegramLifecycleRegistrationDeps, "onSessionStart" | "onSessionShutdown" | "onModelSelect">;
+    configStore: Pick<Config.TelegramConfigStore, "get" | "getOutboundHandlers" | "hasBotToken" | "load">;
+    abort: Runtime.TelegramRuntimeAbortPort;
+    typing: Runtime.TelegramRuntimeTypingPort;
+    lifecycle: Runtime.TelegramRuntimeLifecyclePort;
+    activeTurnRuntime: Queue.TelegramActiveTurnStore<Queue.PendingTelegramTurn>;
+    telegramQueueStore: Queue.TelegramQueueStore<Pi.ExtensionContext>;
+    modelSwitchController: Model.TelegramModelSwitchController<Pi.ExtensionContext, Model.ScopedTelegramModel<ActivePiModel>>;
+    previewRuntime: Preview.TelegramAssistantPreviewRuntime<Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>;
+    promptDispatchRuntime: Runtime.TelegramPromptDispatchRuntime<Pi.ExtensionContext>;
+    deferredQueueDispatchRuntime: Queue.TelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>;
+    modelContextAvailabilityRuntime: Prompts.TelegramModelContextAvailabilityRuntime;
+    disconnectOnQuit?: () => Promise<unknown>;
+    onSessionStarted?: (event: Pi.SessionStartEvent, ctx: Pi.ExtensionContext) => void;
+    shutdownGenerativeAppLiveSurfaces?: () => void;
+    resolveAutomaticThreadCleanupEnabled?: () => boolean | Promise<boolean>;
+    buttonActionStore: OutboundHandlers.TelegramButtonActionStore;
+    callMultipart: OutboundHandlers.TelegramVoiceReplySenderDeps["sendMultipart"];
+    sendChatAction: NonNullable<OutboundHandlers.TelegramVoiceReplySenderDeps["sendChatAction"]>;
+    sendRecordVoiceAction: NonNullable<OutboundHandlers.TelegramVoiceReplySenderDeps["sendRecordVoiceAction"]>;
+    sendMarkdownReply: Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["sendMarkdownReply"];
+    sendTextReply: Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["sendTextReply"] & NonNullable<OutboundHandlers.TelegramVoiceReplySenderDeps["sendTextReply"]>;
+    dispatchNextQueuedTelegramTurn: (ctx: Pi.ExtensionContext) => void;
+    onPromptHandedOff?: (turn: Queue.PendingTelegramTurn, ctx: Pi.ExtensionContext) => void;
+    answerGuestQuery: TelegramApi.TelegramBridgeApiRuntime["answerGuestQuery"];
+    deleteMessage: TelegramApi.TelegramBridgeApiRuntime["deleteMessage"];
+    sendGuestReply: NonNullable<Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["sendGuestReply"]>;
+    editGuestReply?: Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["editGuestReply"];
+    stopGuestPlaceholder?: Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["stopGuestPlaceholder"];
+    preparePreviewDelivery?: Queue.TelegramAgentEndRuntimeDeps<Queue.PendingTelegramTurn>["preparePreviewDelivery"];
+    finalizeMarkdownPreview: Queue.TelegramAgentEndHookRuntimeDeps<Queue.PendingTelegramTurn, Pi.ExtensionContext, Pi.AgentEndEvent["messages"][number], Keyboard.TelegramInlineKeyboardMarkup>["finalizeMarkdownPreview"];
+    proactivePushTargetGetter: () => Queue.TelegramQueueTarget | undefined;
+    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;
+    updateStatus: TelegramBridgeStatusUpdater;
+    recordRuntimeEvent: TelegramRuntimeEventRecorder;
+}
+export declare function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive, isTurnTransportActive, updateStatus, recordRuntimeEvent, }: TelegramLifecycleBindingDeps): void;
+export {};