@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/templating-Bw49ZLzH.d.ts

@@ -0,0 +1,286 @@
+import { i as ReplyThreadingPolicy } from "./get-reply-options.types-BXrapyJ-.js";
+import { n as InboundEventKind, t as InputProvenance } from "./input-provenance-DgsxhTbk.js";
+import { d as MediaUnderstandingOutput, u as MediaUnderstandingDecision } from "./types-Bf9oj7Ac.js";
+import { n as CommandArgs } from "./commands-args.types-BetHnA9i.js";
+import { t as HistoryEntry } from "./history.types-D_WxL2c8.js";
+//#region src/auto-reply/command-turn-context.d.ts
+type CommandTurnKind = "native" | "text-slash" | "normal";
+type CommandTurnSource = "native" | "text" | "message";
+type BaseCommandTurnContext = {
+  commandName?: string;
+  body?: string;
+};
+type NativeCommandTurnContext = BaseCommandTurnContext & {
+  kind: "native";
+  source: "native";
+  authorized: boolean;
+};
+type TextSlashCommandTurnContext = BaseCommandTurnContext & {
+  kind: "text-slash";
+  source: "text";
+  authorized: boolean;
+};
+type NormalCommandTurnContext = BaseCommandTurnContext & {
+  kind: "normal";
+  source: "message";
+  authorized: false;
+};
+type CommandTurnContext = NativeCommandTurnContext | TextSlashCommandTurnContext | NormalCommandTurnContext;
+declare function createCommandTurnContext(source: CommandTurnSource, input: {
+  authorized: boolean;
+  commandName?: string;
+  body?: string;
+}): CommandTurnContext;
+declare function isNativeCommandTurn(commandTurn: CommandTurnContext | undefined): boolean;
+declare function isTextSlashCommandTurn(commandTurn: CommandTurnContext | undefined): boolean;
+declare function isAuthorizedTextSlashCommandTurn(commandTurn: CommandTurnContext | undefined): boolean;
+declare function isExplicitCommandTurn(commandTurn: CommandTurnContext | undefined): boolean;
+//#endregion
+//#region src/auto-reply/templating.d.ts
+/** Valid message channels for routing. */
+type OriginatingChannelType = string & {
+  readonly __originatingChannelBrand?: never;
+};
+type MentionSource = "explicit_bot" | "subteam" | "mention_pattern" | "implicit_thread" | "command_bypass" | "none";
+type StickerContextMetadata = {
+  cachedDescription?: string;
+  emoji?: string;
+  setName?: string;
+  description?: string;
+  fileId?: string;
+  fileUniqueId?: string;
+  uniqueFileId?: string;
+  isAnimated?: boolean;
+  isVideo?: boolean;
+} & Record<string, unknown>;
+type UntrustedStructuredContextEntry = {
+  label: string;
+  source?: string;
+  type?: string;
+  payload: unknown;
+};
+type MsgContext = {
+  Body?: string;
+  InboundEventKind?: InboundEventKind;
+  /**
+   * Agent prompt body (may include envelope/history/context). Prefer this for prompt shaping.
+   * Should use real newlines (`\n`), not escaped `\\n`.
+   */
+  BodyForAgent?: string;
+  /**
+   * Recent chat history for context (untrusted user content). Prefer passing this
+   * as structured context blocks in the user prompt rather than rendering plaintext envelopes.
+   */
+  InboundHistory?: HistoryEntry[];
+  /**
+   * @deprecated Use CommandBody.
+   *
+   * Raw message body without structural context (history, sender labels).
+   * Legacy alias for CommandBody. Falls back to Body if not set.
+   */
+  RawBody?: string;
+  /**
+   * Prefer for command detection; RawBody is treated as legacy alias.
+   */
+  CommandBody?: string;
+  /**
+   * Command parsing body. Prefer this over CommandBody/RawBody when set.
+   * Should be the "clean" text (no history/sender context).
+   */
+  BodyForCommands?: string;
+  CommandArgs?: CommandArgs;
+  From?: string;
+  To?: string;
+  SessionKey?: string;
+  /**
+   * Session-like key used for runtime policy (sandbox/tool policy) when the
+   * conversation key intentionally remains broader, such as a main-session DM.
+   */
+  RuntimePolicySessionKey?: string; /** Provider account id (multi-account). */
+  AccountId?: string;
+  ParentSessionKey?: string;
+  /**
+   * Session key used only for inheriting session-scoped model/provider
+   * overrides. Unlike ParentSessionKey, this must not trigger transcript
+   * forking or parent-session lifecycle behavior.
+   */
+  ModelParentSessionKey?: string;
+  MessageSid?: string; /** Provider-specific full message id when MessageSid is a shortened alias. */
+  MessageSidFull?: string;
+  MessageSids?: string[];
+  MessageSidFirst?: string;
+  MessageSidLast?: string; /** Per-turn reply-threading overrides. */
+  ReplyThreading?: ReplyThreadingPolicy;
+  ReplyToId?: string;
+  /**
+   * Root message id for thread reconstruction (used by Feishu for root_id).
+   * When a message is part of a thread, this is the id of the first message.
+   */
+  RootMessageId?: string; /** Provider-specific full reply-to id when ReplyToId is a shortened alias. */
+  ReplyToIdFull?: string;
+  ReplyToBody?: string;
+  ReplyToQuoteText?: string;
+  ReplyToSender?: string;
+  ReplyChain?: Array<{
+    messageId?: string;
+    threadId?: string;
+    sender?: string;
+    senderId?: string;
+    senderUsername?: string;
+    timestamp?: number;
+    body?: string;
+    isQuote?: boolean;
+    mediaType?: string;
+    mediaPath?: string;
+    mediaRef?: string;
+    replyToId?: string;
+    forwardedFrom?: string;
+    forwardedFromId?: string;
+    forwardedFromUsername?: string;
+    forwardedDate?: number;
+  }>;
+  ReplyToIsQuote?: boolean; /** Forward origin from the reply target (when reply_to_message is a forwarded message). */
+  ReplyToForwardedFrom?: string;
+  ReplyToForwardedFromType?: string;
+  ReplyToForwardedFromId?: string;
+  ReplyToForwardedFromUsername?: string;
+  ReplyToForwardedFromTitle?: string;
+  ReplyToForwardedDate?: number;
+  ForwardedFrom?: string;
+  ForwardedFromType?: string;
+  ForwardedFromId?: string;
+  ForwardedFromUsername?: string;
+  ForwardedFromTitle?: string;
+  ForwardedFromSignature?: string;
+  ForwardedFromChatType?: string;
+  ForwardedFromMessageId?: number;
+  ForwardedDate?: number;
+  ThreadStarterBody?: string; /** Full thread history when starting a new thread session. */
+  ThreadHistoryBody?: string;
+  IsFirstThreadTurn?: boolean;
+  ThreadLabel?: string;
+  MediaPath?: string;
+  MediaUrl?: string;
+  MediaType?: string;
+  MediaDir?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+  MediaWorkspaceDir?: string; /** Attachment indexes whose audio was already transcribed before media understanding runs. */
+  MediaTranscribedIndexes?: number[];
+  /**
+   * Marker: skip downstream stageSandboxMedia. chat.send RPC sets this so
+   * staging runs synchronously before respond() and surfaces 5xx to the
+   * client; any later failure only reaches the broadcast channel.
+   */
+  MediaStaged?: boolean; /** Telegram sticker metadata (emoji, set name, file IDs, cached description). */
+  Sticker?: StickerContextMetadata; /** True when current-turn sticker media is present in MediaPaths (false for cached-description path). */
+  StickerMediaIncluded?: boolean;
+  OutputDir?: string;
+  OutputBase?: string; /** Remote host for SCP when media lives on a different machine (e.g., daocore@192.168.64.3). */
+  MediaRemoteHost?: string;
+  Transcript?: string;
+  MediaUnderstanding?: MediaUnderstandingOutput[];
+  MediaUnderstandingDecisions?: MediaUnderstandingDecision[];
+  LinkUnderstanding?: string[];
+  Prompt?: string;
+  MaxChars?: number;
+  ChatType?: string; /** Human label for envelope headers (conversation label, not sender). */
+  ConversationLabel?: string;
+  GroupSubject?: string; /** Human label for channel-like group conversations (e.g. #general, #support). */
+  GroupChannel?: string;
+  GroupSpace?: string; /** Trusted provider role ids for the sender in this group turn. */
+  MemberRoleIds?: string[];
+  GroupMembers?: string;
+  GroupSystemPrompt?: string; /** Untrusted metadata that must not be treated as system instructions. */
+  UntrustedContext?: string[]; /** Structured untrusted metadata rendered by prompt assembly as fenced JSON. */
+  UntrustedStructuredContext?: UntrustedStructuredContextEntry[]; /** System-attached provenance for the current inbound message. */
+  InputProvenance?: InputProvenance; /** Explicit owner allowlist overrides (trusted, configuration-derived). */
+  OwnerAllowFrom?: Array<string | number>;
+  SenderName?: string;
+  SenderId?: string;
+  SenderUsername?: string;
+  SenderTag?: string;
+  SenderE164?: string;
+  Timestamp?: number;
+  LocationLat?: number;
+  LocationLon?: number;
+  LocationAccuracy?: number;
+  LocationName?: string;
+  LocationAddress?: string;
+  LocationSource?: string;
+  LocationIsLive?: boolean;
+  LocationCaption?: string; /** Provider label. */
+  Provider?: string; /** Provider surface label. Prefer this over `Provider` when available. */
+  Surface?: string; /** Platform bot username when command mentions should be normalized. */
+  BotUsername?: string;
+  WasMentioned?: boolean; /** True when this turn explicitly mentioned the current bot target. */
+  ExplicitlyMentionedBot?: boolean; /** Provider-native explicit user mention ids present on this turn. */
+  MentionedUserIds?: string[]; /** Provider-native explicit user-group/subteam mention ids present on this turn. */
+  MentionedSubteamIds?: string[]; /** Provider-native implicit mention wake reasons present on this turn. */
+  ImplicitMentionKinds?: string[]; /** Provider-native source that caused the current mention decision. */
+  MentionSource?: MentionSource;
+  CommandAuthorized?: boolean;
+  CommandTurn?: CommandTurnContext;
+  CommandSource?: "text" | "native";
+  CommandTargetSessionKey?: string;
+  /**
+   * Internal flag: command handling prepared trailing prompt text for ACP dispatch.
+   * Used for `/new <prompt>` and `/reset <prompt>` on ACP-bound sessions.
+   */
+  AcpDispatchTailAfterReset?: boolean; /** Gateway client scopes when the message originates from the gateway. */
+  GatewayClientScopes?: string[]; /** Thread identifier (Telegram topic id or Matrix thread event id). */
+  MessageThreadId?: string | number; /** Provider-native thread target for reply delivery without making the session thread-scoped. */
+  TransportThreadId?: string | number; /** Platform-native channel/conversation id (e.g. Slack DM channel "D…" id). */
+  NativeChannelId?: string; /** Stable provider-native direct-peer id when a DM room/user mapping must survive later writes. */
+  NativeDirectUserId?: string; /** Telegram forum supergroup marker. */
+  IsForum?: boolean; /** Human-readable Telegram forum topic name (cached from service messages). */
+  TopicName?: string; /** Warning: DM has topics enabled but this message is not in a topic. */
+  TopicRequiredButMissing?: boolean;
+  /**
+   * Originating channel for reply routing.
+   * When set, replies should be routed back to this provider
+   * instead of using lastChannel from the session.
+   */
+  OriginatingChannel?: OriginatingChannelType;
+  /**
+   * Originating destination for reply routing.
+   * The chat/channel/user ID where the reply should be sent.
+   */
+  OriginatingTo?: string;
+  /**
+   * True when the current turn intentionally requested external delivery to
+   * OriginatingChannel/OriginatingTo, rather than inheriting stale session route metadata.
+   */
+  ExplicitDeliverRoute?: boolean;
+  /**
+   * Provider-specific parent conversation id for threaded contexts.
+   * For Discord threads, this is the parent channel id.
+   */
+  ThreadParentId?: string;
+  /**
+   * Messages from hooks to be included in the response.
+   * Used for hook confirmation messages like "Session context saved to memory".
+   */
+  HookMessages?: string[];
+};
+type FinalizedMsgContext = Omit<MsgContext, "CommandAuthorized"> & {
+  /**
+   * Always set by finalizeInboundContext().
+   * Default-deny: missing/undefined becomes false.
+   */
+  CommandAuthorized: boolean;
+  /**
+   * Populated by finalizeInboundContext(); optional for public SDK
+   * compatibility with existing plugin-constructed finalized contexts.
+   */
+  CommandTurn?: CommandTurnContext;
+};
+type TemplateContext = MsgContext & {
+  BodyStripped?: string;
+  SessionId?: string;
+  IsNewSession?: string;
+};
+declare function applyTemplate(str: string | undefined, ctx: TemplateContext): string;
+//#endregion
+export { CommandTurnKind as a, isExplicitCommandTurn as c, CommandTurnContext as i, isNativeCommandTurn as l, MsgContext as n, createCommandTurnContext as o, applyTemplate as r, isAuthorizedTextSlashCommandTurn as s, FinalizedMsgContext as t, isTextSlashCommandTurn as u };

package/dist/test-fixtures-xgg7UsEw.d.ts

@@ -0,0 +1,27 @@
+import { a as SandboxSshConfig, i as SandboxPruneConfig, t as SandboxBrowserConfig } from "./types-kd_AtXCR.js";
+
+//#region src/plugin-sdk/test-helpers/sandbox-fixtures.d.ts
+declare function createSandboxBrowserConfig(overrides?: Partial<SandboxBrowserConfig>): SandboxBrowserConfig;
+declare function createSandboxPruneConfig(overrides?: Partial<SandboxPruneConfig>): SandboxPruneConfig;
+declare function createSandboxSshConfig(workspaceRoot: string, overrides?: Partial<SandboxSshConfig>): SandboxSshConfig;
+//#endregion
+//#region src/plugin-sdk/test-helpers/bundled-plugin-paths.d.ts
+declare const BUNDLED_PLUGIN_ROOT_DIR = "extensions";
+declare const BUNDLED_PLUGIN_PATH_PREFIX = "extensions/";
+declare const BUNDLED_PLUGIN_TEST_GLOB = "extensions/**/*.test.ts";
+declare function bundledPluginRoot(pluginId: string): string;
+declare function bundledPluginFile(pluginId: string, relativePath: string): string;
+declare function bundledPluginDirPrefix(pluginId: string, relativeDir: string): string;
+declare function bundledPluginRootAt(baseDir: string, pluginId: string): string;
+declare function bundledPluginFileAt(baseDir: string, pluginId: string, relativePath: string): string;
+declare function bundledDistPluginRoot(pluginId: string): string;
+declare function bundledDistPluginFile(pluginId: string, relativePath: string): string;
+declare function bundledDistPluginRootAt(baseDir: string, pluginId: string): string;
+declare function bundledDistPluginFileAt(baseDir: string, pluginId: string, relativePath: string): string;
+declare function installedPluginRoot(baseDir: string, pluginId: string): string;
+declare function repoInstallSpec(pluginId: string): string;
+//#endregion
+//#region src/plugin-sdk/test-helpers/import-fresh.d.ts
+declare function importFreshModule<TModule>(from: string, specifier: string): Promise<TModule>;
+//#endregion
+export { createSandboxPruneConfig as _, bundledDistPluginFile as a, bundledDistPluginRootAt as c, bundledPluginFileAt as d, bundledPluginRoot as f, createSandboxBrowserConfig as g, repoInstallSpec as h, BUNDLED_PLUGIN_TEST_GLOB as i, bundledPluginDirPrefix as l, installedPluginRoot as m, BUNDLED_PLUGIN_PATH_PREFIX as n, bundledDistPluginFileAt as o, bundledPluginRootAt as p, BUNDLED_PLUGIN_ROOT_DIR as r, bundledDistPluginRoot as s, importFreshModule as t, bundledPluginFile as u, createSandboxSshConfig as v };

package/dist/test-support-BVVgDSdq.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/testing-BhkgXw7E.d.ts

@@ -0,0 +1,84 @@
+import { Ut as AcpRuntimeEvent, r as DaoCoreConfig, zt as AcpRuntime } from "./types.daocore-CNMq809i.js";
+import { n as MsgContext } from "./templating-Bw49ZLzH.js";
+import { n as CommandHandler, r as HandleCommandsParams } from "./commands-types-4LhvvAkC.js";
+//#region src/infra/runtime-guard.d.ts
+type Semver = {
+  major: number;
+  minor: number;
+  patch: number;
+};
+declare function parseSemver(version: string | null): Semver | null;
+declare function isAtLeast(version: Semver | null, minimum: Semver): boolean;
+//#endregion
+//#region src/plugins/min-host-version.d.ts
+type MinHostVersionRequirement = {
+  raw: string;
+  minimumLabel: string;
+};
+declare function parseMinHostVersionRequirement(raw: unknown, options?: {
+  allowLegacyBareSemver?: boolean;
+}): MinHostVersionRequirement | null;
+//#endregion
+//#region src/plugins/provider-runtime.test-support.d.ts
+declare const openaiCodexCatalogEntries: {
+  provider: string;
+  id: string;
+  name: string;
+}[];
+declare const expectedAugmentedOpenaiCodexCatalogEntriesWithGpt55: {
+  provider: string;
+  id: string;
+  name: string;
+}[];
+declare const expectedOpenaiPluginCodexCatalogEntriesWithGpt55: {
+  provider: string;
+  id: string;
+  name: string;
+}[];
+declare function expectCodexMissingAuthHint(buildProviderMissingAuthMessageWithPlugin: (params: {
+  provider: string;
+  env: NodeJS.ProcessEnv;
+  context: {
+    env: NodeJS.ProcessEnv;
+    provider: string;
+    listProfileIds: (providerId: string) => string[];
+  };
+}) => string | undefined, expectedModel?: string): void;
+declare function expectAugmentedCodexCatalog(augmentModelCatalogWithProviderPlugins: (params: {
+  env: NodeJS.ProcessEnv;
+  context: {
+    env: NodeJS.ProcessEnv;
+    entries: typeof openaiCodexCatalogEntries;
+  };
+}) => Promise<unknown>, expectedEntries?: {
+  provider: string;
+  id: string;
+  name: string;
+}[]): Promise<void>;
+//#endregion
+//#region src/plugins/runtime-sidecar-paths.d.ts
+declare function assertUniqueValues<T extends string>(values: readonly T[], label: string): readonly T[];
+declare const BUNDLED_RUNTIME_SIDECAR_PATHS: readonly string[];
+//#endregion
+//#region src/acp/runtime/adapter-contract.testkit.d.ts
+type AcpRuntimeAdapterContractParams = {
+  createRuntime: () => Promise<AcpRuntime> | AcpRuntime;
+  agentId?: string;
+  successPrompt?: string;
+  errorPrompt?: string;
+  includeControlChecks?: boolean;
+  assertSuccessEvents?: (events: AcpRuntimeEvent[]) => void | Promise<void>;
+  assertErrorOutcome?: (params: {
+    events: AcpRuntimeEvent[];
+    thrown: unknown;
+  }) => void | Promise<void>;
+};
+declare function runAcpRuntimeAdapterContract(params: AcpRuntimeAdapterContractParams): Promise<void>;
+//#endregion
+//#region src/auto-reply/reply/commands-acp.d.ts
+declare const handleAcpCommand: CommandHandler;
+//#endregion
+//#region src/auto-reply/reply/commands-spawn.test-harness.d.ts
+declare function buildCommandTestParams(commandBody: string, cfg: DaoCoreConfig, ctxOverrides?: Partial<MsgContext>): HandleCommandsParams;
+//#endregion
+export { assertUniqueValues as a, expectedAugmentedOpenaiCodexCatalogEntriesWithGpt55 as c, isAtLeast as d, parseSemver as f, BUNDLED_RUNTIME_SIDECAR_PATHS as i, expectedOpenaiPluginCodexCatalogEntriesWithGpt55 as l, handleAcpCommand as n, expectAugmentedCodexCatalog as o, runAcpRuntimeAdapterContract as r, expectCodexMissingAuthHint as s, buildCommandTestParams as t, parseMinHostVersionRequirement as u };

package/dist/thinking-policy-CaATk4lD.d.ts

@@ -0,0 +1,5 @@
+import { Zn as ProviderThinkingProfile } from "./types-DEEPn4W72.js";
+//#region extensions/fireworks/thinking-policy.d.ts
+declare function resolveFireworksThinkingProfile(modelId: string): ProviderThinkingProfile | undefined;
+//#endregion
+export { resolveFireworksThinkingProfile as t };

package/dist/thread-bindings-4TKHMzkJ.d.ts

@@ -0,0 +1,66 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as BindingTargetKind } from "./session-binding.types-cd2c9es6.js";
+//#region extensions/feishu/src/conversation-id.d.ts
+type FeishuGroupSessionScope = "group" | "group_sender" | "group_topic" | "group_topic_sender";
+declare function buildFeishuConversationId(params: {
+  chatId: string;
+  scope: FeishuGroupSessionScope;
+  senderOpenId?: string;
+  topicId?: string;
+}): string;
+declare function parseFeishuTargetId(raw: unknown): string | undefined;
+declare function parseFeishuDirectConversationId(raw: unknown): string | undefined;
+declare function parseFeishuConversationId(params: {
+  conversationId: string;
+  parentConversationId?: string;
+}): {
+  canonicalConversationId: string;
+  chatId: string;
+  topicId?: string;
+  senderOpenId?: string;
+  scope: FeishuGroupSessionScope;
+} | null;
+declare function buildFeishuModelOverrideParentCandidates(parentConversationId?: string | null): string[];
+//#endregion
+//#region extensions/feishu/src/thread-bindings.d.ts
+type FeishuBindingTargetKind = "subagent" | "acp";
+type FeishuThreadBindingRecord = {
+  accountId: string;
+  conversationId: string;
+  parentConversationId?: string;
+  deliveryTo?: string;
+  deliveryThreadId?: string;
+  targetKind: FeishuBindingTargetKind;
+  targetSessionKey: string;
+  agentId?: string;
+  label?: string;
+  boundBy?: string;
+  boundAt: number;
+  lastActivityAt: number;
+};
+type FeishuThreadBindingManager = {
+  accountId: string;
+  getByConversationId: (conversationId: string) => FeishuThreadBindingRecord | undefined;
+  listBySessionKey: (targetSessionKey: string) => FeishuThreadBindingRecord[];
+  bindConversation: (params: {
+    conversationId: string;
+    parentConversationId?: string;
+    targetKind: BindingTargetKind;
+    targetSessionKey: string;
+    metadata?: Record<string, unknown>;
+  }) => FeishuThreadBindingRecord | null;
+  touchConversation: (conversationId: string, at?: number) => FeishuThreadBindingRecord | null;
+  unbindConversation: (conversationId: string) => FeishuThreadBindingRecord | null;
+  unbindBySessionKey: (targetSessionKey: string) => FeishuThreadBindingRecord[];
+  stop: () => void;
+};
+declare function createFeishuThreadBindingManager(params: {
+  accountId?: string;
+  cfg: DaoCoreConfig;
+}): FeishuThreadBindingManager;
+declare function getFeishuThreadBindingManager(accountId?: string): FeishuThreadBindingManager | null;
+declare const testing: {
+  resetFeishuThreadBindingsForTests(): void;
+};
+//#endregion
+export { buildFeishuConversationId as a, parseFeishuDirectConversationId as c, FeishuGroupSessionScope as i, parseFeishuTargetId as l, getFeishuThreadBindingManager as n, buildFeishuModelOverrideParentCandidates as o, testing as r, parseFeishuConversationId as s, createFeishuThreadBindingManager as t };

package/dist/thread-bindings-Bp1N2bz7.d.ts

@@ -0,0 +1,56 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { n as PinnedDispatcherPolicy, o as SsrFPolicy } from "./ssrf-skjEI_i5.js";
+import { c as ChannelSetupWizardAdapter } from "./setup-wizard-types-gkEuMVal.js";
+import { H as ChannelSetupAdapter } from "./types.adapters-Ca58O0tl.js";
+import { t as MatrixClient } from "./sdk-Ddt9_En6.js";
+import { t as MatrixThreadBindingManager } from "./thread-bindings-shared-Ddk3opvy.js";
+
+//#region extensions/matrix/src/setup-core.d.ts
+type MatrixSetupWizardModule = {
+  matrixSetupWizard: ChannelSetupWizardAdapter;
+};
+declare function createMatrixSetupWizardProxy(loadWizardModule: () => Promise<MatrixSetupWizardModule>): ChannelSetupWizardAdapter;
+declare const matrixSetupAdapter: ChannelSetupAdapter;
+//#endregion
+//#region extensions/matrix/src/onboarding.d.ts
+declare const matrixOnboardingAdapter: ChannelSetupWizardAdapter;
+//#endregion
+//#region extensions/matrix/src/matrix/client/types.d.ts
+/**
+ * Authenticated Matrix configuration.
+ * Note: deviceId is NOT included here because it's implicit in the accessToken.
+ * Matrix storage reuses the most complete account-scoped root it can find for the
+ * same homeserver/user/account tuple so token refreshes do not strand prior state.
+ * If the device identity itself changes or crypto storage is lost, crypto state may
+ * still need to be recreated together with the new access token.
+ */
+type MatrixAuth = {
+  accountId: string;
+  homeserver: string;
+  userId: string;
+  accessToken: string;
+  password?: string;
+  deviceId?: string;
+  deviceName?: string;
+  initialSyncLimit?: number;
+  encryption?: boolean;
+  allowPrivateNetwork?: boolean;
+  ssrfPolicy?: SsrFPolicy;
+  dispatcherPolicy?: PinnedDispatcherPolicy;
+};
+//#endregion
+//#region extensions/matrix/src/matrix/thread-bindings.d.ts
+declare function createMatrixThreadBindingManager(params: {
+  cfg: DaoCoreConfig;
+  accountId: string;
+  auth: MatrixAuth;
+  client: MatrixClient;
+  env?: NodeJS.ProcessEnv;
+  stateDir?: string;
+  idleTimeoutMs: number;
+  maxAgeMs: number;
+  enableSweeper?: boolean;
+  logVerboseMessage?: (message: string) => void;
+}): Promise<MatrixThreadBindingManager>;
+//#endregion
+export { matrixSetupAdapter as i, matrixOnboardingAdapter as n, createMatrixSetupWizardProxy as r, createMatrixThreadBindingManager as t };

package/dist/thread-bindings-CsWIJiRb.d.ts

@@ -0,0 +1,82 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { t as AcpSessionStoreEntry } from "./session-meta-B484DkOM.js";
+import { d as ThreadBindingRecord, f as ThreadBindingTargetKind } from "./thread-bindings.manager-TzexfcRq.js";
+//#region extensions/discord/src/monitor/thread-bindings.persona.d.ts
+declare function resolveThreadBindingPersona(params: {
+  label?: string;
+  agentId?: string;
+}): string;
+declare function resolveThreadBindingPersonaFromRecord(record: ThreadBindingRecord): string;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.config.d.ts
+declare function resolveDiscordThreadBindingIdleTimeoutMs(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+}): number;
+declare function resolveDiscordThreadBindingMaxAgeMs(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+}): number;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.session-updates.d.ts
+declare function setThreadBindingIdleTimeoutBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  idleTimeoutMs: number;
+}): ThreadBindingRecord[];
+declare function setThreadBindingMaxAgeBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  maxAgeMs: number;
+}): ThreadBindingRecord[];
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.lifecycle.d.ts
+type AcpThreadBindingReconciliationResult = {
+  checked: number;
+  removed: number;
+  staleSessionKeys: string[];
+};
+type AcpThreadBindingHealthStatus = "healthy" | "stale" | "uncertain";
+type AcpThreadBindingHealthProbe = (params: {
+  cfg: DaoCoreConfig;
+  accountId: string;
+  sessionKey: string;
+  binding: ThreadBindingRecord;
+  session: AcpSessionStoreEntry;
+}) => Promise<{
+  status: AcpThreadBindingHealthStatus;
+  reason?: string;
+}>;
+declare function listThreadBindingsForAccount(accountId?: string): ThreadBindingRecord[];
+declare function listThreadBindingsBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  targetKind?: ThreadBindingTargetKind;
+}): ThreadBindingRecord[];
+declare function autoBindSpawnedDiscordSubagent(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+  channel?: string;
+  to?: string;
+  threadId?: string | number;
+  childSessionKey: string;
+  agentId: string;
+  label?: string;
+  boundBy?: string;
+}): Promise<ThreadBindingRecord | null>;
+declare function unbindThreadBindingsBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  targetKind?: ThreadBindingTargetKind;
+  reason?: string;
+  sendFarewell?: boolean;
+  farewellText?: string;
+}): ThreadBindingRecord[];
+declare function reconcileAcpThreadBindingsOnStartup(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+  sendFarewell?: boolean;
+  healthProbe?: AcpThreadBindingHealthProbe;
+}): Promise<AcpThreadBindingReconciliationResult>;
+//#endregion
+export { reconcileAcpThreadBindingsOnStartup as a, setThreadBindingMaxAgeBySessionKey as c, resolveThreadBindingPersona as d, resolveThreadBindingPersonaFromRecord as f, listThreadBindingsForAccount as i, resolveDiscordThreadBindingIdleTimeoutMs as l, autoBindSpawnedDiscordSubagent as n, unbindThreadBindingsBySessionKey as o, listThreadBindingsBySessionKey as r, setThreadBindingIdleTimeoutBySessionKey as s, AcpThreadBindingReconciliationResult as t, resolveDiscordThreadBindingMaxAgeMs as u };

package/dist/thread-bindings-DSnV9kIf.d.ts

@@ -0,0 +1,60 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+//#region extensions/telegram/src/thread-bindings.d.ts
+type TelegramBindingTargetKind = "subagent" | "acp";
+type TelegramThreadBindingRecord = {
+  accountId: string;
+  conversationId: string;
+  targetKind: TelegramBindingTargetKind;
+  targetSessionKey: string;
+  agentId?: string;
+  label?: string;
+  boundBy?: string;
+  boundAt: number;
+  lastActivityAt: number;
+  idleTimeoutMs?: number;
+  maxAgeMs?: number;
+  metadata?: Record<string, unknown>;
+};
+type TelegramThreadBindingManager = {
+  accountId: string;
+  shouldPersistMutations: () => boolean;
+  getIdleTimeoutMs: () => number;
+  getMaxAgeMs: () => number;
+  getByConversationId: (conversationId: string) => TelegramThreadBindingRecord | undefined;
+  listBySessionKey: (targetSessionKey: string) => TelegramThreadBindingRecord[];
+  listBindings: () => TelegramThreadBindingRecord[];
+  touchConversation: (conversationId: string, at?: number) => TelegramThreadBindingRecord | null;
+  unbindConversation: (params: {
+    conversationId: string;
+    reason?: string;
+    sendFarewell?: boolean;
+  }) => TelegramThreadBindingRecord | null;
+  unbindBySessionKey: (params: {
+    targetSessionKey: string;
+    reason?: string;
+    sendFarewell?: boolean;
+  }) => TelegramThreadBindingRecord[];
+  stop: () => void;
+};
+declare function createTelegramThreadBindingManager(params: {
+  cfg: DaoCoreConfig;
+  accountId?: string;
+  persist?: boolean;
+  idleTimeoutMs?: number;
+  maxAgeMs?: number;
+  enableSweeper?: boolean;
+}): TelegramThreadBindingManager;
+declare function getTelegramThreadBindingManager(accountId?: string): TelegramThreadBindingManager | null;
+declare function setTelegramThreadBindingIdleTimeoutBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  idleTimeoutMs: number;
+}): TelegramThreadBindingRecord[];
+declare function setTelegramThreadBindingMaxAgeBySessionKey(params: {
+  targetSessionKey: string;
+  accountId?: string;
+  maxAgeMs: number;
+}): TelegramThreadBindingRecord[];
+declare function resetTelegramThreadBindingsForTests(): Promise<void>;
+//#endregion
+export { setTelegramThreadBindingMaxAgeBySessionKey as a, setTelegramThreadBindingIdleTimeoutBySessionKey as i, getTelegramThreadBindingManager as n, resetTelegramThreadBindingsForTests as r, createTelegramThreadBindingManager as t };