@fased/fased 0.1.41 → 0.1.43

package/dist/plugin-sdk/types-CXLEOrJX.d.ts

@@ -0,0 +1,3359 @@
+import { t as ChatType } from "./chat-type-CK5stkc4.js";
+import { An as GetReplyOptions, At as FasedAgentConfig, B as ChannelCapabilities, Ct as RuntimeEnv, Dn as MarkdownTableMode, E as ChannelPairingAdapter, F as ChannelAccountSnapshot, G as ChannelId, J as ChannelMessageActionAdapter, Jt as SlackSlashCommandConfig, Kt as TelegramGroupConfig, L as ChannelAgentPromptAdapter, N as BaseProbeResult, Nt as ModelProviderConfig, On as ReplyToMode, Ot as sendMessageDiscord, P as BaseTokenResolution, R as ChannelAgentTool, St as sendMessageIMessage, Tn as HumanDelayConfig, V as ChannelDirectoryEntry, _t as sendPollWhatsApp, bn as GroupToolPolicyConfig, bt as sendMessageSlack, c as writeConfigFile, dn as chunkMarkdownTextWithMode, f as ChannelCommandAdapter, fn as chunkText, ft as FinalizedMsgContext, gt as sendMessageWhatsApp, h as ChannelElevatedAdapter, hn as resolveTextChunkLimit, ht as ShouldHandleTextCommandsParams, jn as ReplyPayload, kt as sendPollDiscord, ln as chunkByNewline, mn as resolveChunkMode, mt as CommandNormalizeOptions, n as ChannelPlugin, o as WizardPrompter, ot as ChannelThreadingAdapter, p as ChannelConfigAdapter, pn as chunkTextWithMode, pt as MsgContext, q as ChannelMentionAdapter, s as loadConfig, sn as TtsAutoMode, un as chunkMarkdownText, v as ChannelGroupAdapter, vn as PollInput, vt as sendMessageTelegram, wn as GroupPolicy, xt as sendMessageSignal, yn as GroupToolPolicyBySenderConfig, yt as sendPollTelegram } from "./types.plugin-CvUiB3Kh.js";
+import { C as readWebSelfId, H as resolveStateDir, M as LookupFn, P as SsrFPolicy, S as logoutWeb, _ as PushTestParams, a as GatewayClient, b as getWebAuthAgeMs, c as GatewayRequestHandlerOptions, i as OperatorScope, j as LogLevel, l as GatewayRequestHandlers, m as ChatInjectParams, n as AuthProfileStore, o as GatewayRequestContext, r as OAuthCredential, s as GatewayRequestHandler, t as AuthProfileCredential, v as WebLoginStartParams, w as webAuthExists, x as logWebSelfId, y as WebLoginWaitParams } from "./types-CJGVZX6j.js";
+import { WebClient } from "@slack/web-api";
+import { Skill } from "@mariozechner/pi-coding-agent";
+import { AgentMessage, AgentTool, AgentToolResult } from "@mariozechner/pi-agent-core";
+import { TSchema } from "@sinclair/typebox";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Command } from "commander";
+import { AnyMessageContent, makeWASocket } from "@whiskeysockets/baileys";
+import { WebhookRequestBody, messagingApi } from "@line/bot-sdk";
+
+//#region src/utils/delivery-context.d.ts
+type DeliveryContext = {
+  channel?: string;
+  to?: string;
+  accountId?: string;
+  threadId?: string | number;
+};
+//#endregion
+//#region src/config/sessions/types.d.ts
+type SessionChannelId = ChannelId | "webchat";
+type SessionChatType = ChatType;
+type SessionOrigin = {
+  label?: string;
+  provider?: string;
+  surface?: string;
+  chatType?: SessionChatType;
+  from?: string;
+  to?: string;
+  accountId?: string;
+  threadId?: string | number;
+};
+type SessionAcpIdentitySource = "ensure" | "status" | "event";
+type SessionAcpIdentityState = "pending" | "resolved";
+type SessionAcpIdentity = {
+  state: SessionAcpIdentityState;
+  acpxRecordId?: string;
+  acpxSessionId?: string;
+  agentSessionId?: string;
+  source: SessionAcpIdentitySource;
+  lastUpdatedAt: number;
+};
+type SessionAcpMeta = {
+  backend: string;
+  agent: string;
+  runtimeSessionName: string;
+  identity?: SessionAcpIdentity;
+  mode: "persistent" | "oneshot";
+  runtimeOptions?: AcpSessionRuntimeOptions;
+  cwd?: string;
+  state: "idle" | "running" | "error";
+  lastActivityAt: number;
+  lastError?: string;
+};
+type AcpSessionRuntimeOptions = {
+  /**
+   * ACP runtime mode set via session/set_mode (for example: "plan", "normal", "auto").
+   */
+  runtimeMode?: string; /** ACP runtime config option: model id. */
+  model?: string; /** Working directory override for ACP session turns. */
+  cwd?: string; /** ACP runtime config option: permission profile id. */
+  permissionProfile?: string; /** ACP runtime config option: per-turn timeout in seconds. */
+  timeoutSeconds?: number; /** Backend-specific option bag mapped through session/set_config_option. */
+  backendExtras?: Record<string, string>;
+};
+type SessionCompactionCheckpointReason = "manual" | "auto-threshold" | "overflow-retry" | "timeout-retry";
+type SessionCompactionTranscriptReference = {
+  sessionId: string;
+  sessionFile?: string;
+  leafId?: string;
+  entryId?: string;
+};
+type SessionCompactionCheckpoint = {
+  checkpointId: string;
+  sessionKey: string;
+  sessionId: string;
+  createdAt: number;
+  reason: SessionCompactionCheckpointReason;
+  tokensBefore?: number;
+  tokensAfter?: number;
+  summary?: string;
+  firstKeptEntryId?: string;
+  preCompaction: SessionCompactionTranscriptReference;
+  postCompaction: SessionCompactionTranscriptReference;
+};
+type SessionEntry = {
+  /**
+   * Last delivered heartbeat payload (used to suppress duplicate heartbeat notifications).
+   * Stored on the main session entry.
+   */
+  lastHeartbeatText?: string; /** Timestamp (ms) when lastHeartbeatText was delivered. */
+  lastHeartbeatSentAt?: number;
+  sessionId: string;
+  updatedAt: number;
+  sessionFile?: string; /** Parent session key that spawned this session (used for sandbox session-tool scoping). */
+  spawnedBy?: string; /** Legacy alias retained for older tests and persisted stores. Prefer spawnedBy/baseSessionKey. */
+  parentSessionKey?: string; /** True after a thread/topic session has been forked from its parent transcript once. */
+  forkedFromParent?: boolean; /** Subagent spawn depth (0 = main, 1 = sub-agent, 2 = sub-sub-agent). */
+  spawnDepth?: number;
+  systemSent?: boolean;
+  abortedLastRun?: boolean; /** Runtime status snapshot for detached/sub-agent sessions. */
+  status?: string; /** Runtime start timestamp for detached/sub-agent sessions. */
+  startedAt?: number; /** Runtime end timestamp for detached/sub-agent sessions. */
+  endedAt?: number; /** Runtime duration snapshot for detached/sub-agent sessions. */
+  runtimeMs?: number;
+  /**
+   * Session-level stop cutoff captured when /stop is received.
+   * Messages at/before this boundary are skipped to avoid replaying
+   * queued pre-stop backlog.
+   */
+  abortCutoffMessageSid?: string; /** Epoch ms cutoff paired with abortCutoffMessageSid when available. */
+  abortCutoffTimestamp?: number;
+  chatType?: SessionChatType;
+  thinkingLevel?: string;
+  verboseLevel?: string;
+  reasoningLevel?: string;
+  elevatedLevel?: string;
+  ttsAuto?: TtsAutoMode;
+  execHost?: string;
+  execSecurity?: string;
+  execAsk?: string;
+  execNode?: string;
+  responseUsage?: "on" | "off" | "tokens" | "full";
+  providerOverride?: string;
+  modelOverride?: string;
+  modelOverrideSource?: "auto" | "user";
+  authProfileOverride?: string;
+  authProfileOverrideSource?: "auto" | "user";
+  authProfileOverrideCompactionCount?: number;
+  groupActivation?: "mention" | "always";
+  systemPromptOverride?: string;
+  groupActivationNeedsSystemIntro?: boolean;
+  sendPolicy?: "allow" | "deny";
+  queueMode?: "steer" | "followup" | "collect" | "steer-backlog" | "steer+backlog" | "queue" | "interrupt";
+  queueDebounceMs?: number;
+  queueCap?: number;
+  queueDrop?: "old" | "new" | "summarize";
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  /**
+   * Whether totalTokens reflects a fresh context snapshot for the latest run.
+   * Undefined means legacy/unknown freshness; false forces consumers to treat
+   * totalTokens as stale/unknown for context-utilization displays.
+   */
+  totalTokensFresh?: boolean;
+  cacheRead?: number;
+  cacheWrite?: number;
+  modelProvider?: string;
+  model?: string;
+  /**
+   * Last selected/runtime model pair for which a fallback notice was emitted.
+   * Used to avoid repeating the same fallback notice every turn.
+   */
+  fallbackNoticeSelectedModel?: string;
+  fallbackNoticeActiveModel?: string;
+  fallbackNoticeReason?: string;
+  contextTokens?: number;
+  liveModelSwitchPending?: boolean;
+  compactionCount?: number;
+  compactionCheckpoints?: SessionCompactionCheckpoint[];
+  memoryFlushAt?: number;
+  memoryFlushCompactionCount?: number;
+  cliSessionIds?: Record<string, string>;
+  claudeCliSessionId?: string;
+  label?: string;
+  displayName?: string;
+  /**
+   * For a channel/base session, the currently selected named child session.
+   * This lets a single Telegram/Discord/Slack chat switch between named work
+   * contexts without changing the channel route itself.
+   */
+  activeSessionKey?: string; /** Base channel/session key that owns this named child session. */
+  baseSessionKey?: string; /** Stable slug used by /session switch/list for named channel sessions. */
+  sessionSlug?: string;
+  channel?: string;
+  groupId?: string;
+  subject?: string;
+  groupChannel?: string;
+  space?: string;
+  origin?: SessionOrigin;
+  deliveryContext?: DeliveryContext;
+  lastChannel?: SessionChannelId;
+  lastTo?: string;
+  lastAccountId?: string;
+  lastThreadId?: string | number;
+  skillsSnapshot?: SessionSkillSnapshot;
+  systemPromptReport?: SessionSystemPromptReport;
+  acp?: SessionAcpMeta;
+};
+type GroupKeyResolution = {
+  key: string;
+  channel?: string;
+  id?: string;
+  chatType?: SessionChatType;
+};
+type SessionSkillSnapshot = {
+  prompt: string;
+  skills: Array<{
+    name: string;
+    primaryEnv?: string;
+    requiredEnv?: string[];
+  }>; /** Normalized agent-level filter used to build this snapshot; undefined means unrestricted. */
+  skillFilter?: string[];
+  resolvedSkills?: Skill[];
+  version?: number;
+};
+type SessionSystemPromptReport = {
+  source: "run" | "estimate";
+  generatedAt: number;
+  sessionId?: string;
+  sessionKey?: string;
+  provider?: string;
+  model?: string;
+  workspaceDir?: string;
+  bootstrapMaxChars?: number;
+  bootstrapTotalMaxChars?: number;
+  bootstrapTruncation?: {
+    warningMode?: "off" | "once" | "always";
+    warningSignaturesSeen?: string[];
+    promptWarningSignature?: string;
+    [key: string]: unknown;
+  };
+  sandbox?: {
+    mode?: string;
+    sandboxed?: boolean;
+  };
+  systemPrompt: {
+    chars: number;
+    projectContextChars: number;
+    nonProjectContextChars: number;
+  };
+  injectedWorkspaceFiles: Array<{
+    name: string;
+    path: string;
+    missing: boolean;
+    rawChars: number;
+    injectedChars: number;
+    truncated: boolean;
+  }>;
+  skills: {
+    promptChars: number;
+    entries: Array<{
+      name: string;
+      blockChars: number;
+    }>;
+  };
+  tools: {
+    listChars: number;
+    schemaChars: number;
+    entries: Array<{
+      name: string;
+      summaryChars: number;
+      schemaChars: number;
+      propertiesCount?: number | null;
+    }>;
+  };
+};
+//#endregion
+//#region src/config/sessions/paths.d.ts
+declare function resolveStorePath(store?: string, opts?: {
+  agentId?: string;
+}): string;
+//#endregion
+//#region src/config/sessions/store.d.ts
+declare function readSessionUpdatedAt(params: {
+  storePath: string;
+  sessionKey: string;
+}): number | undefined;
+declare function recordSessionMetaFromInbound(params: {
+  storePath: string;
+  sessionKey: string;
+  ctx: MsgContext;
+  groupResolution?: GroupKeyResolution | null;
+  createIfMissing?: boolean;
+}): Promise<SessionEntry | null>;
+declare function updateLastRoute(params: {
+  storePath: string;
+  sessionKey: string;
+  channel?: SessionEntry["lastChannel"];
+  to?: string;
+  accountId?: string;
+  threadId?: string | number;
+  deliveryContext?: DeliveryContext;
+  ctx?: MsgContext;
+  groupResolution?: GroupKeyResolution | null;
+}): Promise<SessionEntry>;
+//#endregion
+//#region src/globals.d.ts
+declare function shouldLogVerbose(): boolean;
+//#endregion
+//#region src/auto-reply/reply/get-reply.d.ts
+declare function getReplyFromConfig(ctx: MsgContext, opts?: GetReplyOptions, configOverride?: FasedAgentConfig): Promise<ReplyPayload | ReplyPayload[] | undefined>;
+//#endregion
+//#region src/agents/tools/common.d.ts
+type AnyAgentTool = AgentTool<any, unknown> & {
+  ownerOnly?: boolean;
+  displaySummary?: string;
+};
+type StringParamOptions = {
+  required?: boolean;
+  trim?: boolean;
+  label?: string;
+  allowEmpty?: boolean;
+};
+type ActionGate<T extends Record<string, boolean | undefined>> = (key: keyof T, defaultValue?: boolean) => boolean;
+declare function createActionGate<T extends Record<string, boolean | undefined>>(actions: T | undefined): ActionGate<T>;
+declare function readStringParam(params: Record<string, unknown>, key: string, options: StringParamOptions & {
+  required: true;
+}): string;
+declare function readStringParam(params: Record<string, unknown>, key: string, options?: StringParamOptions): string | undefined;
+declare function readNumberParam(params: Record<string, unknown>, key: string, options?: {
+  required?: boolean;
+  label?: string;
+  integer?: boolean;
+}): number | undefined;
+type ReactionParams = {
+  emoji: string;
+  remove: boolean;
+  isEmpty: boolean;
+};
+declare function readReactionParams(params: Record<string, unknown>, options: {
+  emojiKey?: string;
+  removeKey?: string;
+  removeErrorMessage: string;
+}): ReactionParams;
+declare function jsonResult(payload: unknown): AgentToolResult<unknown>;
+//#endregion
+//#region src/channels/typing.d.ts
+type TypingCallbacks = {
+  onReplyStart: () => Promise<void>;
+  onIdle?: () => void; /** Called when the typing controller is cleaned up (e.g. on NO_REPLY). */
+  onCleanup?: () => void;
+};
+type CreateTypingCallbacksParams = {
+  start: () => Promise<void>;
+  stop?: () => Promise<void>;
+  onStartError: (err: unknown) => void;
+  onStopError?: (err: unknown) => void;
+  keepaliveIntervalMs?: number; /** Stop keepalive after this many consecutive start() failures. Default: 2 */
+  maxConsecutiveFailures?: number; /** Maximum duration for typing indicator before auto-cleanup (safety TTL). Default: 60s */
+  maxDurationMs?: number;
+};
+declare function createTypingCallbacks(params: CreateTypingCallbacksParams): TypingCallbacks;
+//#endregion
+//#region src/auto-reply/reply/response-prefix-template.d.ts
+/**
+ * Template interpolation for response prefix.
+ *
+ * Supports variables like `{model}`, `{provider}`, `{thinkingLevel}`, etc.
+ * Variables are case-insensitive and unresolved ones remain as literal text.
+ */
+type ResponsePrefixContext = {
+  /** Short model name (e.g., "gpt-5.2", "claude-opus-4-6") */model?: string; /** Full model ID including provider (e.g., "openai-codex/gpt-5.2") */
+  modelFull?: string; /** Provider name (e.g., "openai-codex", "anthropic") */
+  provider?: string; /** Current thinking level (e.g., "high", "low", "off") */
+  thinkingLevel?: string; /** Agent identity name */
+  identityName?: string;
+};
+//#endregion
+//#region src/auto-reply/reply/normalize-reply.d.ts
+type NormalizeReplySkipReason = "empty" | "silent" | "heartbeat";
+//#endregion
+//#region src/auto-reply/reply/reply-dispatcher.d.ts
+type ReplyDispatchKind = "tool" | "block" | "final";
+type ReplyDispatchErrorHandler = (err: unknown, info: {
+  kind: ReplyDispatchKind;
+}) => void;
+type ReplyDispatchSkipHandler = (payload: ReplyPayload, info: {
+  kind: ReplyDispatchKind;
+  reason: NormalizeReplySkipReason;
+}) => void;
+type ReplyDispatchDeliverer = (payload: ReplyPayload, info: {
+  kind: ReplyDispatchKind;
+}) => Promise<void>;
+type ReplyDispatcherOptions = {
+  deliver: ReplyDispatchDeliverer;
+  responsePrefix?: string; /** Static context for response prefix template interpolation. */
+  responsePrefixContext?: ResponsePrefixContext;
+  /** Dynamic context provider for response prefix template interpolation.
+   * Called at normalization time, after model selection is complete. */
+  responsePrefixContextProvider?: () => ResponsePrefixContext;
+  onHeartbeatStrip?: () => void;
+  onIdle?: () => void;
+  onError?: ReplyDispatchErrorHandler;
+  onSkip?: ReplyDispatchSkipHandler; /** Human-like delay between block replies for natural rhythm. */
+  humanDelay?: HumanDelayConfig;
+};
+type ReplyDispatcherWithTypingOptions = Omit<ReplyDispatcherOptions, "onIdle"> & {
+  typingCallbacks?: TypingCallbacks;
+  onReplyStart?: () => Promise<void> | void;
+  onIdle?: () => void; /** Called when the typing controller is cleaned up (e.g., on NO_REPLY). */
+  onCleanup?: () => void;
+};
+type ReplyDispatcherWithTypingResult = {
+  dispatcher: ReplyDispatcher;
+  replyOptions: Pick<GetReplyOptions, "onReplyStart" | "onTypingController" | "onTypingCleanup">;
+  markDispatchIdle: () => void;
+};
+type ReplyDispatcher = {
+  sendToolResult: (payload: ReplyPayload) => boolean;
+  sendBlockReply: (payload: ReplyPayload) => boolean;
+  sendFinalReply: (payload: ReplyPayload) => boolean;
+  waitForIdle: () => Promise<void>;
+  getQueuedCounts: () => Record<ReplyDispatchKind, number>;
+  markComplete: () => void;
+};
+declare function createReplyDispatcherWithTyping(options: ReplyDispatcherWithTypingOptions): ReplyDispatcherWithTypingResult;
+//#endregion
+//#region src/auto-reply/reply/dispatch-from-config.d.ts
+type DispatchFromConfigResult = {
+  queuedFinal: boolean;
+  counts: Record<ReplyDispatchKind, number>;
+};
+declare function dispatchReplyFromConfig(params: {
+  ctx: FinalizedMsgContext;
+  cfg: FasedAgentConfig;
+  dispatcher: ReplyDispatcher;
+  replyOptions?: Omit<GetReplyOptions, "onToolResult" | "onBlockReply">;
+  replyResolver?: typeof getReplyFromConfig;
+}): Promise<DispatchFromConfigResult>;
+//#endregion
+//#region src/auto-reply/dispatch.d.ts
+type DispatchInboundResult = DispatchFromConfigResult;
+declare function withReplyDispatcher<T>(params: {
+  dispatcher: ReplyDispatcher;
+  run: () => Promise<T>;
+  onSettled?: () => void | Promise<void>;
+}): Promise<T>;
+//#endregion
+//#region src/auto-reply/reply/provider-dispatcher.d.ts
+declare function dispatchReplyWithBufferedBlockDispatcher(params: {
+  ctx: MsgContext | FinalizedMsgContext;
+  cfg: FasedAgentConfig;
+  dispatcherOptions: ReplyDispatcherWithTypingOptions;
+  replyOptions?: Omit<GetReplyOptions, "onToolResult" | "onBlockReply">;
+  replyResolver?: typeof getReplyFromConfig;
+}): Promise<DispatchInboundResult>;
+//#endregion
+//#region src/agents/identity.d.ts
+declare function resolveAckReaction(cfg: FasedAgentConfig, agentId: string, opts?: {
+  channel?: string;
+  accountId?: string;
+}): string;
+declare function resolveEffectiveMessagesConfig(cfg: FasedAgentConfig, agentId: string, opts?: {
+  hasAllowFrom?: boolean;
+  fallbackMessagePrefix?: string;
+  channel?: string;
+  accountId?: string;
+}): {
+  messagePrefix: string;
+  responsePrefix?: string;
+};
+declare function resolveHumanDelayConfig(cfg: FasedAgentConfig, agentId: string): HumanDelayConfig | undefined;
+//#endregion
+//#region src/routing/resolve-route.d.ts
+/** @deprecated Use ChatType from channels/chat-type.js */
+type RoutePeerKind = ChatType;
+type RoutePeer = {
+  kind: ChatType;
+  id: string;
+};
+type ResolveAgentRouteInput = {
+  cfg: FasedAgentConfig;
+  channel: string;
+  accountId?: string | null;
+  peer?: RoutePeer | null; /** Parent peer for threads — used for binding inheritance when peer doesn't match directly. */
+  parentPeer?: RoutePeer | null;
+  guildId?: string | null;
+  teamId?: string | null; /** Discord member role IDs — used for role-based agent routing. */
+  memberRoleIds?: string[];
+};
+type ResolvedAgentRoute = {
+  agentId: string;
+  channel: string;
+  accountId: string; /** Internal session key used for persistence + concurrency. */
+  sessionKey: string; /** Convenience alias for direct-chat collapse. */
+  mainSessionKey: string; /** Match description for debugging/logging. */
+  matchedBy: "binding.peer" | "binding.peer.parent" | "binding.guild+roles" | "binding.guild" | "binding.team" | "binding.account" | "binding.channel" | "default";
+};
+declare function resolveAgentRoute(input: ResolveAgentRouteInput): ResolvedAgentRoute;
+//#endregion
+//#region src/pairing/pairing-store.d.ts
+type PairingChannel = ChannelId;
+declare function readChannelAllowFromStore(channel: PairingChannel, env: NodeJS.ProcessEnv | undefined, accountId: string): Promise<string[]>;
+declare function upsertChannelPairingRequest(params: {
+  channel: PairingChannel;
+  id: string | number;
+  accountId: string;
+  meta?: Record<string, string | undefined | null>;
+  env?: NodeJS.ProcessEnv; /** Extension channels can pass their adapter directly to bypass registry lookup. */
+  pairingAdapter?: ChannelPairingAdapter;
+}): Promise<{
+  code: string;
+  created: boolean;
+}>;
+//#endregion
+//#region src/pairing/pairing-messages.d.ts
+declare function buildPairingReply(params: {
+  channel: PairingChannel;
+  idLine: string;
+  code: string;
+}): string;
+//#endregion
+//#region src/media/fetch.d.ts
+type FetchMediaResult = {
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+};
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type FetchMediaOptions = {
+  url: string;
+  fetchImpl?: FetchLike;
+  requestInit?: RequestInit;
+  filePathHint?: string;
+  maxBytes?: number;
+  maxRedirects?: number;
+  ssrfPolicy?: SsrFPolicy;
+  lookupFn?: LookupFn;
+};
+declare function fetchRemoteMedia(options: FetchMediaOptions): Promise<FetchMediaResult>;
+//#endregion
+//#region src/media/store.d.ts
+/**
+ * Extract original filename from path if it matches the embedded format.
+ * Pattern: {original}---{uuid}.{ext} → returns "{original}.{ext}"
+ * Falls back to basename if no pattern match, or "file.bin" if empty.
+ */
+declare function extractOriginalFilename(filePath: string): string;
+type SavedMedia = {
+  id: string;
+  path: string;
+  size: number;
+  contentType?: string;
+};
+declare function saveMediaBuffer(buffer: Buffer, contentType?: string, subdir?: string, maxBytes?: number, originalFilename?: string): Promise<SavedMedia>;
+//#endregion
+//#region src/tts/tts.d.ts
+type TtsTelephonyResult = {
+  success: boolean;
+  audioBuffer?: Buffer;
+  error?: string;
+  latencyMs?: number;
+  provider?: string;
+  outputFormat?: string;
+  sampleRate?: number;
+};
+declare function textToSpeechTelephony(params: {
+  text: string;
+  cfg: FasedAgentConfig;
+  prefsPath?: string;
+}): Promise<TtsTelephonyResult>;
+//#endregion
+//#region src/auto-reply/reply/mentions.d.ts
+declare function buildMentionRegexes(cfg: FasedAgentConfig | undefined, agentId?: string): RegExp[];
+declare function matchesMentionPatterns(text: string, mentionRegexes: RegExp[]): boolean;
+type ExplicitMentionSignal = {
+  hasAnyMention: boolean;
+  isExplicitlyMentioned: boolean;
+  canResolveExplicit: boolean;
+};
+declare function matchesMentionWithExplicit(params: {
+  text: string;
+  mentionRegexes: RegExp[];
+  explicit?: ExplicitMentionSignal;
+  transcript?: string;
+}): boolean;
+//#endregion
+//#region src/channels/ack-reactions.d.ts
+type AckReactionScope = "all" | "direct" | "group-all" | "group-mentions" | "off" | "none";
+type WhatsAppAckReactionMode = "always" | "mentions" | "never";
+type AckReactionGateParams = {
+  scope: AckReactionScope | undefined;
+  isDirect: boolean;
+  isGroup: boolean;
+  isMentionableGroup: boolean;
+  requireMention: boolean;
+  canDetectMention: boolean;
+  effectiveWasMentioned: boolean;
+  shouldBypassMention?: boolean;
+};
+declare function shouldAckReaction(params: AckReactionGateParams): boolean;
+declare function shouldAckReactionForWhatsApp(params: {
+  emoji: string;
+  isDirect: boolean;
+  isGroup: boolean;
+  directEnabled: boolean;
+  groupMode: WhatsAppAckReactionMode;
+  wasMentioned: boolean;
+  groupActivated: boolean;
+}): boolean;
+declare function removeAckReactionAfterReply(params: {
+  removeAfterReply: boolean;
+  ackReactionPromise: Promise<boolean> | null;
+  ackReactionValue: string | null;
+  remove: () => Promise<void>;
+  onError?: (err: unknown) => void;
+}): void;
+//#endregion
+//#region src/config/group-policy.d.ts
+type GroupPolicyChannel = ChannelId;
+type ChannelGroupConfig = {
+  requireMention?: boolean;
+  tools?: GroupToolPolicyConfig;
+  toolsBySender?: GroupToolPolicyBySenderConfig;
+};
+type ChannelGroupPolicy = {
+  allowlistEnabled: boolean;
+  allowed: boolean;
+  groupConfig?: ChannelGroupConfig;
+  defaultConfig?: ChannelGroupConfig;
+};
+type GroupToolPolicySender = {
+  senderId?: string | null;
+  senderName?: string | null;
+  senderUsername?: string | null;
+  senderE164?: string | null;
+};
+declare function resolveToolsBySender(params: {
+  toolsBySender?: GroupToolPolicyBySenderConfig;
+} & GroupToolPolicySender): GroupToolPolicyConfig | undefined;
+declare function resolveChannelGroupPolicy(params: {
+  cfg: FasedAgentConfig;
+  channel: GroupPolicyChannel;
+  groupId?: string | null;
+  accountId?: string | null;
+  groupIdCaseInsensitive?: boolean; /** When true, sender-level filtering (groupAllowFrom) is configured upstream. */
+  hasGroupAllowFrom?: boolean;
+}): ChannelGroupPolicy;
+declare function resolveChannelGroupRequireMention(params: {
+  cfg: FasedAgentConfig;
+  channel: GroupPolicyChannel;
+  groupId?: string | null;
+  accountId?: string | null;
+  groupIdCaseInsensitive?: boolean;
+  requireMentionOverride?: boolean;
+  overrideOrder?: "before-config" | "after-config";
+}): boolean;
+//#endregion
+//#region src/auto-reply/inbound-debounce.d.ts
+declare function resolveInboundDebounceMs(params: {
+  cfg: FasedAgentConfig;
+  channel: string;
+  overrideMs?: number;
+}): number;
+declare function createInboundDebouncer<T>(params: {
+  debounceMs: number;
+  buildKey: (item: T) => string | null | undefined;
+  shouldDebounce?: (item: T) => boolean;
+  resolveDebounceMs?: (item: T) => number | undefined;
+  onFlush: (items: T[]) => Promise<void>;
+  onError?: (err: unknown, items: T[]) => void;
+}): {
+  enqueue: (item: T) => Promise<void>;
+  flushKey: (key: string) => Promise<void>;
+};
+//#endregion
+//#region src/channels/command-gating.d.ts
+type CommandAuthorizer = {
+  configured: boolean;
+  allowed: boolean;
+};
+type CommandGatingModeWhenAccessGroupsOff = "allow" | "deny" | "configured";
+declare function resolveCommandAuthorizedFromAuthorizers(params: {
+  useAccessGroups: boolean;
+  authorizers: CommandAuthorizer[];
+  modeWhenAccessGroupsOff?: CommandGatingModeWhenAccessGroupsOff;
+}): boolean;
+declare function resolveControlCommandGate(params: {
+  useAccessGroups: boolean;
+  authorizers: CommandAuthorizer[];
+  allowTextCommands: boolean;
+  hasControlCommand: boolean;
+  modeWhenAccessGroupsOff?: CommandGatingModeWhenAccessGroupsOff;
+}): {
+  commandAuthorized: boolean;
+  shouldBlock: boolean;
+};
+//#endregion
+//#region src/config/markdown-tables.d.ts
+declare function resolveMarkdownTableMode(params: {
+  cfg?: Partial<FasedAgentConfig>;
+  channel?: string | null;
+  accountId?: string | null;
+}): MarkdownTableMode;
+//#endregion
+//#region src/markdown/tables.d.ts
+declare function convertMarkdownTables(markdown: string, mode: MarkdownTableMode): string;
+//#endregion
+//#region src/auto-reply/commands-registry.d.ts
+declare function shouldHandleTextCommands(params: ShouldHandleTextCommandsParams): boolean;
+//#endregion
+//#region src/auto-reply/command-detection.d.ts
+declare function hasControlCommand(text?: string, cfg?: FasedAgentConfig, options?: CommandNormalizeOptions): boolean;
+declare function isControlCommandMessage(text?: string, cfg?: FasedAgentConfig, options?: CommandNormalizeOptions): boolean;
+declare function shouldComputeCommandAuthorized(text?: string, cfg?: FasedAgentConfig, options?: CommandNormalizeOptions): boolean;
+//#endregion
+//#region src/auto-reply/reply/inbound-context.d.ts
+type FinalizeInboundContextOptions = {
+  forceBodyForAgent?: boolean;
+  forceBodyForCommands?: boolean;
+  forceChatType?: boolean;
+  forceConversationLabel?: boolean;
+};
+declare function finalizeInboundContext<T extends Record<string, unknown>>(ctx: T, opts?: FinalizeInboundContextOptions): T & FinalizedMsgContext;
+//#endregion
+//#region src/channels/sender-label.d.ts
+type SenderLabelParams = {
+  name?: string;
+  username?: string;
+  tag?: string;
+  e164?: string;
+  id?: string;
+};
+//#endregion
+//#region src/auto-reply/envelope.d.ts
+type AgentEnvelopeParams = {
+  channel: string;
+  from?: string;
+  timestamp?: number | Date;
+  host?: string;
+  ip?: string;
+  body: string;
+  previousTimestamp?: number | Date;
+  envelope?: EnvelopeFormatOptions;
+};
+type EnvelopeFormatOptions = {
+  /**
+   * "local" (default), "utc", "user", or an explicit IANA timezone string.
+   */
+  timezone?: string;
+  /**
+   * Include absolute timestamps in the envelope (default: true).
+   */
+  includeTimestamp?: boolean;
+  /**
+   * Include elapsed time suffix when previousTimestamp is provided (default: true).
+   */
+  includeElapsed?: boolean;
+  /**
+   * Optional user timezone used when timezone="user".
+   */
+  userTimezone?: string;
+};
+declare function resolveEnvelopeFormatOptions(cfg?: FasedAgentConfig): EnvelopeFormatOptions;
+declare function formatAgentEnvelope(params: AgentEnvelopeParams): string;
+declare function formatInboundEnvelope(params: {
+  channel: string;
+  from: string;
+  body: string;
+  timestamp?: number | Date;
+  chatType?: string;
+  senderLabel?: string;
+  sender?: SenderLabelParams;
+  previousTimestamp?: number | Date;
+  envelope?: EnvelopeFormatOptions;
+}): string;
+declare function formatInboundFromLabel(params: {
+  isGroup: boolean;
+  groupLabel?: string;
+  groupId?: string;
+  directLabel: string;
+  directId?: string;
+  groupFallback?: string;
+}): string;
+//#endregion
+//#region src/channels/session.d.ts
+type InboundLastRouteUpdate = {
+  sessionKey: string;
+  channel: SessionEntry["lastChannel"];
+  to: string;
+  accountId?: string;
+  threadId?: string | number;
+};
+declare function recordInboundSession(params: {
+  storePath: string;
+  sessionKey: string;
+  ctx: MsgContext;
+  groupResolution?: GroupKeyResolution | null;
+  createIfMissing?: boolean;
+  updateLastRoute?: InboundLastRouteUpdate;
+  onRecordError: (err: unknown) => void;
+}): Promise<void>;
+//#endregion
+//#region src/infra/channel-activity.d.ts
+type ChannelDirection = "inbound" | "outbound";
+type ActivityEntry = {
+  inboundAt: number | null;
+  outboundAt: number | null;
+};
+declare function recordChannelActivity(params: {
+  channel: ChannelId;
+  accountId?: string | null;
+  direction: ChannelDirection;
+  at?: number;
+}): void;
+declare function getChannelActivity(params: {
+  channel: ChannelId;
+  accountId?: string | null;
+}): ActivityEntry;
+//#endregion
+//#region src/infra/system-events.d.ts
+type SystemEventOptions = {
+  sessionKey: string;
+  contextKey?: string | null;
+  trusted?: boolean;
+};
+declare function enqueueSystemEvent(text: string, options: SystemEventOptions): boolean | undefined;
+//#endregion
+//#region src/process/exec.d.ts
+type SpawnResult = {
+  pid?: number;
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  killed: boolean;
+  termination: "exit" | "timeout" | "no-output-timeout" | "signal";
+  noOutputTimedOut?: boolean;
+};
+type CommandOptions = {
+  timeoutMs: number;
+  cwd?: string;
+  input?: string;
+  env?: NodeJS.ProcessEnv;
+  windowsVerbatimArguments?: boolean;
+  noOutputTimeoutMs?: number;
+};
+declare function runCommandWithTimeout(argv: string[], optionsOrTimeout: number | CommandOptions): Promise<SpawnResult>;
+//#endregion
+//#region src/plugins/runtime/native-deps.d.ts
+type NativeDependencyHintParams = {
+  packageName: string;
+  manager?: "pnpm" | "npm" | "yarn";
+  rebuildCommand?: string;
+  approveBuildsCommand?: string;
+  downloadCommand?: string;
+};
+declare function formatNativeDependencyHint(params: NativeDependencyHintParams): string;
+//#endregion
+//#region src/media/constants.d.ts
+type MediaKind = "image" | "audio" | "video" | "document" | "unknown";
+declare function mediaKindFromMime(mime?: string | null): MediaKind;
+//#endregion
+//#region src/media/image-ops.d.ts
+type ImageMetadata = {
+  width: number;
+  height: number;
+};
+declare function getImageMetadata(buffer: Buffer): Promise<ImageMetadata | null>;
+declare function resizeToJpeg(params: {
+  buffer: Buffer;
+  maxSide: number;
+  quality: number;
+  withoutEnlargement?: boolean;
+}): Promise<Buffer>;
+//#endregion
+//#region src/web/media.d.ts
+type WebMediaResult = {
+  buffer: Buffer;
+  contentType?: string;
+  kind: MediaKind;
+  fileName?: string;
+};
+type WebMediaOptions = {
+  maxBytes?: number;
+  optimizeImages?: boolean;
+  ssrfPolicy?: SsrFPolicy; /** Allowed root directories for local path reads. "any" is deprecated; prefer sandboxValidated + readFile. */
+  localRoots?: readonly string[] | "any"; /** Caller already validated the local path (sandbox/other guards); requires readFile override. */
+  sandboxValidated?: boolean;
+  readFile?: (filePath: string) => Promise<Buffer>;
+};
+declare function loadWebMedia(mediaUrl: string, maxBytesOrOptions?: number | WebMediaOptions, options?: {
+  ssrfPolicy?: SsrFPolicy;
+  localRoots?: readonly string[] | "any";
+}): Promise<WebMediaResult>;
+//#endregion
+//#region src/media/mime.d.ts
+declare function getFileExtension(filePath?: string | null): string | undefined;
+declare function detectMime(opts: {
+  buffer?: Buffer;
+  headerMime?: string | null;
+  filePath?: string;
+}): Promise<string | undefined>;
+declare function extensionForMime(mime?: string | null): string | undefined;
+//#endregion
+//#region src/media/audio.d.ts
+/**
+ * Backward-compatible alias used across plugin/runtime call sites.
+ * Keeps existing behavior while making Telegram-specific policy explicit.
+ */
+declare function isVoiceCompatibleAudio(opts: {
+  contentType?: string | null;
+  fileName?: string | null;
+}): boolean;
+//#endregion
+//#region src/agents/tools/memory-tool.d.ts
+declare function createMemorySearchTool(options: {
+  config?: FasedAgentConfig;
+  agentSessionKey?: string;
+}): AnyAgentTool | null;
+declare function createMemoryGetTool(options: {
+  config?: FasedAgentConfig;
+  agentSessionKey?: string;
+}): AnyAgentTool | null;
+//#endregion
+//#region src/cli/memory-cli.d.ts
+declare function registerMemoryCli(program: Command): void;
+//#endregion
+//#region src/channels/plugins/actions/discord.d.ts
+declare const discordMessageActions: ChannelMessageActionAdapter;
+//#endregion
+//#region src/discord/audit.d.ts
+type DiscordChannelPermissionsAuditEntry = {
+  channelId: string;
+  ok: boolean;
+  missing?: string[];
+  error?: string | null;
+  matchKey?: string;
+  matchSource?: "id";
+};
+type DiscordChannelPermissionsAudit = {
+  ok: boolean;
+  checkedChannels: number;
+  unresolvedChannels: number;
+  channels: DiscordChannelPermissionsAuditEntry[];
+  elapsedMs: number;
+};
+declare function collectDiscordAuditChannelIds(params: {
+  cfg: FasedAgentConfig;
+  accountId?: string | null;
+}): {
+  channelIds: string[];
+  unresolvedChannels: number;
+};
+declare function auditDiscordChannelPermissions(params: {
+  token: string;
+  accountId?: string | null;
+  channelIds: string[];
+  timeoutMs: number;
+}): Promise<DiscordChannelPermissionsAudit>;
+//#endregion
+//#region src/channels/plugins/directory-config.d.ts
+type DirectoryConfigParams = {
+  cfg: FasedAgentConfig;
+  accountId?: string | null;
+  query?: string | null;
+  limit?: number | null;
+};
+declare function listSlackDirectoryPeersFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listSlackDirectoryGroupsFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listDiscordDirectoryPeersFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listDiscordDirectoryGroupsFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listTelegramDirectoryPeersFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listTelegramDirectoryGroupsFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listWhatsAppDirectoryPeersFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listWhatsAppDirectoryGroupsFromConfig(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+//#endregion
+//#region src/discord/directory-live.d.ts
+declare function listDiscordDirectoryGroupsLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listDiscordDirectoryPeersLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+//#endregion
+//#region src/discord/probe.d.ts
+type DiscordProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs: number;
+  bot?: {
+    id?: string | null;
+    username?: string | null;
+  };
+  application?: DiscordApplicationSummary;
+};
+type DiscordPrivilegedIntentStatus = "enabled" | "limited" | "disabled";
+type DiscordPrivilegedIntentsSummary = {
+  messageContent: DiscordPrivilegedIntentStatus;
+  guildMembers: DiscordPrivilegedIntentStatus;
+  presence: DiscordPrivilegedIntentStatus;
+};
+type DiscordApplicationSummary = {
+  id?: string | null;
+  flags?: number | null;
+  intents?: DiscordPrivilegedIntentsSummary;
+};
+declare function probeDiscord(token: string, timeoutMs: number, opts?: {
+  fetcher?: typeof fetch;
+  includeApplication?: boolean;
+}): Promise<DiscordProbe>;
+//#endregion
+//#region src/discord/resolve-channels.d.ts
+type DiscordChannelResolution = {
+  input: string;
+  resolved: boolean;
+  guildId?: string;
+  guildName?: string;
+  channelId?: string;
+  channelName?: string;
+  archived?: boolean;
+  note?: string;
+};
+declare function resolveDiscordChannelAllowlist(params: {
+  token: string;
+  entries: string[];
+  fetcher?: typeof fetch;
+}): Promise<DiscordChannelResolution[]>;
+//#endregion
+//#region src/discord/resolve-users.d.ts
+type DiscordUserResolution = {
+  input: string;
+  resolved: boolean;
+  id?: string;
+  name?: string;
+  guildId?: string;
+  guildName?: string;
+  note?: string;
+};
+declare function resolveDiscordUserAllowlist(params: {
+  token: string;
+  entries: string[];
+  fetcher?: typeof fetch;
+}): Promise<DiscordUserResolution[]>;
+//#endregion
+//#region src/config/runtime-group-policy.d.ts
+type RuntimeGroupPolicyResolution = {
+  groupPolicy: GroupPolicy;
+  providerMissingFallbackApplied: boolean;
+};
+type ResolveProviderRuntimeGroupPolicyParams = {
+  providerConfigPresent: boolean;
+  groupPolicy?: GroupPolicy;
+  defaultGroupPolicy?: GroupPolicy;
+};
+type GroupPolicyDefaultsConfig = {
+  channels?: {
+    defaults?: {
+      groupPolicy?: GroupPolicy;
+    };
+  };
+};
+declare function resolveDefaultGroupPolicy(cfg: GroupPolicyDefaultsConfig): GroupPolicy | undefined;
+declare const GROUP_POLICY_BLOCKED_LABEL: {
+  readonly group: "group messages";
+  readonly guild: "guild messages";
+  readonly room: "room messages";
+  readonly channel: "channel messages";
+  readonly space: "space messages";
+};
+/**
+ * Standard provider runtime policy:
+ * - configured provider fallback: open
+ * - missing provider fallback: allowlist (fail-closed)
+ */
+declare function resolveOpenProviderRuntimeGroupPolicy(params: ResolveProviderRuntimeGroupPolicyParams): RuntimeGroupPolicyResolution;
+/**
+ * Strict provider runtime policy:
+ * - configured provider fallback: allowlist
+ * - missing provider fallback: allowlist (fail-closed)
+ */
+declare function resolveAllowlistProviderRuntimeGroupPolicy(params: ResolveProviderRuntimeGroupPolicyParams): RuntimeGroupPolicyResolution;
+declare function warnMissingProviderGroupPolicyFallbackOnce(params: {
+  providerMissingFallbackApplied: boolean;
+  providerKey: string;
+  accountId?: string;
+  blockedLabel?: string;
+  log: (message: string) => void;
+}): boolean;
+//#endregion
+//#region src/discord/monitor/provider.d.ts
+type MonitorDiscordOpts = {
+  token?: string;
+  accountId?: string;
+  config?: FasedAgentConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  mediaMaxMb?: number;
+  historyLimit?: number;
+  replyToMode?: ReplyToMode;
+  getStatus?: () => ChannelAccountSnapshot;
+  setStatus?: (next: ChannelAccountSnapshot) => void;
+};
+declare function monitorDiscordProvider(opts?: MonitorDiscordOpts): Promise<void>;
+//#endregion
+//#region src/slack/directory-live.d.ts
+declare function listSlackDirectoryPeersLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+declare function listSlackDirectoryGroupsLive(params: DirectoryConfigParams): Promise<ChannelDirectoryEntry[]>;
+//#endregion
+//#region src/slack/probe.d.ts
+type SlackProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs?: number | null;
+  bot?: {
+    id?: string;
+    name?: string;
+  };
+  team?: {
+    id?: string;
+    name?: string;
+  };
+};
+declare function probeSlack(token: string, timeoutMs?: number): Promise<SlackProbe>;
+//#endregion
+//#region src/slack/resolve-channels.d.ts
+type SlackChannelResolution = {
+  input: string;
+  resolved: boolean;
+  id?: string;
+  name?: string;
+  archived?: boolean;
+};
+declare function resolveSlackChannelAllowlist(params: {
+  token: string;
+  entries: string[];
+  client?: WebClient;
+}): Promise<SlackChannelResolution[]>;
+//#endregion
+//#region src/slack/resolve-users.d.ts
+type SlackUserResolution = {
+  input: string;
+  resolved: boolean;
+  id?: string;
+  name?: string;
+  email?: string;
+  deleted?: boolean;
+  isBot?: boolean;
+  note?: string;
+};
+declare function resolveSlackUserAllowlist(params: {
+  token: string;
+  entries: string[];
+  client?: WebClient;
+}): Promise<SlackUserResolution[]>;
+//#endregion
+//#region src/slack/monitor/types.d.ts
+type MonitorSlackOpts = {
+  botToken?: string;
+  appToken?: string;
+  accountId?: string;
+  mode?: "socket" | "http";
+  config?: FasedAgentConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  mediaMaxMb?: number;
+  slashCommand?: SlackSlashCommandConfig;
+};
+//#endregion
+//#region src/slack/monitor/provider.d.ts
+declare function monitorSlackProvider(opts?: MonitorSlackOpts): Promise<void>;
+//#endregion
+//#region src/agents/tools/slack-actions.d.ts
+type SlackActionContext = {
+  /** Current channel ID for auto-threading. */currentChannelId?: string; /** Current thread timestamp for auto-threading. */
+  currentThreadTs?: string; /** Reply-to mode for auto-threading. */
+  replyToMode?: "off" | "first" | "all"; /** Mutable ref to track if a reply was sent (for "first" mode). */
+  hasRepliedRef?: {
+    value: boolean;
+  };
+};
+declare function handleSlackAction(params: Record<string, unknown>, cfg: FasedAgentConfig, context?: SlackActionContext): Promise<AgentToolResult<unknown>>;
+//#endregion
+//#region src/telegram/audit.d.ts
+type TelegramGroupMembershipAuditEntry = {
+  chatId: string;
+  ok: boolean;
+  status?: string | null;
+  error?: string | null;
+  matchKey?: string;
+  matchSource?: "id";
+};
+type TelegramGroupMembershipAudit = {
+  ok: boolean;
+  checkedGroups: number;
+  unresolvedGroups: number;
+  hasWildcardUnmentionedGroups: boolean;
+  groups: TelegramGroupMembershipAuditEntry[];
+  elapsedMs: number;
+};
+declare function collectTelegramUnmentionedGroupIds(groups: Record<string, TelegramGroupConfig> | undefined): {
+  groupIds: string[];
+  unresolvedGroups: number;
+  hasWildcardUnmentionedGroups: boolean;
+};
+declare function auditTelegramGroupMembership(params: {
+  token: string;
+  botId: number;
+  groupIds: string[];
+  proxyUrl?: string;
+  timeoutMs: number;
+}): Promise<TelegramGroupMembershipAudit>;
+//#endregion
+//#region src/telegram/probe.d.ts
+type TelegramProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs: number;
+  bot?: {
+    id?: number | null;
+    username?: string | null;
+    canJoinGroups?: boolean | null;
+    canReadAllGroupMessages?: boolean | null;
+    supportsInlineQueries?: boolean | null;
+  };
+  webhook?: {
+    url?: string | null;
+    hasCustomCert?: boolean | null;
+  };
+};
+declare function probeTelegram(token: string, timeoutMs: number, proxyUrl?: string): Promise<TelegramProbe>;
+//#endregion
+//#region src/telegram/token.d.ts
+type TelegramTokenSource = "env" | "tokenFile" | "config" | "none";
+type TelegramTokenResolution = BaseTokenResolution & {
+  source: TelegramTokenSource;
+};
+type ResolveTelegramTokenOpts = {
+  envToken?: string | null;
+  accountId?: string | null;
+  logMissingFile?: (message: string) => void;
+};
+declare function resolveTelegramToken(cfg?: FasedAgentConfig, opts?: ResolveTelegramTokenOpts): TelegramTokenResolution;
+//#endregion
+//#region src/telegram/monitor.d.ts
+type MonitorTelegramOpts = {
+  token?: string;
+  accountId?: string;
+  config?: FasedAgentConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  useWebhook?: boolean;
+  webhookPath?: string;
+  webhookPort?: number;
+  webhookSecret?: string;
+  webhookHost?: string;
+  proxyFetch?: typeof fetch;
+  webhookUrl?: string;
+};
+declare function monitorTelegramProvider(opts?: MonitorTelegramOpts): Promise<void>;
+//#endregion
+//#region src/channels/plugins/actions/telegram.d.ts
+declare const telegramMessageActions: ChannelMessageActionAdapter;
+//#endregion
+//#region src/signal/probe.d.ts
+type SignalProbe = BaseProbeResult & {
+  status?: number | null;
+  elapsedMs: number;
+  version?: string | null;
+};
+declare function probeSignal(baseUrl: string, timeoutMs: number): Promise<SignalProbe>;
+//#endregion
+//#region src/infra/backoff.d.ts
+type BackoffPolicy = {
+  initialMs: number;
+  maxMs: number;
+  factor: number;
+  jitter: number;
+};
+//#endregion
+//#region src/signal/monitor.d.ts
+type MonitorSignalOpts = {
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  account?: string;
+  accountId?: string;
+  config?: FasedAgentConfig;
+  baseUrl?: string;
+  autoStart?: boolean;
+  startupTimeoutMs?: number;
+  cliPath?: string;
+  httpHost?: string;
+  httpPort?: number;
+  receiveMode?: "on-start" | "manual";
+  ignoreAttachments?: boolean;
+  ignoreStories?: boolean;
+  sendReadReceipts?: boolean;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  mediaMaxMb?: number;
+  reconnectPolicy?: Partial<BackoffPolicy>;
+};
+declare function monitorSignalProvider(opts?: MonitorSignalOpts): Promise<void>;
+//#endregion
+//#region src/channels/plugins/actions/signal.d.ts
+declare const signalMessageActions: ChannelMessageActionAdapter;
+//#endregion
+//#region src/imessage/monitor/types.d.ts
+type MonitorIMessageOpts = {
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  cliPath?: string;
+  dbPath?: string;
+  accountId?: string;
+  config?: FasedAgentConfig;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  includeAttachments?: boolean;
+  mediaMaxMb?: number;
+  requireMention?: boolean;
+};
+//#endregion
+//#region src/imessage/monitor/monitor-provider.d.ts
+declare function monitorIMessageProvider(opts?: MonitorIMessageOpts): Promise<void>;
+//#endregion
+//#region src/imessage/probe.d.ts
+type IMessageProbe = BaseProbeResult & {
+  fatal?: boolean;
+};
+type IMessageProbeOptions = {
+  cliPath?: string;
+  dbPath?: string;
+  runtime?: RuntimeEnv;
+};
+/**
+ * Probe iMessage RPC availability.
+ * @param timeoutMs - Explicit timeout in ms. If undefined, uses config or default.
+ * @param opts - Additional options (cliPath, dbPath, runtime).
+ */
+declare function probeIMessage(timeoutMs?: number, opts?: IMessageProbeOptions): Promise<IMessageProbe>;
+//#endregion
+//#region src/web/active-listener.d.ts
+type ActiveWebSendOptions = {
+  gifPlayback?: boolean;
+  accountId?: string;
+  fileName?: string;
+  replyToId?: string;
+};
+type ActiveWebListener = {
+  sendMessage: (to: string, text: string, mediaBuffer?: Buffer, mediaType?: string, options?: ActiveWebSendOptions) => Promise<{
+    messageId: string;
+  }>;
+  sendPoll: (to: string, poll: PollInput) => Promise<{
+    messageId: string;
+  }>;
+  sendReaction: (chatJid: string, messageId: string, emoji: string, fromMe: boolean, participant?: string) => Promise<void>;
+  sendComposingTo: (to: string) => Promise<void>;
+  close?: () => Promise<void>;
+};
+declare function getActiveWebListener(accountId?: string | null): ActiveWebListener | null;
+//#endregion
+//#region src/web/session.d.ts
+declare function waitForWaConnection(sock: ReturnType<typeof makeWASocket>): Promise<void>;
+//#endregion
+//#region src/web/login.d.ts
+declare function loginWeb(verbose: boolean, waitForConnection?: typeof waitForWaConnection, runtime?: RuntimeEnv, accountId?: string): Promise<void>;
+//#endregion
+//#region src/web/login-qr.d.ts
+declare function startWebLoginWithQr(opts?: {
+  verbose?: boolean;
+  timeoutMs?: number;
+  force?: boolean;
+  accountId?: string;
+  runtime?: RuntimeEnv;
+}): Promise<{
+  qrDataUrl?: string;
+  message: string;
+}>;
+declare function waitForWebLogin(opts?: {
+  timeoutMs?: number;
+  runtime?: RuntimeEnv;
+  accountId?: string;
+}): Promise<{
+  connected: boolean;
+  message: string;
+}>;
+//#endregion
+//#region src/channels/location.d.ts
+type LocationSource = "pin" | "place" | "live";
+type NormalizedLocation = {
+  latitude: number;
+  longitude: number;
+  accuracy?: number;
+  name?: string;
+  address?: string;
+  isLive?: boolean;
+  source?: LocationSource;
+  caption?: string;
+};
+declare function formatLocationText(location: NormalizedLocation): string;
+declare function toLocationContext(location: NormalizedLocation): {
+  LocationLat: number;
+  LocationLon: number;
+  LocationAccuracy?: number;
+  LocationName?: string;
+  LocationAddress?: string;
+  LocationSource: LocationSource;
+  LocationIsLive: boolean;
+};
+//#endregion
+//#region src/web/inbound/types.d.ts
+type WebListenerCloseReason = {
+  status?: number;
+  isLoggedOut: boolean;
+  error?: unknown;
+};
+type WebInboundMessage = {
+  id?: string;
+  from: string;
+  conversationId: string;
+  to: string;
+  accountId: string;
+  body: string;
+  pushName?: string;
+  timestamp?: number;
+  chatType: "direct" | "group";
+  chatId: string;
+  senderJid?: string;
+  senderE164?: string;
+  senderName?: string;
+  replyToId?: string;
+  replyToBody?: string;
+  replyToSender?: string;
+  replyToSenderJid?: string;
+  replyToSenderE164?: string;
+  groupSubject?: string;
+  groupParticipants?: string[];
+  mentionedJids?: string[];
+  selfJid?: string | null;
+  selfE164?: string | null;
+  location?: NormalizedLocation;
+  sendComposing: () => Promise<void>;
+  reply: (text: string) => Promise<void>;
+  sendMedia: (payload: AnyMessageContent) => Promise<void>;
+  mediaPath?: string;
+  mediaType?: string;
+  mediaFileName?: string;
+  mediaUrl?: string;
+  wasMentioned?: boolean;
+};
+//#endregion
+//#region src/web/inbound/monitor.d.ts
+declare function monitorWebInbox(options: {
+  verbose: boolean;
+  accountId: string;
+  authDir: string;
+  onMessage: (msg: WebInboundMessage) => Promise<void>;
+  mediaMaxMb?: number; /** Send read receipts for incoming messages (default true). */
+  sendReadReceipts?: boolean; /** Debounce window (ms) for batching rapid consecutive messages from the same sender (0 to disable). */
+  debounceMs?: number; /** Optional debounce gating predicate. */
+  shouldDebounce?: (msg: WebInboundMessage) => boolean;
+}): Promise<{
+  readonly sendMessage: (to: string, text: string, mediaBuffer?: Buffer, mediaType?: string, sendOptions?: ActiveWebSendOptions) => Promise<{
+    messageId: string;
+  }>;
+  readonly sendPoll: (to: string, poll: {
+    question: string;
+    options: string[];
+    maxSelections?: number;
+  }) => Promise<{
+    messageId: string;
+  }>;
+  readonly sendReaction: (chatJid: string, messageId: string, emoji: string, fromMe: boolean, participant?: string) => Promise<void>;
+  readonly sendComposingTo: (to: string) => Promise<void>;
+  readonly close: () => Promise<void>;
+  readonly onClose: Promise<WebListenerCloseReason>;
+  readonly signalClose: (reason?: WebListenerCloseReason) => void;
+}>;
+//#endregion
+//#region src/web/reconnect.d.ts
+type ReconnectPolicy = BackoffPolicy & {
+  maxAttempts: number;
+};
+//#endregion
+//#region src/web/auto-reply/types.d.ts
+type WebChannelStatus = {
+  running: boolean;
+  connected: boolean;
+  reconnectAttempts: number;
+  lastConnectedAt?: number | null;
+  lastDisconnect?: {
+    at: number;
+    status?: number;
+    error?: string;
+    loggedOut?: boolean;
+  } | null;
+  lastMessageAt?: number | null;
+  lastEventAt?: number | null;
+  lastError?: string | null;
+};
+type WebMonitorTuning = {
+  reconnect?: Partial<ReconnectPolicy>;
+  heartbeatSeconds?: number;
+  messageTimeoutMs?: number;
+  watchdogCheckMs?: number;
+  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+  statusSink?: (status: WebChannelStatus) => void; /** WhatsApp account id. Default: "default". */
+  accountId?: string; /** Debounce window (ms) for batching rapid consecutive messages from the same sender. */
+  debounceMs?: number;
+};
+//#endregion
+//#region src/web/auto-reply/monitor.d.ts
+declare function monitorWebChannel(verbose: boolean, listenerFactory?: typeof monitorWebInbox | undefined, keepAlive?: boolean, replyResolver?: typeof getReplyFromConfig | undefined, runtime?: RuntimeEnv, abortSignal?: AbortSignal, tuning?: WebMonitorTuning): Promise<void>;
+//#endregion
+//#region src/agents/tools/whatsapp-actions.d.ts
+declare function handleWhatsAppAction(params: Record<string, unknown>, cfg: FasedAgentConfig): Promise<AgentToolResult<unknown>>;
+//#endregion
+//#region src/channels/plugins/agent-tools/whatsapp-login.d.ts
+declare function createWhatsAppLoginTool(): ChannelAgentTool;
+//#endregion
+//#region src/line/types.d.ts
+type LineTokenSource = "config" | "env" | "file" | "none";
+interface LineAccountBaseConfig {
+  enabled?: boolean;
+  channelAccessToken?: string;
+  channelSecret?: string;
+  tokenFile?: string;
+  secretFile?: string;
+  name?: string;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  /** Outbound response prefix override for this account. */
+  responsePrefix?: string;
+  mediaMaxMb?: number;
+  webhookPath?: string;
+  groups?: Record<string, LineGroupConfig>;
+}
+interface LineConfig extends LineAccountBaseConfig {
+  /** Per-account overrides keyed by account id. */
+  accounts?: Record<string, LineAccountConfig>;
+}
+interface LineAccountConfig extends LineAccountBaseConfig {}
+interface LineGroupConfig {
+  enabled?: boolean;
+  allowFrom?: Array<string | number>;
+  requireMention?: boolean;
+  systemPrompt?: string;
+  skills?: string[];
+}
+interface ResolvedLineAccount {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  channelAccessToken: string;
+  channelSecret: string;
+  tokenSource: LineTokenSource;
+  config: LineConfig & LineAccountConfig;
+}
+interface LineSendResult {
+  messageId: string;
+  chatId: string;
+}
+type LineProbeResult = BaseProbeResult<string> & {
+  bot?: {
+    displayName?: string;
+    userId?: string;
+    basicId?: string;
+    pictureUrl?: string;
+  };
+};
+type LineFlexMessagePayload = {
+  altText: string;
+  contents: unknown;
+};
+type LineTemplateMessagePayload = {
+  type: "confirm";
+  text: string;
+  confirmLabel: string;
+  confirmData: string;
+  cancelLabel: string;
+  cancelData: string;
+  altText?: string;
+} | {
+  type: "buttons";
+  title: string;
+  text: string;
+  actions: Array<{
+    type: "message" | "uri" | "postback";
+    label: string;
+    data?: string;
+    uri?: string;
+  }>;
+  thumbnailImageUrl?: string;
+  altText?: string;
+} | {
+  type: "carousel";
+  columns: Array<{
+    title?: string;
+    text: string;
+    thumbnailImageUrl?: string;
+    actions: Array<{
+      type: "message" | "uri" | "postback";
+      label: string;
+      data?: string;
+      uri?: string;
+    }>;
+  }>;
+  altText?: string;
+};
+type LineChannelData = {
+  quickReplies?: string[];
+  location?: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+  };
+  flexMessage?: LineFlexMessagePayload;
+  templateMessage?: LineTemplateMessagePayload;
+};
+//#endregion
+//#region src/line/accounts.d.ts
+declare function resolveLineAccount(params: {
+  cfg: FasedAgentConfig;
+  accountId?: string;
+}): ResolvedLineAccount;
+declare function listLineAccountIds(cfg: FasedAgentConfig): string[];
+declare function resolveDefaultLineAccountId(cfg: FasedAgentConfig): string;
+declare function normalizeAccountId(accountId: string | undefined): string;
+//#endregion
+//#region src/line/probe.d.ts
+declare function probeLineBot(channelAccessToken: string, timeoutMs?: number): Promise<LineProbeResult>;
+//#endregion
+//#region src/line/send.d.ts
+type Message = messagingApi.Message;
+type FlexContainer = messagingApi.FlexContainer;
+type TemplateMessage$1 = messagingApi.TemplateMessage;
+type QuickReply = messagingApi.QuickReply;
+interface LineSendOpts {
+  channelAccessToken?: string;
+  accountId?: string;
+  verbose?: boolean;
+  mediaUrl?: string;
+  replyToken?: string;
+}
+type LinePushOpts = Pick<LineSendOpts, "channelAccessToken" | "accountId" | "verbose">;
+declare function sendMessageLine(to: string, text: string, opts?: LineSendOpts): Promise<LineSendResult>;
+declare function pushMessageLine(to: string, text: string, opts?: LineSendOpts): Promise<LineSendResult>;
+declare function pushMessagesLine(to: string, messages: Message[], opts?: LinePushOpts): Promise<LineSendResult>;
+/**
+ * Push a location message to a user/group
+ */
+declare function pushLocationMessage(to: string, location: {
+  title: string;
+  address: string;
+  latitude: number;
+  longitude: number;
+}, opts?: LinePushOpts): Promise<LineSendResult>;
+/**
+ * Push a Flex Message to a user/group
+ */
+declare function pushFlexMessage(to: string, altText: string, contents: FlexContainer, opts?: LinePushOpts): Promise<LineSendResult>;
+/**
+ * Push a Template Message to a user/group
+ */
+declare function pushTemplateMessage(to: string, template: TemplateMessage$1, opts?: LinePushOpts): Promise<LineSendResult>;
+/**
+ * Push a text message with quick reply buttons
+ */
+declare function pushTextMessageWithQuickReplies(to: string, text: string, quickReplyLabels: string[], opts?: LinePushOpts): Promise<LineSendResult>;
+/**
+ * Create quick reply buttons to attach to a message
+ */
+declare function createQuickReplyItems(labels: string[]): QuickReply;
+//#endregion
+//#region src/line/template-messages.d.ts
+type TemplateMessage = messagingApi.TemplateMessage;
+/**
+ * Convert a TemplateMessagePayload from ReplyPayload to a LINE TemplateMessage
+ */
+declare function buildTemplateMessageFromPayload(payload: LineTemplateMessagePayload): TemplateMessage | null;
+//#endregion
+//#region src/line/monitor.d.ts
+interface MonitorLineProviderOptions {
+  channelAccessToken: string;
+  channelSecret: string;
+  accountId?: string;
+  config: FasedAgentConfig;
+  runtime: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  webhookUrl?: string;
+  webhookPath?: string;
+}
+interface LineProviderMonitor {
+  account: ResolvedLineAccount;
+  handleWebhook: (body: WebhookRequestBody) => Promise<void>;
+  stop: () => void;
+}
+declare function monitorLineProvider(opts: MonitorLineProviderOptions): Promise<LineProviderMonitor>;
+//#endregion
+//#region src/gateway/session-utils.types.d.ts
+type GatewaySessionsDefaults = {
+  modelProvider: string | null;
+  model: string | null;
+  contextTokens: number | null;
+};
+type GatewaySessionCompactionCheckpointSummary = {
+  checkpointId: string;
+  createdAt: number;
+  reason: SessionCompactionCheckpointReason;
+  tokensBefore?: number;
+  tokensAfter?: number;
+  summary?: string;
+};
+type GatewaySessionRow = {
+  key: string;
+  kind: "direct" | "group" | "global" | "unknown";
+  label?: string;
+  displayName?: string;
+  derivedTitle?: string;
+  lastMessagePreview?: string;
+  channel?: string;
+  subject?: string;
+  groupChannel?: string;
+  space?: string;
+  chatType?: ChatType;
+  origin?: SessionEntry["origin"];
+  updatedAt: number | null;
+  sessionId?: string;
+  systemSent?: boolean;
+  abortedLastRun?: boolean;
+  thinkingLevel?: string;
+  verboseLevel?: string;
+  reasoningLevel?: string;
+  elevatedLevel?: string;
+  sendPolicy?: "allow" | "deny";
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  totalTokensFresh?: boolean;
+  responseUsage?: "on" | "off" | "tokens" | "full";
+  modelProvider?: string;
+  model?: string;
+  skills?: {
+    count: number;
+    names: string[];
+    skillFilter?: string[];
+  };
+  contextTokens?: number;
+  compactionCheckpointCount?: number;
+  compactionCheckpoints?: GatewaySessionCompactionCheckpointSummary[];
+  deliveryContext?: DeliveryContext;
+  lastChannel?: SessionEntry["lastChannel"];
+  lastTo?: string;
+  lastAccountId?: string;
+  hasActiveRun?: boolean;
+  activeRunIds?: string[];
+};
+//#endregion
+//#region src/channels/dock.d.ts
+type ChannelDock = {
+  id: ChannelId;
+  capabilities: ChannelCapabilities;
+  commands?: ChannelCommandAdapter;
+  outbound?: {
+    textChunkLimit?: number;
+  };
+  streaming?: ChannelDockStreaming;
+  elevated?: ChannelElevatedAdapter;
+  config?: Pick<ChannelConfigAdapter<unknown>, "resolveAllowFrom" | "formatAllowFrom" | "resolveDefaultTo">;
+  groups?: ChannelGroupAdapter;
+  mentions?: ChannelMentionAdapter;
+  threading?: ChannelThreadingAdapter;
+  agentPrompt?: ChannelAgentPromptAdapter;
+};
+type ChannelDockStreaming = {
+  blockStreamingCoalesceDefaults?: {
+    minChars?: number;
+    idleMs?: number;
+  };
+};
+//#endregion
+//#region src/hooks/internal-hooks.d.ts
+type InternalHookEventType = "command" | "session" | "agent" | "gateway" | "message";
+interface InternalHookEvent {
+  /** The type of event (command, session, agent, gateway, etc.) */
+  type: InternalHookEventType;
+  /** The specific action within the type (e.g., 'new', 'reset', 'stop') */
+  action: string;
+  /** The session key this event relates to */
+  sessionKey: string;
+  /** Additional context specific to the event */
+  context: Record<string, unknown>;
+  /** Timestamp when the event occurred */
+  timestamp: Date;
+  /** Messages to send back to the user (hooks can push to this array) */
+  messages: string[];
+}
+type InternalHookHandler = (event: InternalHookEvent) => Promise<void> | void;
+//#endregion
+//#region src/hooks/types.d.ts
+type HookInstallSpec = {
+  id?: string;
+  kind: "bundled" | "npm" | "git";
+  label?: string;
+  package?: string;
+  repository?: string;
+  bins?: string[];
+};
+type FasedAgentHookMetadata = {
+  always?: boolean;
+  hookKey?: string;
+  emoji?: string;
+  homepage?: string; /** Events this hook handles (e.g., ["command:new", "session:start"]) */
+  events: string[]; /** Optional export name (default: "default") */
+  export?: string;
+  os?: string[];
+  requires?: {
+    bins?: string[];
+    anyBins?: string[];
+    env?: string[];
+    config?: string[];
+  };
+  install?: HookInstallSpec[];
+};
+type HookInvocationPolicy = {
+  enabled: boolean;
+};
+type ParsedHookFrontmatter = Record<string, string>;
+type Hook = {
+  name: string;
+  description: string;
+  source: "fased-bundled" | "fased-managed" | "fased-workspace" | "fased-plugin";
+  pluginId?: string;
+  filePath: string;
+  baseDir: string;
+  handlerPath: string;
+};
+type HookEntry = {
+  hook: Hook;
+  frontmatter: ParsedHookFrontmatter;
+  metadata?: FasedAgentHookMetadata;
+  invocation?: HookInvocationPolicy;
+};
+//#endregion
+//#region src/commands/oauth-flow.d.ts
+type OAuthPrompt = {
+  message: string;
+  placeholder?: string;
+};
+declare function createVpsAwareOAuthHandlers(params: {
+  isRemote: boolean;
+  prompter: WizardPrompter;
+  runtime: RuntimeEnv;
+  spin: ReturnType<WizardPrompter["progress"]>;
+  openUrl: (url: string) => Promise<unknown>;
+  localBrowserMessage: string;
+  manualPromptMessage?: string;
+}): {
+  onAuth: (event: {
+    url: string;
+  }) => Promise<void>;
+  onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+};
+//#endregion
+//#region src/image-generation/types.d.ts
+type GeneratedImageAsset = {
+  buffer: Buffer;
+  mimeType: string;
+  fileName?: string;
+  revisedPrompt?: string;
+  metadata?: Record<string, unknown>;
+};
+type ImageGenerationResolution = "1K" | "2K" | "4K";
+type ImageGenerationSourceImage = {
+  buffer: Buffer;
+  mimeType: string;
+  fileName?: string;
+  metadata?: Record<string, unknown>;
+};
+type ImageGenerationProviderConfiguredContext = {
+  cfg?: FasedAgentConfig;
+  agentDir?: string;
+};
+type ImageGenerationRequest = {
+  provider: string;
+  model: string;
+  prompt: string;
+  cfg: FasedAgentConfig;
+  agentDir?: string;
+  authStore?: AuthProfileStore;
+  timeoutMs?: number;
+  count?: number;
+  size?: string;
+  aspectRatio?: string;
+  resolution?: ImageGenerationResolution;
+  inputImages?: ImageGenerationSourceImage[];
+};
+type ImageGenerationResult = {
+  images: GeneratedImageAsset[];
+  model?: string;
+  metadata?: Record<string, unknown>;
+};
+type ImageGenerationModeCapabilities = {
+  maxCount?: number;
+  supportsSize?: boolean;
+  supportsAspectRatio?: boolean;
+  supportsResolution?: boolean;
+};
+type ImageGenerationEditCapabilities = ImageGenerationModeCapabilities & {
+  enabled: boolean;
+  maxInputImages?: number;
+};
+type ImageGenerationGeometryCapabilities = {
+  sizes?: string[];
+  aspectRatios?: string[];
+  resolutions?: ImageGenerationResolution[];
+};
+type ImageGenerationProviderCapabilities = {
+  generate: ImageGenerationModeCapabilities;
+  edit: ImageGenerationEditCapabilities;
+  geometry?: ImageGenerationGeometryCapabilities;
+};
+type ImageGenerationProvider = {
+  id: string;
+  aliases?: string[];
+  label?: string;
+  defaultModel?: string;
+  models?: string[];
+  capabilities: ImageGenerationProviderCapabilities;
+  isConfigured?: (ctx: ImageGenerationProviderConfiguredContext) => boolean;
+  generateImage: (req: ImageGenerationRequest) => Promise<ImageGenerationResult>;
+};
+//#endregion
+//#region src/realtime-transcription/provider-types.d.ts
+type RealtimeTranscriptionProviderId = string;
+type RealtimeTranscriptionProviderConfig = Record<string, unknown>;
+type RealtimeTranscriptionProviderResolveConfigContext = {
+  cfg: FasedAgentConfig;
+  rawConfig: RealtimeTranscriptionProviderConfig;
+};
+type RealtimeTranscriptionProviderConfiguredContext = {
+  cfg?: FasedAgentConfig;
+  providerConfig: RealtimeTranscriptionProviderConfig;
+};
+type RealtimeTranscriptionSessionCallbacks = {
+  onPartial?: (partial: string) => void;
+  onTranscript?: (transcript: string) => void;
+  onSpeechStart?: () => void;
+  onError?: (error: Error) => void;
+};
+type RealtimeTranscriptionSessionCreateRequest = RealtimeTranscriptionSessionCallbacks & {
+  providerConfig: RealtimeTranscriptionProviderConfig;
+};
+type RealtimeTranscriptionSession = {
+  connect(): Promise<void>;
+  sendAudio(audio: Buffer): void;
+  close(): void;
+  isConnected(): boolean;
+};
+//#endregion
+//#region src/realtime-voice/provider-types.d.ts
+type RealtimeVoiceProviderId = string;
+type RealtimeVoiceRole = "user" | "assistant";
+type RealtimeVoiceCloseReason = "completed" | "error";
+type RealtimeVoiceTool = {
+  type: "function";
+  name: string;
+  description: string;
+  parameters: {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+};
+type RealtimeVoiceToolCallEvent = {
+  itemId: string;
+  callId: string;
+  name: string;
+  args: unknown;
+};
+type RealtimeVoiceBridgeCallbacks = {
+  onAudio: (muLaw: Buffer) => void;
+  onClearAudio: () => void;
+  onMark?: (markName: string) => void;
+  onTranscript?: (role: RealtimeVoiceRole, text: string, isFinal: boolean) => void;
+  onToolCall?: (event: RealtimeVoiceToolCallEvent) => void;
+  onReady?: () => void;
+  onError?: (error: Error) => void;
+  onClose?: (reason: RealtimeVoiceCloseReason) => void;
+};
+type RealtimeVoiceProviderConfig = Record<string, unknown>;
+type RealtimeVoiceProviderResolveConfigContext = {
+  cfg: FasedAgentConfig;
+  rawConfig: RealtimeVoiceProviderConfig;
+};
+type RealtimeVoiceProviderConfiguredContext = {
+  cfg?: FasedAgentConfig;
+  providerConfig: RealtimeVoiceProviderConfig;
+};
+type RealtimeVoiceBridgeCreateRequest = RealtimeVoiceBridgeCallbacks & {
+  providerConfig: RealtimeVoiceProviderConfig;
+  instructions?: string;
+  tools?: RealtimeVoiceTool[];
+};
+type RealtimeVoiceBridge = {
+  connect(): Promise<void>;
+  sendAudio(audio: Buffer): void;
+  setMediaTimestamp(ts: number): void;
+  sendUserMessage?(text: string): void;
+  triggerGreeting?(instructions?: string): void;
+  submitToolResult(callId: string, result: unknown): void;
+  acknowledgeMark(): void;
+  close(): void;
+  isConnected(): boolean;
+};
+//#endregion
+//#region src/secrets/runtime-web-tools.types.d.ts
+type RuntimeWebDiagnosticCode = "WEB_SEARCH_PROVIDER_INVALID_AUTODETECT" | "WEB_SEARCH_AUTODETECT_SELECTED" | "WEB_SEARCH_KEY_UNRESOLVED_FALLBACK_USED" | "WEB_SEARCH_KEY_UNRESOLVED_NO_FALLBACK" | "WEB_FETCH_PROVIDER_INVALID_AUTODETECT" | "WEB_FETCH_AUTODETECT_SELECTED" | "WEB_FETCH_PROVIDER_KEY_UNRESOLVED_FALLBACK_USED" | "WEB_FETCH_PROVIDER_KEY_UNRESOLVED_NO_FALLBACK";
+type RuntimeWebDiagnostic = {
+  code: RuntimeWebDiagnosticCode;
+  message: string;
+  path?: string;
+};
+type RuntimeWebSearchMetadata = {
+  providerConfigured?: string;
+  providerSource: "configured" | "auto-detect" | "none";
+  selectedProvider?: string;
+  selectedProviderKeySource?: "config" | "secretRef" | "env" | "missing";
+  perplexityTransport?: "search_api" | "chat_completions";
+  diagnostics: RuntimeWebDiagnostic[];
+};
+//#endregion
+//#region src/video-generation/types.d.ts
+type GeneratedVideoAsset = {
+  buffer: Buffer;
+  mimeType: string;
+  fileName?: string;
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationResolution = "480P" | "720P" | "768P" | "1080P";
+type VideoGenerationSourceAsset = {
+  url?: string;
+  buffer?: Buffer;
+  mimeType?: string;
+  fileName?: string;
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationProviderConfiguredContext = {
+  cfg?: FasedAgentConfig;
+  agentDir?: string;
+};
+type VideoGenerationRequest = {
+  provider: string;
+  model: string;
+  prompt: string;
+  cfg: FasedAgentConfig;
+  agentDir?: string;
+  authStore?: AuthProfileStore;
+  timeoutMs?: number;
+  size?: string;
+  aspectRatio?: string;
+  resolution?: VideoGenerationResolution;
+  durationSeconds?: number;
+  audio?: boolean;
+  watermark?: boolean;
+  inputImages?: VideoGenerationSourceAsset[];
+  inputVideos?: VideoGenerationSourceAsset[];
+};
+type VideoGenerationResult = {
+  videos: GeneratedVideoAsset[];
+  model?: string;
+  metadata?: Record<string, unknown>;
+};
+type VideoGenerationIgnoredOverrideKey = "size" | "aspectRatio" | "resolution" | "audio" | "watermark";
+type VideoGenerationIgnoredOverride = {
+  key: VideoGenerationIgnoredOverrideKey;
+  value: string | boolean;
+};
+type VideoGenerationMode = "generate" | "imageToVideo" | "videoToVideo";
+type VideoGenerationModeCapabilities = {
+  maxVideos?: number;
+  maxInputImages?: number;
+  maxInputVideos?: number;
+  maxDurationSeconds?: number;
+  supportedDurationSeconds?: readonly number[];
+  supportedDurationSecondsByModel?: Readonly<Record<string, readonly number[]>>;
+  supportsSize?: boolean;
+  supportsAspectRatio?: boolean;
+  supportsResolution?: boolean;
+  supportsAudio?: boolean;
+  supportsWatermark?: boolean;
+};
+type VideoGenerationTransformCapabilities = VideoGenerationModeCapabilities & {
+  enabled: boolean;
+};
+type VideoGenerationProviderCapabilities = VideoGenerationModeCapabilities & {
+  generate?: VideoGenerationModeCapabilities;
+  imageToVideo?: VideoGenerationTransformCapabilities;
+  videoToVideo?: VideoGenerationTransformCapabilities;
+};
+type VideoGenerationProvider = {
+  id: string;
+  aliases?: string[];
+  label?: string;
+  defaultModel?: string;
+  models?: string[];
+  capabilities: VideoGenerationProviderCapabilities;
+  isConfigured?: (ctx: VideoGenerationProviderConfiguredContext) => boolean;
+  generateVideo: (req: VideoGenerationRequest) => Promise<VideoGenerationResult>;
+};
+//#endregion
+//#region src/plugins/types.d.ts
+type PluginLogger = {
+  debug?: (message: string) => void;
+  info: (message: string) => void;
+  warn: (message: string) => void;
+  error: (message: string) => void;
+};
+type PluginConfigUiHint = {
+  label?: string;
+  help?: string;
+  tags?: string[];
+  advanced?: boolean;
+  sensitive?: boolean;
+  placeholder?: string;
+};
+type PluginKind = "memory";
+type PluginConfigValidation = {
+  ok: true;
+  value?: unknown;
+} | {
+  ok: false;
+  errors: string[];
+};
+type FasedAgentPluginConfigSchema = {
+  safeParse?: (value: unknown) => {
+    success: boolean;
+    data?: unknown;
+    error?: {
+      issues?: Array<{
+        path: Array<string | number>;
+        message: string;
+      }>;
+    };
+  };
+  parse?: (value: unknown) => unknown;
+  validate?: (value: unknown) => PluginConfigValidation;
+  uiHints?: Record<string, PluginConfigUiHint>;
+  jsonSchema?: Record<string, unknown>;
+};
+type FasedAgentPluginToolContext = {
+  config?: FasedAgentConfig;
+  workspaceDir?: string;
+  agentDir?: string;
+  agentId?: string;
+  sessionKey?: string;
+  messageChannel?: string;
+  agentAccountId?: string;
+  sandboxed?: boolean;
+};
+type FasedAgentPluginToolFactory = (ctx: FasedAgentPluginToolContext) => AnyAgentTool | AnyAgentTool[] | null | undefined;
+type FasedAgentPluginToolOptions = {
+  name?: string;
+  names?: string[];
+  optional?: boolean;
+};
+type FasedAgentPluginHookOptions = {
+  entry?: HookEntry;
+  name?: string;
+  description?: string;
+  register?: boolean;
+};
+type ProviderAuthKind = "oauth" | "api_key" | "token" | "device_code" | "custom";
+type ProviderAuthResult = {
+  profiles: Array<{
+    profileId: string;
+    credential: AuthProfileCredential;
+  }>;
+  configPatch?: Partial<FasedAgentConfig>;
+  defaultModel?: string;
+  notes?: string[];
+};
+type ProviderAuthContext = {
+  config: FasedAgentConfig;
+  agentDir?: string;
+  workspaceDir?: string;
+  prompter: WizardPrompter;
+  runtime: RuntimeEnv;
+  isRemote: boolean;
+  openUrl: (url: string) => Promise<void>;
+  oauth: {
+    createVpsAwareHandlers: typeof createVpsAwareOAuthHandlers;
+  };
+};
+type ProviderAuthMethod = {
+  id: string;
+  label: string;
+  hint?: string;
+  kind: ProviderAuthKind;
+  wizard?: ProviderPluginWizardSetup;
+  run: (ctx: ProviderAuthContext) => Promise<ProviderAuthResult>;
+};
+type ProviderPluginWizardSetup = {
+  choiceId?: string;
+  choiceLabel?: string;
+  choiceHint?: string;
+  assistantPriority?: number;
+  assistantVisibility?: "visible" | "manual-only";
+  deprecatedChoiceIds?: string[];
+  groupId?: string;
+  groupLabel?: string;
+  groupHint?: string;
+  optionKey?: string;
+  cliFlag?: string;
+  cliOption?: string;
+  cliDescription?: string;
+  onboardingScopes?: Array<"text-inference" | "image-generation">;
+};
+type ProviderPluginWizardModelPicker = {
+  label?: string;
+  hint?: string;
+  methodId?: string;
+};
+type ProviderPluginWizard = {
+  setup?: ProviderPluginWizardSetup;
+  modelPicker?: ProviderPluginWizardModelPicker;
+};
+type ProviderCatalogOrder = "simple" | "profile" | "paired" | "late";
+type ProviderCatalogContext = {
+  config: FasedAgentConfig;
+  agentDir?: string;
+  workspaceDir?: string;
+  env: NodeJS.ProcessEnv;
+  resolveProviderApiKey: (providerId?: string) => {
+    apiKey: string | undefined;
+    discoveryApiKey?: string;
+  };
+  resolveProviderAuth: (providerId?: string, options?: {
+    oauthMarker?: string;
+  }) => {
+    apiKey: string | undefined;
+    discoveryApiKey?: string;
+    mode: "api_key" | "oauth" | "token" | "none";
+    source: "env" | "profile" | "none";
+    profileId?: string;
+  };
+};
+type ProviderCatalogResult = {
+  provider: ModelProviderConfig;
+} | {
+  providers: Record<string, ModelProviderConfig>;
+} | null | undefined;
+type ProviderPluginCatalog = {
+  order?: ProviderCatalogOrder;
+  run: (ctx: ProviderCatalogContext) => Promise<ProviderCatalogResult>;
+};
+/**
+ * @deprecated Use ProviderPluginCatalog.
+ */
+type ProviderPluginDiscovery = ProviderPluginCatalog;
+type ProviderPlugin = {
+  id: string;
+  label: string;
+  docsPath?: string;
+  aliases?: string[];
+  envVars?: string[];
+  models?: ModelProviderConfig;
+  auth: ProviderAuthMethod[];
+  catalog?: ProviderPluginCatalog;
+  staticCatalog?: ProviderPluginCatalog;
+  discovery?: ProviderPluginDiscovery;
+  wizard?: ProviderPluginWizard;
+  formatApiKey?: (cred: AuthProfileCredential) => string;
+  refreshOAuth?: (cred: OAuthCredential) => Promise<OAuthCredential>;
+};
+type ImageGenerationProviderPlugin = ImageGenerationProvider;
+type VideoGenerationProviderPlugin = VideoGenerationProvider;
+type RealtimeTranscriptionProviderPlugin = {
+  id: RealtimeTranscriptionProviderId;
+  label: string;
+  aliases?: string[];
+  autoSelectOrder?: number;
+  resolveConfig?: (ctx: RealtimeTranscriptionProviderResolveConfigContext) => RealtimeTranscriptionProviderConfig;
+  isConfigured: (ctx: RealtimeTranscriptionProviderConfiguredContext) => boolean;
+  createSession: (req: RealtimeTranscriptionSessionCreateRequest) => RealtimeTranscriptionSession;
+};
+type RealtimeVoiceProviderPlugin = {
+  id: RealtimeVoiceProviderId;
+  label: string;
+  aliases?: string[];
+  autoSelectOrder?: number;
+  resolveConfig?: (ctx: RealtimeVoiceProviderResolveConfigContext) => RealtimeVoiceProviderConfig;
+  isConfigured: (ctx: RealtimeVoiceProviderConfiguredContext) => boolean;
+  createBridge: (req: RealtimeVoiceBridgeCreateRequest) => RealtimeVoiceBridge;
+};
+type WebSearchProviderToolDefinition = {
+  description: string;
+  parameters: Record<string, unknown>;
+  execute: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+type PluginWebSearchProviderEntry = {
+  pluginId: string;
+  id: string;
+  label: string;
+  hint?: string;
+  inactiveSecretPaths?: string[];
+  envVars: string[];
+  placeholder?: string;
+  signupUrl?: string;
+  credentialPath: string;
+  autoDetectOrder?: number;
+  requiresCredential?: boolean;
+  getCredentialValue?: (searchConfig?: Record<string, unknown>) => unknown;
+  setCredentialValue?: (value: string, searchConfig?: Record<string, unknown>) => void;
+  getConfiguredCredentialValue?: (config?: FasedAgentConfig) => unknown;
+  setConfiguredCredentialValue?: (configTarget: FasedAgentConfig, value: unknown) => void;
+  applySelectionConfig?: (config: FasedAgentConfig) => FasedAgentConfig;
+  createTool: (params: {
+    config?: FasedAgentConfig;
+    searchConfig?: Record<string, unknown>;
+    runtimeMetadata?: RuntimeWebSearchMetadata;
+  }) => WebSearchProviderToolDefinition | null;
+};
+type WebSearchProviderPlugin = Omit<PluginWebSearchProviderEntry, "pluginId">;
+/**
+ * Context passed to plugin command handlers.
+ */
+type PluginCommandContext = {
+  /** The sender's identifier (e.g., Telegram user ID) */senderId?: string; /** The channel/surface (e.g., "telegram", "discord") */
+  channel: string; /** Provider channel id (e.g., "telegram") */
+  channelId?: ChannelId; /** Whether the sender is on the allowlist */
+  isAuthorizedSender: boolean; /** Raw command arguments after the command name */
+  args?: string; /** The full normalized command body */
+  commandBody: string; /** Current FasedAgent configuration */
+  config: FasedAgentConfig; /** Raw "From" value (channel-scoped id) */
+  from?: string; /** Raw "To" value (channel-scoped id) */
+  to?: string; /** Account id for multi-account channels */
+  accountId?: string; /** Thread/topic id if available */
+  messageThreadId?: number;
+};
+/**
+ * Result returned by a plugin command handler.
+ */
+type PluginCommandResult = ReplyPayload;
+/**
+ * Handler function for plugin commands.
+ */
+type PluginCommandHandler = (ctx: PluginCommandContext) => PluginCommandResult | Promise<PluginCommandResult>;
+/**
+ * Definition for a plugin-registered command.
+ */
+type FasedAgentPluginCommandDefinition = {
+  /** Command name without leading slash (e.g., "tts") */name: string; /** Description shown in /help and command menus */
+  description: string; /** Whether this command accepts arguments */
+  acceptsArgs?: boolean; /** Whether only authorized senders can use this command (default: true) */
+  requireAuth?: boolean; /** The handler function */
+  handler: PluginCommandHandler;
+};
+type FasedAgentPluginHttpHandler = (req: IncomingMessage, res: ServerResponse) => Promise<boolean> | boolean;
+type FasedAgentPluginHttpRouteHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void> | void;
+type FasedAgentPluginCliContext = {
+  program: Command;
+  config: FasedAgentConfig;
+  workspaceDir?: string;
+  logger: PluginLogger;
+};
+type FasedAgentPluginCliRegistrar = (ctx: FasedAgentPluginCliContext) => void | Promise<void>;
+type FasedAgentPluginServiceContext = {
+  config: FasedAgentConfig;
+  workspaceDir?: string;
+  stateDir: string;
+  logger: PluginLogger;
+};
+type FasedAgentPluginService = {
+  id: string;
+  start: (ctx: FasedAgentPluginServiceContext) => void | Promise<void>;
+  stop?: (ctx: FasedAgentPluginServiceContext) => void | Promise<void>;
+};
+type FasedAgentPluginChannelRegistration = {
+  plugin: ChannelPlugin;
+  dock?: ChannelDock;
+};
+type FasedAgentPluginApi = {
+  id: string;
+  name: string;
+  version?: string;
+  description?: string;
+  source: string;
+  config: FasedAgentConfig;
+  pluginConfig?: Record<string, unknown>;
+  runtime: PluginRuntime;
+  logger: PluginLogger;
+  registerTool: (tool: AnyAgentTool | FasedAgentPluginToolFactory, opts?: FasedAgentPluginToolOptions) => void;
+  registerHook: (events: string | string[], handler: InternalHookHandler, opts?: FasedAgentPluginHookOptions) => void;
+  registerHttpHandler: (handler: FasedAgentPluginHttpHandler) => void;
+  registerHttpRoute: (params: {
+    path: string;
+    handler: FasedAgentPluginHttpRouteHandler;
+  }) => void;
+  registerChannel: (registration: FasedAgentPluginChannelRegistration | ChannelPlugin) => void;
+  registerGatewayMethod: (method: string, handler: GatewayRequestHandler, opts?: {
+    scope?: OperatorScope;
+  }) => void;
+  registerCli: (registrar: FasedAgentPluginCliRegistrar, opts?: {
+    commands?: string[];
+  }) => void;
+  registerService: (service: FasedAgentPluginService) => void;
+  registerProvider: (provider: ProviderPlugin) => void;
+  registerWebSearchProvider: (provider: WebSearchProviderPlugin) => void;
+  registerImageGenerationProvider: (provider: ImageGenerationProviderPlugin) => void;
+  registerVideoGenerationProvider: (provider: VideoGenerationProviderPlugin) => void;
+  registerRealtimeTranscriptionProvider: (provider: RealtimeTranscriptionProviderPlugin) => void;
+  registerRealtimeVoiceProvider: (provider: RealtimeVoiceProviderPlugin) => void;
+  /**
+   * Register a custom command that bypasses the LLM agent.
+   * Plugin commands are processed before built-in commands and before agent invocation.
+   * Use this for simple state-toggling or status commands that don't need AI reasoning.
+   */
+  registerCommand: (command: FasedAgentPluginCommandDefinition) => void;
+  resolvePath: (input: string) => string; /** Register a lifecycle hook handler */
+  on: <K extends PluginHookName>(hookName: K, handler: PluginHookHandlerMap[K], opts?: {
+    priority?: number;
+  }) => void;
+};
+type PluginOrigin = "bundled" | "global" | "workspace" | "config";
+type PluginDiagnostic = {
+  level: "warn" | "error";
+  message: string;
+  pluginId?: string;
+  source?: string;
+};
+type PluginHookName = "before_model_resolve" | "before_prompt_build" | "before_agent_start" | "llm_input" | "llm_output" | "agent_end" | "before_compaction" | "after_compaction" | "before_reset" | "message_received" | "message_sending" | "message_sent" | "before_tool_call" | "after_tool_call" | "tool_result_persist" | "before_message_write" | "session_start" | "session_end" | "subagent_spawning" | "subagent_delivery_target" | "subagent_spawned" | "subagent_ended" | "gateway_start" | "gateway_stop";
+type PluginHookAgentContext = {
+  agentId?: string;
+  sessionKey?: string;
+  sessionId?: string;
+  workspaceDir?: string;
+  messageProvider?: string;
+};
+type PluginHookBeforeModelResolveEvent = {
+  /** User prompt for this run. No session messages are available yet in this phase. */prompt: string;
+};
+type PluginHookBeforeModelResolveResult = {
+  /** Override the model for this agent run. E.g. "llama3.3:8b" */modelOverride?: string; /** Override the provider for this agent run. E.g. "openrouter" */
+  providerOverride?: string;
+};
+type PluginHookBeforePromptBuildEvent = {
+  prompt: string; /** Session messages prepared for this run. */
+  messages: unknown[];
+};
+type PluginHookBeforePromptBuildResult = {
+  systemPrompt?: string;
+  prependContext?: string;
+};
+type PluginHookBeforeAgentStartEvent = {
+  prompt: string; /** Optional because legacy hook can run in pre-session phase. */
+  messages?: unknown[];
+};
+type PluginHookBeforeAgentStartResult = PluginHookBeforePromptBuildResult & PluginHookBeforeModelResolveResult;
+type PluginHookLlmInputEvent = {
+  runId: string;
+  sessionId: string;
+  provider: string;
+  model: string;
+  systemPrompt?: string;
+  prompt: string;
+  historyMessages: unknown[];
+  imagesCount: number;
+};
+type PluginHookLlmOutputEvent = {
+  runId: string;
+  sessionId: string;
+  provider: string;
+  model: string;
+  assistantTexts: string[];
+  lastAssistant?: unknown;
+  usage?: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+  };
+};
+type PluginHookAgentEndEvent = {
+  messages: unknown[];
+  success: boolean;
+  error?: string;
+  durationMs?: number;
+};
+type PluginHookBeforeCompactionEvent = {
+  /** Total messages in the session before any truncation or compaction */messageCount: number; /** Messages being fed to the compaction LLM (after history-limit truncation) */
+  compactingCount?: number;
+  tokenCount?: number;
+  messages?: unknown[];
+  /** Path to the session JSONL transcript. All messages are already on disk
+   *  before compaction starts, so plugins can read this file asynchronously
+   *  and process in parallel with the compaction LLM call. */
+  sessionFile?: string;
+};
+type PluginHookBeforeResetEvent = {
+  sessionFile?: string;
+  messages?: unknown[];
+  reason?: string;
+};
+type PluginHookAfterCompactionEvent = {
+  messageCount: number;
+  tokenCount?: number;
+  compactedCount: number;
+  /** Path to the session JSONL transcript. All pre-compaction messages are
+   *  preserved on disk, so plugins can read and process them asynchronously
+   *  without blocking the compaction pipeline. */
+  sessionFile?: string;
+};
+type PluginHookMessageContext = {
+  channelId: string;
+  accountId?: string;
+  conversationId?: string;
+};
+type PluginHookMessageReceivedEvent = {
+  from: string;
+  content: string;
+  timestamp?: number;
+  metadata?: Record<string, unknown>;
+};
+type PluginHookMessageSendingEvent = {
+  to: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+};
+type PluginHookMessageSendingResult = {
+  content?: string;
+  cancel?: boolean;
+};
+type PluginHookMessageSentEvent = {
+  to: string;
+  content: string;
+  success: boolean;
+  error?: string;
+};
+type PluginHookToolContext = {
+  agentId?: string;
+  sessionKey?: string;
+  toolName: string;
+};
+type PluginHookBeforeToolCallEvent = {
+  toolName: string;
+  params: Record<string, unknown>;
+};
+type PluginHookBeforeToolCallResult = {
+  params?: Record<string, unknown>;
+  block?: boolean;
+  blockReason?: string;
+};
+type PluginHookAfterToolCallEvent = {
+  toolName: string;
+  params: Record<string, unknown>;
+  result?: unknown;
+  error?: string;
+  durationMs?: number;
+};
+type PluginHookToolResultPersistContext = {
+  agentId?: string;
+  sessionKey?: string;
+  toolName?: string;
+  toolCallId?: string;
+};
+type PluginHookToolResultPersistEvent = {
+  toolName?: string;
+  toolCallId?: string;
+  /**
+   * The toolResult message about to be written to the session transcript.
+   * Handlers may return a modified message (e.g. drop non-essential fields).
+   */
+  message: AgentMessage; /** True when the tool result was synthesized by a guard/repair step. */
+  isSynthetic?: boolean;
+};
+type PluginHookToolResultPersistResult = {
+  message?: AgentMessage;
+};
+type PluginHookBeforeMessageWriteEvent = {
+  message: AgentMessage;
+  sessionKey?: string;
+  agentId?: string;
+};
+type PluginHookBeforeMessageWriteResult = {
+  block?: boolean;
+  message?: AgentMessage;
+};
+type PluginHookSessionContext = {
+  agentId?: string;
+  sessionId: string;
+};
+type PluginHookSessionStartEvent = {
+  sessionId: string;
+  resumedFrom?: string;
+};
+type PluginHookSessionEndEvent = {
+  sessionId: string;
+  messageCount: number;
+  durationMs?: number;
+};
+type PluginHookSubagentContext = {
+  runId?: string;
+  childSessionKey?: string;
+  requesterSessionKey?: string;
+};
+type PluginHookSubagentTargetKind = "subagent" | "acp";
+type PluginHookSubagentSpawningEvent = {
+  childSessionKey: string;
+  agentId: string;
+  label?: string;
+  mode: "run" | "session";
+  requester?: {
+    channel?: string;
+    accountId?: string;
+    to?: string;
+    threadId?: string | number;
+  };
+  threadRequested: boolean;
+};
+type PluginHookSubagentSpawningResult = {
+  status: "ok";
+  threadBindingReady?: boolean;
+} | {
+  status: "error";
+  error: string;
+};
+type PluginHookSubagentDeliveryTargetEvent = {
+  childSessionKey: string;
+  requesterSessionKey: string;
+  requesterOrigin?: {
+    channel?: string;
+    accountId?: string;
+    to?: string;
+    threadId?: string | number;
+  };
+  childRunId?: string;
+  spawnMode?: "run" | "session";
+  expectsCompletionMessage: boolean;
+};
+type PluginHookSubagentDeliveryTargetResult = {
+  origin?: {
+    channel?: string;
+    accountId?: string;
+    to?: string;
+    threadId?: string | number;
+  };
+};
+type PluginHookSubagentSpawnedEvent = {
+  runId: string;
+  childSessionKey: string;
+  agentId: string;
+  label?: string;
+  mode: "run" | "session";
+  requester?: {
+    channel?: string;
+    accountId?: string;
+    to?: string;
+    threadId?: string | number;
+  };
+  threadRequested: boolean;
+};
+type PluginHookSubagentEndedEvent = {
+  targetSessionKey: string;
+  targetKind: PluginHookSubagentTargetKind;
+  reason: string;
+  sendFarewell?: boolean;
+  accountId?: string;
+  runId?: string;
+  endedAt?: number;
+  outcome?: "ok" | "error" | "timeout" | "killed" | "reset" | "deleted";
+  error?: string;
+};
+type PluginHookGatewayContext = {
+  port?: number;
+};
+type PluginHookGatewayStartEvent = {
+  port: number;
+};
+type PluginHookGatewayStopEvent = {
+  reason?: string;
+};
+type PluginHookHandlerMap = {
+  before_model_resolve: (event: PluginHookBeforeModelResolveEvent, ctx: PluginHookAgentContext) => Promise<PluginHookBeforeModelResolveResult | void> | PluginHookBeforeModelResolveResult | void;
+  before_prompt_build: (event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext) => Promise<PluginHookBeforePromptBuildResult | void> | PluginHookBeforePromptBuildResult | void;
+  before_agent_start: (event: PluginHookBeforeAgentStartEvent, ctx: PluginHookAgentContext) => Promise<PluginHookBeforeAgentStartResult | void> | PluginHookBeforeAgentStartResult | void;
+  llm_input: (event: PluginHookLlmInputEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  llm_output: (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  agent_end: (event: PluginHookAgentEndEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  before_compaction: (event: PluginHookBeforeCompactionEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  after_compaction: (event: PluginHookAfterCompactionEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  before_reset: (event: PluginHookBeforeResetEvent, ctx: PluginHookAgentContext) => Promise<void> | void;
+  message_received: (event: PluginHookMessageReceivedEvent, ctx: PluginHookMessageContext) => Promise<void> | void;
+  message_sending: (event: PluginHookMessageSendingEvent, ctx: PluginHookMessageContext) => Promise<PluginHookMessageSendingResult | void> | PluginHookMessageSendingResult | void;
+  message_sent: (event: PluginHookMessageSentEvent, ctx: PluginHookMessageContext) => Promise<void> | void;
+  before_tool_call: (event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext) => Promise<PluginHookBeforeToolCallResult | void> | PluginHookBeforeToolCallResult | void;
+  after_tool_call: (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext) => Promise<void> | void;
+  tool_result_persist: (event: PluginHookToolResultPersistEvent, ctx: PluginHookToolResultPersistContext) => PluginHookToolResultPersistResult | void;
+  before_message_write: (event: PluginHookBeforeMessageWriteEvent, ctx: {
+    agentId?: string;
+    sessionKey?: string;
+  }) => PluginHookBeforeMessageWriteResult | void;
+  session_start: (event: PluginHookSessionStartEvent, ctx: PluginHookSessionContext) => Promise<void> | void;
+  session_end: (event: PluginHookSessionEndEvent, ctx: PluginHookSessionContext) => Promise<void> | void;
+  subagent_spawning: (event: PluginHookSubagentSpawningEvent, ctx: PluginHookSubagentContext) => Promise<PluginHookSubagentSpawningResult | void> | PluginHookSubagentSpawningResult | void;
+  subagent_delivery_target: (event: PluginHookSubagentDeliveryTargetEvent, ctx: PluginHookSubagentContext) => Promise<PluginHookSubagentDeliveryTargetResult | void> | PluginHookSubagentDeliveryTargetResult | void;
+  subagent_spawned: (event: PluginHookSubagentSpawnedEvent, ctx: PluginHookSubagentContext) => Promise<void> | void;
+  subagent_ended: (event: PluginHookSubagentEndedEvent, ctx: PluginHookSubagentContext) => Promise<void> | void;
+  gateway_start: (event: PluginHookGatewayStartEvent, ctx: PluginHookGatewayContext) => Promise<void> | void;
+  gateway_stop: (event: PluginHookGatewayStopEvent, ctx: PluginHookGatewayContext) => Promise<void> | void;
+};
+type PluginHookRegistration$1<K extends PluginHookName = PluginHookName> = {
+  pluginId: string;
+  hookName: K;
+  handler: PluginHookHandlerMap[K];
+  priority?: number;
+  source: string;
+};
+//#endregion
+//#region src/plugins/registry.d.ts
+type PluginToolRegistration = {
+  pluginId: string;
+  factory: FasedAgentPluginToolFactory;
+  names: string[];
+  optional: boolean;
+  source: string;
+};
+type PluginCliRegistration = {
+  pluginId: string;
+  register: FasedAgentPluginCliRegistrar;
+  commands: string[];
+  source: string;
+};
+type PluginHttpRegistration = {
+  pluginId: string;
+  handler: FasedAgentPluginHttpHandler;
+  source: string;
+};
+type PluginHttpRouteRegistration = {
+  pluginId?: string;
+  path: string;
+  handler: FasedAgentPluginHttpRouteHandler;
+  source?: string;
+};
+type PluginChannelRegistration = {
+  pluginId: string;
+  plugin: ChannelPlugin;
+  dock?: ChannelDock;
+  source: string;
+};
+type PluginProviderRegistration = {
+  pluginId: string;
+  provider: ProviderPlugin;
+  source: string;
+};
+type PluginWebSearchProviderRegistration = {
+  pluginId: string;
+  provider: WebSearchProviderPlugin;
+  source: string;
+};
+type PluginImageGenerationProviderRegistration = {
+  pluginId: string;
+  provider: ImageGenerationProviderPlugin;
+  source: string;
+};
+type PluginVideoGenerationProviderRegistration = {
+  pluginId: string;
+  provider: VideoGenerationProviderPlugin;
+  source: string;
+};
+type PluginRealtimeTranscriptionProviderRegistration = {
+  pluginId: string;
+  provider: RealtimeTranscriptionProviderPlugin;
+  source: string;
+};
+type PluginRealtimeVoiceProviderRegistration = {
+  pluginId: string;
+  provider: RealtimeVoiceProviderPlugin;
+  source: string;
+};
+type PluginHookRegistration = {
+  pluginId: string;
+  entry: HookEntry;
+  events: string[];
+  source: string;
+};
+type PluginServiceRegistration = {
+  pluginId: string;
+  service: FasedAgentPluginService;
+  source: string;
+};
+type PluginCommandRegistration = {
+  pluginId: string;
+  command: FasedAgentPluginCommandDefinition;
+  source: string;
+};
+type PluginRecord = {
+  id: string;
+  name: string;
+  version?: string;
+  description?: string;
+  kind?: PluginKind;
+  source: string;
+  origin: PluginOrigin;
+  workspaceDir?: string;
+  enabled: boolean;
+  status: "loaded" | "disabled" | "error";
+  error?: string;
+  toolNames: string[];
+  hookNames: string[];
+  channelIds: string[];
+  providerIds: string[];
+  webSearchProviderIds?: string[];
+  gatewayMethods: string[];
+  cliCommands: string[];
+  services: string[];
+  commands: string[];
+  httpHandlers: number;
+  hookCount: number;
+  configSchema: boolean;
+  configUiHints?: Record<string, PluginConfigUiHint>;
+  configJsonSchema?: Record<string, unknown>;
+};
+type PluginRegistry = {
+  plugins: PluginRecord[];
+  tools: PluginToolRegistration[];
+  hooks: PluginHookRegistration[];
+  typedHooks: PluginHookRegistration$1[];
+  channels: PluginChannelRegistration[];
+  providers: PluginProviderRegistration[];
+  webSearchProviders: PluginWebSearchProviderRegistration[];
+  imageGenerationProviders: PluginImageGenerationProviderRegistration[];
+  videoGenerationProviders: PluginVideoGenerationProviderRegistration[];
+  realtimeTranscriptionProviders: PluginRealtimeTranscriptionProviderRegistration[];
+  realtimeVoiceProviders: PluginRealtimeVoiceProviderRegistration[];
+  gatewayHandlers: GatewayRequestHandlers;
+  gatewayMethodScopes: Partial<Record<string, OperatorScope>>;
+  httpHandlers: PluginHttpRegistration[];
+  httpRoutes: PluginHttpRouteRegistration[];
+  cliRegistrars: PluginCliRegistration[];
+  services: PluginServiceRegistration[];
+  commands: PluginCommandRegistration[];
+  diagnostics: PluginDiagnostic[];
+};
+//#endregion
+//#region src/plugins/config-state.d.ts
+declare const PLUGIN_ADMIN_RPC_ACTION_METHODS: readonly ["chat.inject", "push.test", "web.login.start", "web.login.wait"];
+type PluginAdminRpcActionMethod = (typeof PLUGIN_ADMIN_RPC_ACTION_METHODS)[number];
+//#endregion
+//#region src/plugins/runtime/admin-rpc-helper.d.ts
+type PluginRuntimeAdminRpcCallContext = {
+  context: GatewayRequestContext;
+  client: GatewayClient | null;
+  isWebchatConnect?: GatewayRequestHandlerOptions["isWebchatConnect"];
+};
+type PluginRuntimeAdminRpcInvocation = {
+  method: PluginAdminRpcActionMethod;
+  params: Record<string, unknown>;
+  call: PluginRuntimeAdminRpcCallContext;
+};
+type PluginRuntimeAdminRpcInvoker = (invocation: PluginRuntimeAdminRpcInvocation) => Promise<unknown>;
+type PluginRuntimeAdminRpcAuditEvent = {
+  pluginId?: string;
+  method: PluginAdminRpcActionMethod;
+  outcome: "allowed" | "denied" | "failed";
+  denyReason?: string;
+  matchedSource?: string;
+};
+type PluginRuntimeAdminRpcAuditSink = (event: PluginRuntimeAdminRpcAuditEvent) => void;
+type PluginRuntimeAdminRpcHelpers = {
+  /**
+   * Inject a labeled assistant message into an existing session transcript.
+   *
+   * This is not a generic gateway dispatcher. It requires an explicit
+   * `chat.inject` grant and an operator-scoped gateway call context.
+   */
+  chatInject: (params: ChatInjectParams, call: PluginRuntimeAdminRpcCallContext) => Promise<{
+    ok: boolean;
+    messageId?: string;
+  }>;
+  /**
+   * Send one test push to a specific registered node.
+   */
+  pushTest: (params: PushTestParams, call: PluginRuntimeAdminRpcCallContext) => Promise<{
+    ok?: boolean;
+    status?: number;
+    reason?: string;
+    environment?: string;
+    apnsId?: string;
+    tokenSuffix?: string;
+    topic?: string;
+  }>;
+  /**
+   * Start a provider QR-login flow. The returned payload is intentionally
+   * reduced so plugins never receive QR payloads, tokens, cookies, or secrets.
+   */
+  webLoginStart: (params: WebLoginStartParams, call: PluginRuntimeAdminRpcCallContext) => Promise<{
+    ok: true;
+    started: true;
+  }>;
+  /**
+   * Wait for a provider QR-login flow. The returned payload exposes only
+   * connection status and never returns login secrets.
+   */
+  webLoginWait: (params: WebLoginWaitParams, call: PluginRuntimeAdminRpcCallContext) => Promise<{
+    connected: boolean;
+  }>;
+};
+//#endregion
+//#region src/plugins/runtime/session-read-helper.d.ts
+/**
+ * Sanitized session metadata returned to permissioned plugins.
+ *
+ * This type is intentionally metadata-only. It does not include transcript
+ * bodies, message previews, session file paths, raw origin/delivery targets,
+ * account ids, or compaction summaries.
+ */
+type PluginRuntimeSessionStatus = {
+  key: string;
+  kind: GatewaySessionRow["kind"];
+  label?: string;
+  displayName?: string;
+  channel?: string;
+  subject?: string;
+  groupChannel?: string;
+  space?: string;
+  chatType?: ChatType;
+  updatedAt: number | null;
+  systemSent?: boolean;
+  abortedLastRun?: boolean;
+  thinkingLevel?: string;
+  verboseLevel?: string;
+  reasoningLevel?: string;
+  elevatedLevel?: string;
+  sendPolicy?: "allow" | "deny";
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  totalTokensFresh?: boolean;
+  responseUsage?: "on" | "off" | "tokens" | "full";
+  modelProvider?: string;
+  model?: string;
+  contextTokens?: number;
+  compactionCheckpointCount?: number;
+  lastChannel?: GatewaySessionRow["lastChannel"];
+};
+/**
+ * Filters for `runtime.helpers.sessions.list()`.
+ */
+type PluginRuntimeSessionListParams = {
+  agentId?: string;
+  activeMinutes?: number;
+  includeGlobal?: boolean;
+  includeUnknown?: boolean;
+  limit?: number;
+};
+/**
+ * Result returned by `runtime.helpers.sessions.list()`.
+ */
+type PluginRuntimeSessionListResult = {
+  ts: number;
+  count: number;
+  defaults: GatewaySessionsDefaults;
+  sessions: PluginRuntimeSessionStatus[];
+};
+/**
+ * Lookup parameters for `runtime.helpers.sessions.get()`.
+ */
+type PluginRuntimeSessionGetParams = {
+  key: string;
+  agentId?: string;
+  includeGlobal?: boolean;
+  includeUnknown?: boolean;
+};
+/**
+ * Read-only plugin runtime helpers for session metadata/status.
+ *
+ * Access requires `plugins.entries.<pluginId>.runtime.helpers.sessions.read =
+ * true`. Calls are scoped to the trusted plugin id assigned by the plugin
+ * loader. These helpers are not a gateway dispatcher and cannot read
+ * transcripts, mutate sessions, invoke nodes, edit config, or perform admin
+ * actions.
+ */
+type PluginRuntimeSessionHelpers = {
+  /**
+   * List sanitized session metadata/status rows.
+   *
+   * The returned rows are safe for plugin status and diagnostics. They do not
+   * contain message bodies, transcript previews, raw routing targets, account
+   * ids, session file paths, or compaction summaries.
+   */
+  list: (params?: PluginRuntimeSessionListParams) => PluginRuntimeSessionListResult;
+  /**
+   * Return one sanitized session metadata/status row by canonical session key,
+   * or `null` when the row is not visible.
+   */
+  get: (params: PluginRuntimeSessionGetParams) => PluginRuntimeSessionStatus | null;
+};
+/**
+ * Lightweight audit event emitted for plugin session-helper reads and denials.
+ */
+type PluginRuntimeSessionAuditEvent = {
+  pluginId?: string;
+  helper: "sessions.list" | "sessions.get";
+  outcome: "allowed" | "denied";
+  sessionKey?: string;
+  listCount?: number;
+  denyReason?: string;
+};
+type PluginRuntimeSessionAuditSink = (event: PluginRuntimeSessionAuditEvent) => void;
+//#endregion
+//#region src/plugins/runtime/types.d.ts
+type ShouldLogVerbose = typeof shouldLogVerbose;
+type DispatchReplyWithBufferedBlockDispatcher = typeof dispatchReplyWithBufferedBlockDispatcher;
+type CreateReplyDispatcherWithTyping = typeof createReplyDispatcherWithTyping;
+type ResolveEffectiveMessagesConfig = typeof resolveEffectiveMessagesConfig;
+type ResolveHumanDelayConfig = typeof resolveHumanDelayConfig;
+type ResolveAgentRoute = typeof resolveAgentRoute;
+type BuildPairingReply = typeof buildPairingReply;
+type ReadChannelAllowFromStore = typeof readChannelAllowFromStore;
+type UpsertChannelPairingRequest = typeof upsertChannelPairingRequest;
+type ReadChannelAllowFromStoreForAccount = (params: {
+  channel: Parameters<ReadChannelAllowFromStore>[0];
+  accountId: string;
+  env?: Parameters<ReadChannelAllowFromStore>[1];
+}) => ReturnType<ReadChannelAllowFromStore>;
+type UpsertChannelPairingRequestForAccount = (params: Omit<Parameters<UpsertChannelPairingRequest>[0], "accountId"> & {
+  accountId: string;
+}) => ReturnType<UpsertChannelPairingRequest>;
+type FetchRemoteMedia = typeof fetchRemoteMedia;
+type SaveMediaBuffer = typeof saveMediaBuffer;
+type TextToSpeechTelephony = typeof textToSpeechTelephony;
+type BuildMentionRegexes = typeof buildMentionRegexes;
+type MatchesMentionPatterns = typeof matchesMentionPatterns;
+type MatchesMentionWithExplicit = typeof matchesMentionWithExplicit;
+type ShouldAckReaction = typeof shouldAckReaction;
+type RemoveAckReactionAfterReply = typeof removeAckReactionAfterReply;
+type ResolveChannelGroupPolicy = typeof resolveChannelGroupPolicy;
+type ResolveChannelGroupRequireMention = typeof resolveChannelGroupRequireMention;
+type CreateInboundDebouncer = typeof createInboundDebouncer;
+type ResolveInboundDebounceMs = typeof resolveInboundDebounceMs;
+type ResolveCommandAuthorizedFromAuthorizers = typeof resolveCommandAuthorizedFromAuthorizers;
+type ResolveTextChunkLimit = typeof resolveTextChunkLimit;
+type ResolveChunkMode = typeof resolveChunkMode;
+type ChunkMarkdownText = typeof chunkMarkdownText;
+type ChunkMarkdownTextWithMode = typeof chunkMarkdownTextWithMode;
+type ChunkText = typeof chunkText;
+type ChunkTextWithMode = typeof chunkTextWithMode;
+type ChunkByNewline = typeof chunkByNewline;
+type ResolveMarkdownTableMode = typeof resolveMarkdownTableMode;
+type ConvertMarkdownTables = typeof convertMarkdownTables;
+type HasControlCommand = typeof hasControlCommand;
+type IsControlCommandMessage = typeof isControlCommandMessage;
+type ShouldComputeCommandAuthorized = typeof shouldComputeCommandAuthorized;
+type ShouldHandleTextCommands = typeof shouldHandleTextCommands;
+type DispatchReplyFromConfig = typeof dispatchReplyFromConfig;
+type WithReplyDispatcher = typeof withReplyDispatcher;
+type FinalizeInboundContext = typeof finalizeInboundContext;
+type FormatAgentEnvelope = typeof formatAgentEnvelope;
+type FormatInboundEnvelope = typeof formatInboundEnvelope;
+type ResolveEnvelopeFormatOptions = typeof resolveEnvelopeFormatOptions;
+type ResolveStateDir = typeof resolveStateDir;
+type RecordInboundSession = typeof recordInboundSession;
+type RecordSessionMetaFromInbound = typeof recordSessionMetaFromInbound;
+type ResolveStorePath = typeof resolveStorePath;
+type ReadSessionUpdatedAt = typeof readSessionUpdatedAt;
+type UpdateLastRoute = typeof updateLastRoute;
+type LoadConfig = typeof loadConfig;
+type WriteConfigFile = typeof writeConfigFile;
+type RecordChannelActivity = typeof recordChannelActivity;
+type GetChannelActivity = typeof getChannelActivity;
+type EnqueueSystemEvent = typeof enqueueSystemEvent;
+type RunCommandWithTimeout = typeof runCommandWithTimeout;
+type FormatNativeDependencyHint = typeof formatNativeDependencyHint;
+type LoadWebMedia = typeof loadWebMedia;
+type DetectMime = typeof detectMime;
+type MediaKindFromMime = typeof mediaKindFromMime;
+type IsVoiceCompatibleAudio = typeof isVoiceCompatibleAudio;
+type GetImageMetadata = typeof getImageMetadata;
+type ResizeToJpeg = typeof resizeToJpeg;
+type CreateMemoryGetTool = typeof createMemoryGetTool;
+type CreateMemorySearchTool = typeof createMemorySearchTool;
+type RegisterMemoryCli = typeof registerMemoryCli;
+type DiscordMessageActions = typeof discordMessageActions;
+type AuditDiscordChannelPermissions = typeof auditDiscordChannelPermissions;
+type ListDiscordDirectoryGroupsLive = typeof listDiscordDirectoryGroupsLive;
+type ListDiscordDirectoryPeersLive = typeof listDiscordDirectoryPeersLive;
+type ProbeDiscord = typeof probeDiscord;
+type ResolveDiscordChannelAllowlist = typeof resolveDiscordChannelAllowlist;
+type ResolveDiscordUserAllowlist = typeof resolveDiscordUserAllowlist;
+type SendMessageDiscord = typeof sendMessageDiscord;
+type SendPollDiscord = typeof sendPollDiscord;
+type MonitorDiscordProvider = typeof monitorDiscordProvider;
+type ListSlackDirectoryGroupsLive = typeof listSlackDirectoryGroupsLive;
+type ListSlackDirectoryPeersLive = typeof listSlackDirectoryPeersLive;
+type ProbeSlack = typeof probeSlack;
+type ResolveSlackChannelAllowlist = typeof resolveSlackChannelAllowlist;
+type ResolveSlackUserAllowlist = typeof resolveSlackUserAllowlist;
+type SendMessageSlack = typeof sendMessageSlack;
+type MonitorSlackProvider = typeof monitorSlackProvider;
+type HandleSlackAction = typeof handleSlackAction;
+type AuditTelegramGroupMembership = typeof auditTelegramGroupMembership;
+type CollectTelegramUnmentionedGroupIds = typeof collectTelegramUnmentionedGroupIds;
+type ProbeTelegram = typeof probeTelegram;
+type ResolveTelegramToken = typeof resolveTelegramToken;
+type SendMessageTelegram = typeof sendMessageTelegram;
+type SendPollTelegram = typeof sendPollTelegram;
+type MonitorTelegramProvider = typeof monitorTelegramProvider;
+type TelegramMessageActions = typeof telegramMessageActions;
+type ProbeSignal = typeof probeSignal;
+type SendMessageSignal = typeof sendMessageSignal;
+type MonitorSignalProvider = typeof monitorSignalProvider;
+type SignalMessageActions = typeof signalMessageActions;
+type MonitorIMessageProvider = typeof monitorIMessageProvider;
+type ProbeIMessage = typeof probeIMessage;
+type SendMessageIMessage = typeof sendMessageIMessage;
+type GetActiveWebListener = typeof getActiveWebListener;
+type GetWebAuthAgeMs = typeof getWebAuthAgeMs;
+type LogoutWeb = typeof logoutWeb;
+type LogWebSelfId = typeof logWebSelfId;
+type ReadWebSelfId = typeof readWebSelfId;
+type WebAuthExists = typeof webAuthExists;
+type SendMessageWhatsApp = typeof sendMessageWhatsApp;
+type SendPollWhatsApp = typeof sendPollWhatsApp;
+type LoginWeb = typeof loginWeb;
+type StartWebLoginWithQr = typeof startWebLoginWithQr;
+type WaitForWebLogin = typeof waitForWebLogin;
+type MonitorWebChannel = typeof monitorWebChannel;
+type HandleWhatsAppAction = typeof handleWhatsAppAction;
+type CreateWhatsAppLoginTool = typeof createWhatsAppLoginTool;
+type ListLineAccountIds = typeof listLineAccountIds;
+type ResolveDefaultLineAccountId = typeof resolveDefaultLineAccountId;
+type ResolveLineAccount = typeof resolveLineAccount;
+type NormalizeLineAccountId = typeof normalizeAccountId;
+type ProbeLineBot = typeof probeLineBot;
+type SendMessageLine = typeof sendMessageLine;
+type PushMessageLine = typeof pushMessageLine;
+type PushMessagesLine = typeof pushMessagesLine;
+type PushFlexMessage = typeof pushFlexMessage;
+type PushTemplateMessage = typeof pushTemplateMessage;
+type PushLocationMessage = typeof pushLocationMessage;
+type PushTextMessageWithQuickReplies = typeof pushTextMessageWithQuickReplies;
+type CreateQuickReplyItems = typeof createQuickReplyItems;
+type BuildTemplateMessageFromPayload = typeof buildTemplateMessageFromPayload;
+type MonitorLineProvider = typeof monitorLineProvider;
+type RuntimeLogger = {
+  debug?: (message: string, meta?: Record<string, unknown>) => void;
+  info: (message: string, meta?: Record<string, unknown>) => void;
+  warn: (message: string, meta?: Record<string, unknown>) => void;
+  error: (message: string, meta?: Record<string, unknown>) => void;
+};
+type PluginRuntime = {
+  version: string;
+  config: {
+    loadConfig: LoadConfig;
+    writeConfigFile: WriteConfigFile;
+  };
+  system: {
+    enqueueSystemEvent: EnqueueSystemEvent;
+    runCommandWithTimeout: RunCommandWithTimeout;
+    formatNativeDependencyHint: FormatNativeDependencyHint;
+  };
+  media: {
+    loadWebMedia: LoadWebMedia;
+    detectMime: DetectMime;
+    mediaKindFromMime: MediaKindFromMime;
+    isVoiceCompatibleAudio: IsVoiceCompatibleAudio;
+    getImageMetadata: GetImageMetadata;
+    resizeToJpeg: ResizeToJpeg;
+  };
+  tts: {
+    textToSpeechTelephony: TextToSpeechTelephony;
+  };
+  tools: {
+    createMemoryGetTool: CreateMemoryGetTool;
+    createMemorySearchTool: CreateMemorySearchTool;
+    registerMemoryCli: RegisterMemoryCli;
+  };
+  channel: {
+    text: {
+      chunkByNewline: ChunkByNewline;
+      chunkMarkdownText: ChunkMarkdownText;
+      chunkMarkdownTextWithMode: ChunkMarkdownTextWithMode;
+      chunkText: ChunkText;
+      chunkTextWithMode: ChunkTextWithMode;
+      resolveChunkMode: ResolveChunkMode;
+      resolveTextChunkLimit: ResolveTextChunkLimit;
+      hasControlCommand: HasControlCommand;
+      resolveMarkdownTableMode: ResolveMarkdownTableMode;
+      convertMarkdownTables: ConvertMarkdownTables;
+    };
+    reply: {
+      dispatchReplyWithBufferedBlockDispatcher: DispatchReplyWithBufferedBlockDispatcher;
+      createReplyDispatcherWithTyping: CreateReplyDispatcherWithTyping;
+      resolveEffectiveMessagesConfig: ResolveEffectiveMessagesConfig;
+      resolveHumanDelayConfig: ResolveHumanDelayConfig;
+      dispatchReplyFromConfig: DispatchReplyFromConfig;
+      withReplyDispatcher: WithReplyDispatcher;
+      finalizeInboundContext: FinalizeInboundContext;
+      formatAgentEnvelope: FormatAgentEnvelope; /** @deprecated Prefer `BodyForAgent` + structured user-context blocks (do not build plaintext envelopes for prompts). */
+      formatInboundEnvelope: FormatInboundEnvelope;
+      resolveEnvelopeFormatOptions: ResolveEnvelopeFormatOptions;
+    };
+    routing: {
+      resolveAgentRoute: ResolveAgentRoute;
+    };
+    pairing: {
+      buildPairingReply: BuildPairingReply;
+      readAllowFromStore: ReadChannelAllowFromStoreForAccount;
+      upsertPairingRequest: UpsertChannelPairingRequestForAccount;
+    };
+    media: {
+      fetchRemoteMedia: FetchRemoteMedia;
+      saveMediaBuffer: SaveMediaBuffer;
+    };
+    activity: {
+      record: RecordChannelActivity;
+      get: GetChannelActivity;
+    };
+    session: {
+      resolveStorePath: ResolveStorePath;
+      readSessionUpdatedAt: ReadSessionUpdatedAt;
+      recordSessionMetaFromInbound: RecordSessionMetaFromInbound;
+      recordInboundSession: RecordInboundSession;
+      updateLastRoute: UpdateLastRoute;
+    };
+    mentions: {
+      buildMentionRegexes: BuildMentionRegexes;
+      matchesMentionPatterns: MatchesMentionPatterns;
+      matchesMentionWithExplicit: MatchesMentionWithExplicit;
+    };
+    reactions: {
+      shouldAckReaction: ShouldAckReaction;
+      removeAckReactionAfterReply: RemoveAckReactionAfterReply;
+    };
+    groups: {
+      resolveGroupPolicy: ResolveChannelGroupPolicy;
+      resolveRequireMention: ResolveChannelGroupRequireMention;
+    };
+    debounce: {
+      createInboundDebouncer: CreateInboundDebouncer;
+      resolveInboundDebounceMs: ResolveInboundDebounceMs;
+    };
+    commands: {
+      resolveCommandAuthorizedFromAuthorizers: ResolveCommandAuthorizedFromAuthorizers;
+      isControlCommandMessage: IsControlCommandMessage;
+      shouldComputeCommandAuthorized: ShouldComputeCommandAuthorized;
+      shouldHandleTextCommands: ShouldHandleTextCommands;
+    };
+    discord: {
+      messageActions: DiscordMessageActions;
+      auditChannelPermissions: AuditDiscordChannelPermissions;
+      listDirectoryGroupsLive: ListDiscordDirectoryGroupsLive;
+      listDirectoryPeersLive: ListDiscordDirectoryPeersLive;
+      probeDiscord: ProbeDiscord;
+      resolveChannelAllowlist: ResolveDiscordChannelAllowlist;
+      resolveUserAllowlist: ResolveDiscordUserAllowlist;
+      sendMessageDiscord: SendMessageDiscord;
+      sendPollDiscord: SendPollDiscord;
+      monitorDiscordProvider: MonitorDiscordProvider;
+    };
+    slack: {
+      listDirectoryGroupsLive: ListSlackDirectoryGroupsLive;
+      listDirectoryPeersLive: ListSlackDirectoryPeersLive;
+      probeSlack: ProbeSlack;
+      resolveChannelAllowlist: ResolveSlackChannelAllowlist;
+      resolveUserAllowlist: ResolveSlackUserAllowlist;
+      sendMessageSlack: SendMessageSlack;
+      monitorSlackProvider: MonitorSlackProvider;
+      handleSlackAction: HandleSlackAction;
+    };
+    telegram: {
+      auditGroupMembership: AuditTelegramGroupMembership;
+      collectUnmentionedGroupIds: CollectTelegramUnmentionedGroupIds;
+      probeTelegram: ProbeTelegram;
+      resolveTelegramToken: ResolveTelegramToken;
+      sendMessageTelegram: SendMessageTelegram;
+      sendPollTelegram: SendPollTelegram;
+      monitorTelegramProvider: MonitorTelegramProvider;
+      messageActions: TelegramMessageActions;
+    };
+    signal: {
+      probeSignal: ProbeSignal;
+      sendMessageSignal: SendMessageSignal;
+      monitorSignalProvider: MonitorSignalProvider;
+      messageActions: SignalMessageActions;
+    };
+    imessage: {
+      monitorIMessageProvider: MonitorIMessageProvider;
+      probeIMessage: ProbeIMessage;
+      sendMessageIMessage: SendMessageIMessage;
+    };
+    whatsapp: {
+      getActiveWebListener: GetActiveWebListener;
+      getWebAuthAgeMs: GetWebAuthAgeMs;
+      logoutWeb: LogoutWeb;
+      logWebSelfId: LogWebSelfId;
+      readWebSelfId: ReadWebSelfId;
+      webAuthExists: WebAuthExists;
+      sendMessageWhatsApp: SendMessageWhatsApp;
+      sendPollWhatsApp: SendPollWhatsApp;
+      loginWeb: LoginWeb;
+      startWebLoginWithQr: StartWebLoginWithQr;
+      waitForWebLogin: WaitForWebLogin;
+      monitorWebChannel: MonitorWebChannel;
+      handleWhatsAppAction: HandleWhatsAppAction;
+      createLoginTool: CreateWhatsAppLoginTool;
+    };
+    line: {
+      listLineAccountIds: ListLineAccountIds;
+      resolveDefaultLineAccountId: ResolveDefaultLineAccountId;
+      resolveLineAccount: ResolveLineAccount;
+      normalizeAccountId: NormalizeLineAccountId;
+      probeLineBot: ProbeLineBot;
+      sendMessageLine: SendMessageLine;
+      pushMessageLine: PushMessageLine;
+      pushMessagesLine: PushMessagesLine;
+      pushFlexMessage: PushFlexMessage;
+      pushTemplateMessage: PushTemplateMessage;
+      pushLocationMessage: PushLocationMessage;
+      pushTextMessageWithQuickReplies: PushTextMessageWithQuickReplies;
+      createQuickReplyItems: CreateQuickReplyItems;
+      buildTemplateMessageFromPayload: BuildTemplateMessageFromPayload;
+      monitorLineProvider: MonitorLineProvider;
+    };
+  };
+  logging: {
+    shouldLogVerbose: ShouldLogVerbose;
+    getChildLogger: (bindings?: Record<string, unknown>, opts?: {
+      level?: LogLevel;
+    }) => RuntimeLogger;
+  };
+  state: {
+    resolveStateDir: ResolveStateDir;
+  };
+  /**
+   * Fixed helper surfaces exposed to plugins through the scoped runtime.
+   *
+   * Helpers are permission-gated and intentionally narrower than gateway RPC.
+   * They must not be treated as a generic gateway dispatcher.
+   */
+  helpers: {
+    /**
+     * Fixed, permission-gated wrappers for selected admin/write helper RPCs.
+     *
+     * This is intentionally not a generic gateway dispatcher. Each method
+     * requires an explicit `plugins.entries.<plugin-id>.runtime.adminRpcActions`
+     * grant, trusted plugin source match, operator-scoped call context, inherited
+     * rate limit, and sanitized audit.
+     */
+    adminRpc: PluginRuntimeAdminRpcHelpers;
+    /**
+     * Read-only session metadata/status helper.
+     *
+     * Requires:
+     *
+     * ```json
+     * {
+     *   "plugins": {
+     *     "entries": {
+     *       "<plugin-id>": {
+     *         "runtime": {
+     *           "helpers": { "sessions": { "read": true } }
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * Returns sanitized metadata only. It does not expose transcripts, message
+     * previews, session mutation, node invocation, config mutation, or a gateway
+     * dispatcher.
+     */
+    sessions: PluginRuntimeSessionHelpers;
+  };
+};
+//#endregion
+export { RealtimeVoiceBridge as $, extensionForMime as $t, ProviderPlugin as A, LineAccountConfig as At, GeneratedVideoAsset as B, resolveDefaultGroupPolicy as Bt, ProviderAuthContext as C, readStringParam as Cn, ImageGenerationSourceImage as Ct, ProviderCatalogContext as D, SessionEntry as Dn, normalizeAccountId as Dt, ProviderAuthResult as E, SessionAcpMeta as En, listLineAccountIds as Et, RealtimeTranscriptionProviderPlugin as F, formatLocationText as Ft, VideoGenerationProviderCapabilities as G, listSlackDirectoryGroupsFromConfig as Gt, VideoGenerationMode as H, warnMissingProviderGroupPolicyFallbackOnce as Ht, RealtimeVoiceProviderPlugin as I, toLocationContext as It, VideoGenerationResolution as J, listTelegramDirectoryPeersFromConfig as Jt, VideoGenerationProviderConfiguredContext as K, listSlackDirectoryPeersFromConfig as Kt, VideoGenerationProviderPlugin as L, TelegramProbe as Lt, ProviderPluginWizard as M, LineConfig as Mt, ProviderPluginWizardModelPicker as N, ResolvedLineAccount as Nt, ProviderCatalogOrder as O, SessionSystemPromptReport as On, resolveDefaultLineAccountId as Ot, ProviderPluginWizardSetup as P, NormalizedLocation as Pt, RuntimeWebSearchMetadata as Q, detectMime as Qt, WebSearchProviderPlugin as R, GROUP_POLICY_BLOCKED_LABEL as Rt, PluginLogger as S, readReactionParams as Sn, ImageGenerationResult as St, ProviderAuthMethod as T, SessionAcpIdentity as Tn, ChannelDock as Tt, VideoGenerationModeCapabilities as U, listDiscordDirectoryGroupsFromConfig as Ut, VideoGenerationIgnoredOverride as V, resolveOpenProviderRuntimeGroupPolicy as Vt, VideoGenerationProvider as W, listDiscordDirectoryPeersFromConfig as Wt, VideoGenerationSourceAsset as X, listWhatsAppDirectoryPeersFromConfig as Xt, VideoGenerationResult as Y, listWhatsAppDirectoryGroupsFromConfig as Yt, VideoGenerationTransformCapabilities as Z, collectDiscordAuditChannelIds as Zt, FasedAgentPluginApi as _, createTypingCallbacks as _n, GeneratedImageAsset as _t, PluginRuntimeSessionGetParams as a, resolveControlCommandGate as an, RealtimeVoiceProviderId as at, FasedAgentPluginServiceContext as b, jsonResult as bn, ImageGenerationRequest as bt, PluginRuntimeSessionListResult as c, AckReactionScope as cn, RealtimeVoiceTool as ct, PluginRuntimeAdminRpcAuditSink as d, shouldAckReaction as dn, RealtimeTranscriptionProviderConfiguredContext as dt, getFileExtension as en, RealtimeVoiceBridgeCallbacks as et, PluginRuntimeAdminRpcCallContext as f, shouldAckReactionForWhatsApp as fn, RealtimeTranscriptionProviderId as ft, PluginRegistry as g, ResponsePrefixContext as gn, RealtimeTranscriptionSessionCreateRequest as gt, PluginRuntimeAdminRpcInvoker as h, resolveAckReaction as hn, RealtimeTranscriptionSessionCallbacks as ht, PluginRuntimeSessionAuditSink as i, formatInboundFromLabel as in, RealtimeVoiceProviderConfiguredContext as it, ProviderPluginCatalog as j, LineChannelData as jt, ProviderCatalogResult as k, resolveLineAccount as kt, PluginRuntimeSessionStatus as l, WhatsAppAckReactionMode as ln, RealtimeVoiceToolCallEvent as lt, PluginRuntimeAdminRpcInvocation as m, RoutePeerKind as mn, RealtimeTranscriptionSession as mt, RuntimeLogger as n, loadWebMedia as nn, RealtimeVoiceCloseReason as nt, PluginRuntimeSessionHelpers as o, resolveToolsBySender as on, RealtimeVoiceProviderResolveConfigContext as ot, PluginRuntimeAdminRpcHelpers as p, extractOriginalFilename as pn, RealtimeTranscriptionProviderResolveConfigContext as pt, VideoGenerationRequest as q, listTelegramDirectoryGroupsFromConfig as qt, PluginRuntimeSessionAuditEvent as r, recordInboundSession as rn, RealtimeVoiceProviderConfig as rt, PluginRuntimeSessionListParams as s, AckReactionGateParams as sn, RealtimeVoiceRole as st, PluginRuntime as t, WebMediaResult as tn, RealtimeVoiceBridgeCreateRequest as tt, PluginRuntimeAdminRpcAuditEvent as u, removeAckReactionAfterReply as un, RealtimeTranscriptionProviderConfig as ut, FasedAgentPluginConfigSchema as v, AnyAgentTool as vn, ImageGenerationProvider as vt, ProviderAuthKind as w, AcpSessionRuntimeOptions as wn, HookEntry as wt, ImageGenerationProviderPlugin as x, readNumberParam as xn, ImageGenerationResolution as xt, FasedAgentPluginService as y, createActionGate as yn, ImageGenerationProviderConfiguredContext as yt, WebSearchProviderToolDefinition as z, resolveAllowlistProviderRuntimeGroupPolicy as zt };