pi-harness-runtime 1.1.427 → 1.1.428

package/scripts/verify-package-contents.ts

@@ -30,6 +30,10 @@ import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { execFile, spawnSync } from "node:child_process";
 import { join, resolve, dirname, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+	extractRelativeValueImports,
+	resolveRelativeImport,
+} from "./lib/runtime-imports.js";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const verifyTarball = process.argv.includes("--pack");
@@ -38,6 +42,7 @@ interface Problem {
 	kind:
 		| "missing-dist"
 		| "missing-import"
+		| "broken-import"
 		| "missing-tarball"
 		| "missing-package"
 		| "forbidden-path"
@@ -406,8 +411,13 @@ function checkStaleOutputs(): void {
 	}
 }
 
-/** The tarball npm would publish must contain the built output. */
-async function inspectTarball(): Promise<void> {
+/**
+ * The files npm would publish.
+ *
+ * The list comes from npm itself, so a check sees exactly what a consumer
+ * gets - not what the repository happens to contain.
+ */
+async function packFileList(): Promise<string[]> {
 	const stdout = await new Promise<string>((resolveText, rejectText) => {
 		execFile(
 			"npm",
@@ -423,29 +433,59 @@ async function inspectTarball(): Promise<void> {
 		);
 	});
 
-	let files: string[] = [];
 	try {
 		// `npm pack --json` returns an array with one entry per packed tarball.
 		const parsed = JSON.parse(stdout) as
 			| { files?: { path: string }[] }[]
 			| { files?: { path: string }[] };
 		const entries = Array.isArray(parsed) ? parsed : [parsed];
-		files = entries.flatMap((entry) => entry?.files ?? []).map((file) => file.path);
-		if (files.length === 0) {
+		return entries.flatMap((entry) => entry?.files ?? []).map((file) => file.path);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Every relative import of a published file must resolve.
+ *
+ * The published app reaches its internal packages through relative paths,
+ * so an import that does not resolve is a module graph that breaks when it
+ * runs. A published `.js` file has to reach a published file: a consumer
+ * never sees the repository. A published `.ts` file is resolved by the
+ * compiler, so it may reach a source file in the repository.
+ *
+ * The earlier import check only followed specifiers that contained
+ * "packages/" and never looked at the compiled output, so an import inside
+ * a package was never verified. That is how a package whose entry point
+ * could not be imported reached the registry.
+ */
+function checkRelativeImports(files: string[]): void {
+	const published = new Set(files);
+	for (const path of files) {
+		if (!/\.(ts|mts|cts|mjs|js|cjs)$/.test(path)) continue;
+		if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) continue;
+		const full = join(ROOT, path);
+		if (!existsSync(full)) continue;
+		const content = readFileSync(full, "utf8");
+		for (const specifier of extractRelativeValueImports(content)) {
+			const result = resolveRelativeImport({
+				importer: full,
+				specifier,
+				exists: existsSync,
+				isPublished: (candidate) =>
+					published.has(relative(ROOT, candidate).split("\\").join("/")),
+			});
+			if (result.ok) continue;
 			problems.push({
-				kind: "missing-tarball",
-				detail: "npm pack --dry-run did not return a file list",
+				kind: "broken-import",
+				detail: `${path} imports ${specifier} but ${result.reason}`,
 			});
-			return;
 		}
-	} catch {
-		problems.push({
-			kind: "missing-tarball",
-			detail: "npm pack --dry-run did not return a file list",
-		});
-		return;
 	}
+}
 
+/** The tarball npm would publish must contain the built output. */
+function inspectTarball(files: string[]): void {
 	for (const file of files) {
 		const posix = file.split("\\").join("/");
 		for (const prefix of FORBIDDEN_PACKAGE_PREFIXES) {
@@ -503,7 +543,19 @@ checkPluginCopySource();
 checkImports();
 checkPackageEntries();
 checkStaleOutputs();
-if (verifyTarball) await inspectTarball();
+
+// The published file list drives both the import check and the tarball
+// check: it is what a consumer receives.
+const publishedFiles = await packFileList();
+if (publishedFiles.length === 0) {
+	problems.push({
+		kind: "missing-tarball",
+		detail: "npm pack --dry-run did not return a file list",
+	});
+} else {
+	checkRelativeImports(publishedFiles);
+	if (verifyTarball) inspectTarball(publishedFiles);
+}
 
 if (problems.length > 0) {
 	console.error(`[verify-package-contents] FAILED with ${problems.length} problem(s):`);
@@ -518,7 +570,7 @@ if (problems.length > 0) {
 }
 
 console.log(
-	`[verify-package-contents] OK - ${runtimeImports.size} runtime import(s) resolved${
-		verifyTarball ? ", tarball verified" : ""
-	}`,
+	`[verify-package-contents] OK - ${runtimeImports.size} runtime import(s) resolved, ${
+		publishedFiles.length
+	} published file(s) checked${verifyTarball ? ", tarball verified" : ""}`,
 );

package/packages/telegram/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "@pi-harness/telegram",
-  "version": "1.1.427",
-  "description": "pi-harness-runtime — Telegram inbound/outbound",
-  "type": "module",
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./src/index.js",
-      "types": "./src/index.d.ts"
-    }
-  },
-  "files": [
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "bun test"
-  },
-  "dependencies": {}
-}

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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1,90 +0,0 @@
-/**
- * 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

@@ -1,296 +0,0 @@
-/**
- * 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 {};