@rivus/gateway 0.16.2

package/dist/chunks/index.d.ts

@@ -0,0 +1,4703 @@
+import { A as BackgroundSessionLease, C as ClaimBackgroundSessionInput, E as BackgroundSessionSnapshot, N as BackgroundSessionMemoryScope, O as BackgroundSessionPhase, P as BackgroundSessionId, S as BackgroundSession, T as SuspendBackgroundSessionInput, b as BackgroundSessionDeliveryRecord, g as BackgroundSessionRepository$1, h as BackgroundSessionLeaseStaleOrAbsent, m as BackgroundSessionLeaseRequirement, p as BackgroundSessionLeasePrecondition, r as BackgroundSessionService, w as CreateBackgroundSessionInput, x as BackgroundSessionDeliveryStore } from "./background-session-service.js";
+import { Effect } from "effect";
+import { ActiveAgentRun, AgentClock, AgentDomainEvent, AgentDomainEventSink, AgentEventLog, AgentExecutionControlPort, AgentHarness, AgentHarnessAvailability, AgentHistory, AgentInvocationOrigin, AgentLoopInput, AgentMemoryError, AgentRunId, AgentRunState, AgentRunUpdate, AgentRunUpdateHandler, AuthorizationPolicyState, InvalidInvocationAuthority, InvocationAuthorityRef, InvocationToolGrantSet, LegacyAgentLoop, LegacyAgentMemoryHandle as AgentMemoryHandle, LegacyAgentMemoryService, LegacyAgentMemoryService as AgentMemoryService, LegacyAgentMemorySnapshot, LegacyInvocationAuthorityRef as InvocationAuthorityRef$1, LegacyToolOperationLedger as ToolOperationLedger$1, MemorySearchQuery, ModelBinding, ModelBinding as ModelBinding$1, ModelChangeBoundaryDeadlineError, ModelChangeClock, ModelChangeClock as ModelChangeClock$1, ModelChangeExecutionBudget, ModelChangePaidCallKind, ModelChangePaidCallKind as ModelChangePaidCallKind$1, ModelChangeRestoreResult, ModelChangeRuntimeContext, ModelChangeRuntimePort, ModelChangeRuntimePort as ModelChangeRuntimePort$1, ModelChangeValidationResult, ModelReference, ModelReference as ModelReference$1, NormalizedAgentInvocation, PromptCommand, RecoveryAction, RegisteredRivusSkill, RegisteredRivusTool, RivusHostToolDescriptor, RivusMemoryScope, RivusResolvedToolDescriptor, RivusRuntimeToolGrantSet, RivusRuntimeToolGrantSet as RivusRuntimeToolGrantSet$1, RivusRuntimeToolId, RivusSkillDescriptor, RivusSkillGrantSet, RivusToolDescriptor, RivusToolGrantSet, RivusToolRisk, RunIdGenerator, SessionKey, StandardAgentRunResult, ToolApprovalRequest, ToolExecutionRequest, ToolInputDigest, ToolInvocationDenied as ToolInvocationDenied$1, ToolOperationLedger, WorkspaceInstructionsRequest, WorkspaceInstructionsView } from "@rivus/runtime";
+import { PiManagedRunProvider, PiManagedRunProviderResult, PiThinkingLevel, PiToolApprovalGateway, createPiModelRuntime } from "@rivus/runtime/pi";
+import { PeriodicEffectLoop } from "@rivus/platform/concurrency";
+
+//#region src/core/domain/human-interaction/aggregate/snapshot.d.ts
+type HumanInteractionId$1 = string;
+type HumanInteractionToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
+interface HumanInteractionActor$1 {
+  readonly openId: string;
+  readonly tenantKey: string;
+}
+interface HumanInteractionFact$1 {
+  readonly label: string;
+  readonly value: string;
+}
+interface ToolApprovalBinding$1 {
+  readonly agentId: string;
+  readonly callId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly risk: HumanInteractionToolRisk;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly tenantKey: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface HumanInteractionBase$1 {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly createdAt: string;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact$1>;
+  readonly id: HumanInteractionId$1;
+  readonly instanceId: string;
+  readonly revision: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+}
+interface PendingHumanInteractionState$1 {
+  readonly status: "pending";
+}
+interface ApprovedHumanInteractionState$1 {
+  readonly actor: HumanInteractionActor$1;
+  readonly consumedAt?: string;
+  readonly resolvedAt: string;
+  readonly status: "approved";
+}
+interface RejectedHumanInteractionState$1 {
+  readonly actor: HumanInteractionActor$1;
+  readonly resolvedAt: string;
+  readonly status: "rejected";
+}
+interface SelectedHumanInteractionState$1 {
+  readonly actor: HumanInteractionActor$1;
+  readonly optionId: string;
+  readonly resolvedAt: string;
+  readonly status: "selected";
+}
+interface ExpiredHumanInteractionState$1 {
+  readonly expiredAt: string;
+  readonly status: "expired";
+}
+interface CancelledHumanInteractionState$1 {
+  readonly cancelledAt: string;
+  readonly reason?: string;
+  readonly status: "cancelled";
+}
+type ToolApprovalInteractionState$1 = PendingHumanInteractionState$1 | ApprovedHumanInteractionState$1 | RejectedHumanInteractionState$1 | ExpiredHumanInteractionState$1 | CancelledHumanInteractionState$1;
+interface ToolApprovalInteraction$2 extends HumanInteractionBase$1 {
+  readonly kind: "tool-approval";
+  readonly request: Omit<ToolApprovalBinding$1, "agentId" | "instanceId" | "runId" | "sessionKey" | "tenantKey">;
+  readonly state: ToolApprovalInteractionState$1;
+}
+interface UserDecisionOption$1 {
+  readonly description: string;
+  readonly id: string;
+  readonly label: string;
+}
+type UserDecisionInteractionState$1 = PendingHumanInteractionState$1 | SelectedHumanInteractionState$1 | RejectedHumanInteractionState$1 | ExpiredHumanInteractionState$1 | CancelledHumanInteractionState$1;
+interface UserDecisionInteraction$2 extends HumanInteractionBase$1 {
+  readonly kind: "user-decision";
+  readonly options: ReadonlyArray<UserDecisionOption$1>;
+  readonly recommendedOptionId?: string;
+  readonly state: UserDecisionInteractionState$1;
+}
+type HumanInteraction$2 = ToolApprovalInteraction$2 | UserDecisionInteraction$2;
+type HumanInteractionSnapshot = HumanInteraction$2;
+type HumanInteractionResolutionAction$1 = "approve" | "reject" | "select";
+type HumanInteractionTransition$1 = {
+  readonly action: HumanInteractionResolutionAction$1;
+  readonly actor: HumanInteractionActor$1;
+  readonly now: string;
+  readonly optionId?: string;
+  readonly type: "resolve";
+} | {
+  readonly binding: ToolApprovalBinding$1;
+  readonly now: string;
+  readonly type: "consume-approval";
+} | {
+  readonly now: string;
+  readonly reason?: string;
+  readonly type: "cancel";
+};
+interface RequestToolApprovalInput$1 {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact$1>;
+  readonly instanceId: string;
+  readonly interactionId: string;
+  readonly request: {
+    readonly callId: string;
+    readonly inputDigest: string;
+    readonly operationId: string;
+    readonly risk: HumanInteractionToolRisk;
+    readonly toolId: string;
+    readonly toolVersion: string;
+  };
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+}
+interface RequestUserDecisionInput$1 {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact$1>;
+  readonly instanceId: string;
+  readonly interactionId: string;
+  readonly options: ReadonlyArray<UserDecisionOption$1>;
+  readonly recommendedOptionId?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+}
+//#endregion
+//#region src/core/domain/human-interaction/aggregate/human-interaction.d.ts
+type HumanInteractionTransitionResult = Readonly<{
+  readonly events: ReadonlyArray<never>;
+  readonly state: HumanInteraction$1;
+}>;
+type HumanInteraction$1 = HumanInteractionRoot & HumanInteraction$2;
+type ToolApprovalInteraction$1 = HumanInteractionRoot & ToolApprovalInteraction$2;
+type UserDecisionInteraction$1 = HumanInteractionRoot & UserDecisionInteraction$2;
+type ResolveHumanInteractionInput$2 = Readonly<{
+  readonly action: HumanInteractionResolutionAction$1;
+  readonly actor: HumanInteractionActor$1;
+  readonly now: string;
+  readonly optionId?: string;
+}>;
+type ConsumeHumanInteractionInput = Readonly<{
+  readonly binding: ToolApprovalBinding$1;
+  readonly now: string;
+}>;
+type CancelHumanInteractionInput = Readonly<{
+  readonly now: string;
+  readonly reason?: string;
+}>;
+type CreateHumanInteractionInput = (RequestToolApprovalInput$1 & {
+  readonly kind: "tool-approval";
+}) | (RequestUserDecisionInput$1 & {
+  readonly kind: "user-decision";
+});
+declare class HumanInteractionRoot {
+  #private;
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly createdAt: string;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteraction$2["facts"][number]>;
+  readonly id: string;
+  readonly instanceId: string;
+  readonly kind: "tool-approval" | "user-decision";
+  readonly revision: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly state: HumanInteraction$2["state"];
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+  private constructor();
+  static createToolApproval(input: RequestToolApprovalInput$1, createdAt: string): ToolApprovalInteraction$1;
+  static createUserDecision(input: RequestUserDecisionInput$1, createdAt: string): UserDecisionInteraction$1;
+  static create(input: CreateHumanInteractionInput, createdAt: string): HumanInteraction$1;
+  static restore(value: unknown): HumanInteraction$1;
+  resolve(input: ResolveHumanInteractionInput$2): HumanInteractionTransitionResult;
+  consume(input: ConsumeHumanInteractionInput): HumanInteractionTransitionResult;
+  consumeApproval(input: ConsumeHumanInteractionInput): HumanInteractionTransitionResult;
+  cancel(input: CancelHumanInteractionInput): HumanInteractionTransitionResult;
+  isSameRequest(other: HumanInteraction$1): boolean;
+  hasSameRequest(other: HumanInteraction$1): boolean;
+  isSamePersistedIdentity(other: HumanInteraction$1): boolean;
+  validateTransitionTo(next: HumanInteraction$1): boolean;
+  toSnapshot(): HumanInteraction$2;
+  private toJSON;
+  private transition;
+}
+//#endregion
+//#region src/core/application/human-interaction/ports/human-interaction-contracts.d.ts
+interface HumanInteractionClock$1 {
+  now(): string;
+}
+interface ResolveHumanInteractionInput$1 {
+  readonly action: HumanInteractionResolutionAction$1;
+  readonly actor: HumanInteractionActor$1;
+  readonly interactionId: string;
+  readonly optionId?: string;
+}
+interface ConsumeToolApprovalInput$1 {
+  readonly approvalId: string;
+  readonly binding: ToolApprovalBinding$1;
+}
+interface HumanInteractionServiceContract<Interaction, ToolApprovalInteraction = Interaction, UserDecisionInteraction = Interaction, ToolApprovalInput = RequestToolApprovalInput$1, UserDecisionInput = RequestUserDecisionInput$1, ResolveInput = ResolveHumanInteractionInput$1, ConsumeInput = ConsumeToolApprovalInput$1> {
+  consumeToolApproval(input: ConsumeInput): Effect.Effect<boolean, unknown>;
+  get(interactionId: string): Effect.Effect<Interaction | undefined, unknown>;
+  resolve(input: ResolveInput): Effect.Effect<Interaction, unknown>;
+  requestToolApproval(input: ToolApprovalInput): Effect.Effect<ToolApprovalInteraction, unknown>;
+  requestUserDecision(input: UserDecisionInput): Effect.Effect<UserDecisionInteraction, unknown>;
+  waitForResolution(input: {
+    readonly interactionId: string;
+    readonly signal?: AbortSignal;
+  }): Effect.Effect<Interaction, unknown>;
+}
+interface HumanInteractionServiceOptionsContract<Clock, Presenter, Repository> {
+  readonly clock: Clock;
+  readonly presenter: Presenter;
+  readonly repository: Repository;
+  readonly sleep?: (ms: number) => Promise<void>;
+}
+//#endregion
+//#region src/core/application/human-interaction/ports/human-interaction-presenter.d.ts
+interface HumanInteractionPresenterContract<Interaction> {
+  present(interaction: Interaction): Effect.Effect<void, unknown>;
+}
+type HumanInteractionPresenter$1 = HumanInteractionPresenterContract<HumanInteraction$1>;
+//#endregion
+//#region src/core/application/human-interaction/ports/human-interaction-repository.d.ts
+declare class HumanInteractionRepositoryError extends Error {
+  readonly operation: "create" | "get" | "update";
+  readonly cause?: unknown | undefined;
+  readonly name = "HumanInteractionRepositoryError";
+  constructor(operation: "create" | "get" | "update", message: string, cause?: unknown | undefined);
+}
+interface HumanInteractionRepositoryContract<Interaction> {
+  create(interaction: Interaction): Effect.Effect<void, HumanInteractionRepositoryError>;
+  get(id: HumanInteractionId$1): Effect.Effect<Interaction | undefined, HumanInteractionRepositoryError>;
+  update(id: HumanInteractionId$1, transition: (current: Interaction) => Interaction): Effect.Effect<Interaction, HumanInteractionRepositoryError>;
+}
+type HumanInteractionRepository$1 = HumanInteractionRepositoryContract<HumanInteraction$1>;
+//#endregion
+//#region src/core/application/human-interaction/commands/human-interaction-service.d.ts
+type HumanInteractionService$1 = HumanInteractionServiceContract<HumanInteraction$1, ToolApprovalInteraction$1, UserDecisionInteraction$1>;
+type HumanInteractionServiceOptions$1 = HumanInteractionServiceOptionsContract<HumanInteractionClock$1, HumanInteractionPresenter$1, HumanInteractionRepository$1>;
+declare function createHumanInteractionService$1(options: HumanInteractionServiceOptions$1): HumanInteractionService$1;
+//#endregion
+//#region src/core/application/run-presentation/projection/presented-value.d.ts
+type PresentedValue = {
+  readonly kind: "boolean";
+  readonly value: boolean;
+} | {
+  readonly entries: ReadonlyArray<{
+    readonly key: string;
+    readonly value: PresentedValue;
+  }>;
+  readonly kind: "record";
+  readonly omittedEntries: number;
+} | {
+  readonly items: ReadonlyArray<PresentedValue>;
+  readonly kind: "list";
+  readonly omittedItems: number;
+} | {
+  readonly kind: "null";
+} | {
+  readonly kind: "number";
+  readonly value: number;
+} | {
+  readonly kind: "redacted";
+  readonly reason: "sensitive-key" | "sensitive-value";
+} | {
+  readonly kind: "text";
+  readonly omittedCharacters: number;
+  readonly value: string;
+} | {
+  readonly kind: "unsupported";
+  readonly valueType: string;
+};
+interface PresentedValueOptions {
+  readonly maxCollectionItems?: number;
+  readonly maxDepth?: number;
+  readonly maxNodes?: number;
+  readonly maxStringCharacters?: number;
+}
+declare function createPresentedValue(value: unknown, options?: PresentedValueOptions): PresentedValue;
+//#endregion
+//#region src/core/application/run-presentation/projection/run-presentation.d.ts
+declare const RUN_PRESENTATION_SCHEMA_VERSION: 2;
+type AgentRunId$1 = string;
+type RunPresentationPhase = "cancelled" | "completed" | "failed" | "running";
+type PresentationStepStatus = "completed" | "failed" | "running";
+interface PresentationStepBase {
+  readonly durationMs?: number;
+  readonly endedAt?: string;
+  readonly id: string;
+  readonly label: string;
+  readonly startedAt: string;
+  readonly status: PresentationStepStatus;
+}
+interface AssistantPresentationStep extends PresentationStepBase {
+  readonly kind: "assistant";
+  readonly text: string;
+}
+interface ModelPresentationStep extends PresentationStepBase {
+  readonly kind: "model";
+  readonly model: string;
+  readonly provider: string;
+}
+interface SkillPresentationStep extends PresentationStepBase {
+  readonly kind: "skill";
+  readonly skillId: string;
+}
+interface ToolPresentationStep extends PresentationStepBase {
+  readonly error?: PresentedValue;
+  readonly input: PresentedValue;
+  readonly kind: "tool";
+  readonly output?: PresentedValue;
+  readonly skillId?: string;
+  readonly toolName: string;
+}
+interface ResponsePresentationStep extends PresentationStepBase {
+  readonly kind: "response";
+}
+type PresentationStep = AssistantPresentationStep | ModelPresentationStep | ResponsePresentationStep | SkillPresentationStep | ToolPresentationStep;
+interface RunPresentation {
+  readonly answer: {
+    readonly format: "markdown";
+    readonly text: string;
+  };
+  readonly omittedStepCount: number;
+  readonly phase: RunPresentationPhase;
+  readonly revision: number;
+  readonly runId: AgentRunId$1;
+  readonly schemaVersion: typeof RUN_PRESENTATION_SCHEMA_VERSION;
+  readonly steps: ReadonlyArray<PresentationStep>;
+  readonly totalStepCount: number;
+  readonly totalToolCallCount: number;
+}
+declare function hasInspectableRunProgress(presentation: RunPresentation): boolean;
+//#endregion
+//#region src/core/application/message-gateway/contracts/message-gateway-contracts.d.ts
+/**
+ * Normalized prompt action. The invocation is already normalized via the
+ * gateway identity contract; the legacy AgentInvocationOrigin is
+ * adapted at the channel boundary and never reaches the gateway execution path.
+ */
+interface GatewayPromptAction {
+  readonly invocation?: NormalizedAgentInvocation;
+  readonly messageId: string;
+  readonly receiveId: string;
+  readonly sessionKey: SessionKey;
+  readonly sourceNamespace: string;
+  readonly text: string;
+  readonly type: "prompt";
+}
+interface GatewayCancelAction {
+  /**
+   * Optional dedupe identity. When present, the gateway uses this (scoped by
+   * sourceNamespace) for deduplication instead of messageId. Card actions use
+   * their independent token so they do not collide with the source message
+   * that triggered them.
+   */
+  readonly dedupeId?: string;
+  readonly messageId: string;
+  readonly reason: string;
+  readonly runId?: AgentRunId;
+  readonly sessionKey?: SessionKey;
+  readonly sourceNamespace: string;
+  /** When true, the gateway does not emit a cancellation reply. Used by card
+   *  actions which have their own reaction-based acknowledgement. */
+  readonly silent?: boolean;
+  readonly type: "cancel";
+}
+interface GatewaySteerAction {
+  readonly messageId: string;
+  readonly sessionKey: SessionKey;
+  readonly sourceNamespace: string;
+  readonly text: string;
+  readonly type: "steer";
+}
+interface GatewayResetAction {
+  readonly messageId: string;
+  readonly previousSessionKey: SessionKey;
+  readonly reason: string;
+  readonly sessionKey: SessionKey;
+  readonly sourceNamespace: string;
+  readonly type: "reset";
+}
+interface GatewayResolveInteractionAction {
+  readonly action: ResolveHumanInteractionInput$1["action"];
+  readonly actor: ResolveHumanInteractionInput$1["actor"];
+  readonly dedupeId?: string;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly optionId?: string;
+  readonly sourceNamespace: string;
+  readonly type: "resolve_interaction";
+}
+type GatewayAction = GatewayPromptAction | GatewayCancelAction | GatewaySteerAction | GatewayResetAction | GatewayResolveInteractionAction;
+interface GatewayRunResult {
+  readonly finalText: string;
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+}
+interface GatewaySkippedResult {
+  readonly messageId: string;
+  readonly reason: "duplicate";
+  readonly skipped: true;
+}
+interface GatewayCancelResult {
+  readonly cancelled: boolean;
+  readonly messageId: string;
+  readonly reason?: "not_active";
+  readonly runId?: AgentRunId;
+}
+interface GatewaySteeredResult {
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+  readonly steered: true;
+}
+interface GatewayInteractionResult {
+  readonly interaction: HumanInteractionSnapshot;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly resolved: true;
+}
+interface GatewayResetResult {
+  readonly messageId: string;
+  readonly previousSessionKey: SessionKey;
+  readonly reset: true;
+  readonly sessionKey: SessionKey;
+}
+type GatewayActionResult = GatewayRunResult | GatewaySkippedResult | GatewayCancelResult | GatewaySteeredResult | GatewayInteractionResult | GatewayResetResult;
+/**
+ * Normalized execution command. Uses the canonical NormalizedAgentInvocation
+ * rather than the legacy AgentInvocationOrigin DTO.
+ */
+interface GatewayPromptCommand {
+  readonly invocation?: NormalizedAgentInvocation;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+/**
+ * Execution port. The runtime never receives receiveId or reply targets; those
+ * are bound to the presentation and reply ports only.
+ */
+interface GatewayExecutionPort extends AgentExecutionControlPort {
+  promptWithUpdates(command: GatewayPromptCommand, onUpdate: (update: AgentRunUpdate) => Effect.Effect<void, unknown>): Effect.Effect<StandardAgentRunResult, unknown>;
+}
+interface GatewayRunPreparation {
+  readonly messageId: string;
+  readonly prompt: string;
+  readonly receiveId: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+/**
+ * Safe presentation update delivered to the presentation port. The Gateway
+ * applies the RunPresentation projection (redacting tool input/result via
+ * PresentedValue) before invoking this port. Raw Tool events never reach the
+ * presentation port through this boundary; only the safe presentation and the
+ * minimal scalar metadata needed for streaming behaviour are passed.
+ */
+interface GatewayPresentationUpdate {
+  readonly errorMessage?: string;
+  readonly eventType: AgentDomainEvent["type"];
+  readonly presentation?: RunPresentation;
+  readonly reason?: string;
+  readonly runId: AgentRunId;
+  readonly text?: string;
+}
+/**
+ * Presentation port. The Gateway owns the safe RunPresentation projection;
+ * the presentation port receives only the safe presentation plus minimal
+ * scalar metadata. Raw tool input/result never passes through this port.
+ */
+interface GatewayPresentationPort {
+  finalizeRun(runId: AgentRunId): Effect.Effect<void>;
+  prepareRun(run: GatewayRunPreparation): Effect.Effect<void, unknown>;
+  publishPresentation(update: GatewayPresentationUpdate): Effect.Effect<void, unknown>;
+}
+/**
+ * Raw observation port. A legacy compatibility hook that receives the original
+ * AgentRunUpdate before safe projection. Used by channels (e.g. Feishu) that
+ * still expose a raw publishRunUpdate callback. Not part of the standard
+ * rendering boundary.
+ */
+interface GatewayObservationPort {
+  observeUpdate(update: AgentRunUpdate): Effect.Effect<void, unknown>;
+}
+/**
+ * Reply port. Channel-specific wording and reaction ACK/fallback live in the
+ * adapter implementation; the gateway only signals the semantic outcome.
+ */
+interface GatewayReplyPort {
+  replyCancelled(messageId: string, hadActiveRun: boolean): Effect.Effect<void, unknown>;
+  replyReset(messageId: string, hadActiveRun: boolean): Effect.Effect<void, unknown>;
+  replySteered(messageId: string): Effect.Effect<void, unknown>;
+}
+interface GatewayHumanInteractionPort {
+  resolve(input: ResolveHumanInteractionInput$1): Effect.Effect<HumanInteractionSnapshot, unknown>;
+}
+/**
+ * Per-execution bindings. The gateway is constructed once with stable execution
+ * and dedupe state; presentation, reply, observation and an optional execution
+ * override are bound to a single execute call so they do not leak across
+ * requests. The gateway only ever sees the normalized command; legacy DTOs are
+ * captured in the adapter's execution port closure.
+ *
+ * Direct message execution:
+ * When `direct` is provided, the gateway owns the full direct-message
+ * lifecycle: it reserves the message identity before any execution, attempts
+ * steering, and falls back to prompting via the adapter-supplied
+ * `preparePrompt` binding. Any failure releases the reserved identity so the
+ * same message can be retried. This keeps the steer→prepare→prompt workflow
+ * and its dedupe lifetime inside a single gateway call rather than split
+ * across adapter-steered multiple execute invocations.
+ *
+ * Control execution (no `direct`):
+ * Cancel/reset/steer use their own marking timing (cancel after execution,
+ * reset before execution, steer after execution+ACK). Cancel and reset retain
+ * the mark on failure so a failed ACK does not allow the same message to
+ * cancel again.
+ */
+interface GatewayDirectExecution {
+  /**
+   * Deferred prompt preparation. Required only for direct prompt actions;
+   * cancel/reset use direct mode for marking semantics without preparation.
+   * The adapter resolves the prompt text, normalized invocation, and the
+   * per-call execution port (which captures the legacy origin in its closure).
+   */
+  readonly preparePrompt?: () => Effect.Effect<{
+    readonly execution?: GatewayExecutionPort;
+    readonly invocation?: NormalizedAgentInvocation;
+    readonly text: string;
+  }, unknown>;
+}
+interface GatewayExecuteOptions {
+  readonly direct?: GatewayDirectExecution;
+  readonly execution?: GatewayExecutionPort;
+  readonly observation?: GatewayObservationPort;
+  readonly presentation?: GatewayPresentationPort;
+  readonly reply?: GatewayReplyPort;
+}
+//#endregion
+//#region src/core/application/message-gateway/gateway/message-gateway.d.ts
+interface MessageGatewayOptions {
+  readonly dedupe?: boolean;
+  readonly execution: GatewayExecutionPort;
+  readonly humanInteraction?: GatewayHumanInteractionPort;
+  readonly observation?: GatewayObservationPort;
+  readonly presentation?: GatewayPresentationPort;
+  readonly reply?: GatewayReplyPort;
+}
+interface MessageGateway {
+  execute(action: GatewayAction, options?: GatewayExecuteOptions): Effect.Effect<GatewayActionResult | undefined, unknown>;
+}
+declare function createMessageGateway(options: MessageGatewayOptions): MessageGateway;
+//#endregion
+//#region src/core/domain/background-session/factories/create-background-session.d.ts
+declare function createBackgroundSession$1(input: CreateBackgroundSessionInput): BackgroundSession;
+//#endregion
+//#region src/core/domain/automation-occurrence/aggregate/snapshot.d.ts
+type AutomationOccurrenceStatus = "running" | "failed" | "generated" | "suppressed" | "delivered";
+interface AutomationOccurrenceSnapshot {
+  readonly automationId: string;
+  readonly body?: string;
+  readonly error?: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly presentation?: unknown;
+  readonly providerMessageId?: string;
+  readonly revision: number;
+  readonly runId?: string;
+  readonly status: AutomationOccurrenceStatus;
+  readonly suppressionReason?: string;
+  readonly tickId: string;
+}
+//#endregion
+//#region src/core/domain/automation-occurrence/aggregate/automation-occurrence.d.ts
+interface CreateAutomationOccurrenceInput {
+  readonly automationId: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly tickId: string;
+}
+interface GenerateAutomationOccurrenceInput {
+  readonly body: string;
+  readonly presentation?: unknown;
+  readonly runId: string;
+}
+interface SuppressAutomationOccurrenceInput {
+  readonly reason: string;
+  readonly runId: string;
+}
+declare class AutomationOccurrence {
+  #private;
+  private constructor();
+  static create(input: CreateAutomationOccurrenceInput): AutomationOccurrence;
+  static restore(value: unknown): AutomationOccurrence;
+  get automationId(): string;
+  get mandateId(): string;
+  get occurrence(): string;
+  get revision(): number;
+  get status(): AutomationOccurrenceStatus;
+  get tickId(): string;
+  restart(): AutomationOccurrence;
+  fail(error: string): AutomationOccurrence;
+  generate(input: GenerateAutomationOccurrenceInput): AutomationOccurrence;
+  suppress(input: SuppressAutomationOccurrenceInput): AutomationOccurrence;
+  deliver(providerMessageId: string): AutomationOccurrence;
+  validateTransitionTo(next: AutomationOccurrence): boolean;
+  toSnapshot(): AutomationOccurrenceSnapshot;
+  private requireRunning;
+  private next;
+}
+//#endregion
+//#region src/core/application/automation/occurrence/automation-occurrence-repository.d.ts
+interface AutomationOccurrenceRepository {
+  get(automationId: string, occurrence: string): Effect.Effect<AutomationOccurrence | undefined, unknown>;
+  save(occurrence: AutomationOccurrence): Effect.Effect<AutomationOccurrence, unknown>;
+}
+//#endregion
+//#region src/core/application/automation/policy/automation-mandate.d.ts
+interface AutomationBinding {
+  readonly agentId: string;
+  readonly bindingId: string;
+  readonly delivery: AutomationDeliveryBinding;
+  readonly schedule: string;
+  readonly servicePrincipalId: string;
+  readonly skillGrantRevision: string;
+  readonly skillIds: ReadonlyArray<string>;
+  readonly templateId: string;
+  readonly timeZone: string;
+  readonly toolIds: ReadonlyArray<string>;
+}
+interface AutomationDeliveryBinding {
+  readonly endpointId: string;
+  readonly targetKey: string;
+  readonly targetType: "chat_id" | "open_id" | "user_id" | "union_id" | "email";
+}
+interface AutomationMandate extends AutomationBinding {
+  readonly id: string;
+  readonly active: boolean;
+}
+interface AutomationTick {
+  readonly tickId: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly claimedBy: string;
+}
+interface AutomationMandateStore {
+  activate(binding: AutomationBinding): AutomationMandate;
+  revoke(id: string): void;
+  claim(id: string, occurrence: string, workerId: string): AutomationTick;
+}
+interface AutomationIdentity {
+  mandateId(binding: AutomationBinding): string;
+  tickId(mandateId: string, occurrence: string): string;
+}
+declare class AutomationMandateError extends Error {
+  readonly name = "AutomationMandateError";
+}
+//#endregion
+//#region src/core/application/automation/presentation/automation-line-chart.d.ts
+interface AutomationLineChart {
+  readonly title: string;
+  readonly labels: ReadonlyArray<string>;
+  readonly unit: string;
+  readonly seriesLayout?: "overlay" | "separate";
+  readonly series: ReadonlyArray<{
+    readonly name: string;
+    readonly values: ReadonlyArray<number>;
+  }>;
+}
+//#endregion
+//#region src/core/application/automation/presentation/automation-presentation.d.ts
+declare const AUTOMATION_PRESENTATION_SCHEMA_VERSION: 1;
+type AutomationPresentationKind = "daily-ai" | "generic" | "industry" | "news" | "subscriptions";
+interface AutomationPresentationSource {
+  readonly label: string;
+  readonly url: string;
+}
+interface AutomationPresentationItem {
+  readonly headline: string;
+  readonly note?: string;
+  readonly sources: ReadonlyArray<AutomationPresentationSource>;
+}
+interface AutomationPresentationSection {
+  readonly id: string;
+  readonly items: ReadonlyArray<AutomationPresentationItem>;
+  readonly title: string;
+}
+interface AutomationPresentation {
+  readonly lineChart?: AutomationLineChart;
+  readonly footnote?: string;
+  readonly kind?: AutomationPresentationKind;
+  readonly meta: ReadonlyArray<string>;
+  readonly schemaVersion: typeof AUTOMATION_PRESENTATION_SCHEMA_VERSION;
+  readonly sections: ReadonlyArray<AutomationPresentationSection>;
+  readonly summary?: string;
+  readonly title: string;
+}
+interface AutomationPresentationInput {
+  readonly lineChart?: AutomationLineChart;
+  readonly footnote?: string;
+  readonly kind?: AutomationPresentationKind;
+  readonly meta?: ReadonlyArray<string>;
+  readonly sections: ReadonlyArray<{
+    readonly id: string;
+    readonly items: ReadonlyArray<{
+      readonly headline: string;
+      readonly note?: string;
+      readonly sources?: ReadonlyArray<AutomationPresentationSource>;
+    }>;
+    readonly title: string;
+  }>;
+  readonly summary?: string;
+  readonly title: string;
+}
+declare class InvalidAutomationPresentation extends Error {
+  readonly name = "InvalidAutomationPresentation";
+}
+declare function createAutomationPresentation(input: AutomationPresentationInput): AutomationPresentation;
+declare function readAutomationPresentation(value: unknown): AutomationPresentation;
+//#endregion
+//#region src/core/application/automation/scheduling/automation-scheduler.d.ts
+declare const AUTOMATION_SUPPRESSION_PREFIX = "RIVUS_AUTOMATION_SUPPRESSED:";
+interface ScheduledAutomationRunInput {
+  readonly occurrence: string;
+  readonly sessionKey: string;
+  readonly text: string;
+  readonly tickId: string;
+}
+interface ScheduledAutomationRunResult {
+  readonly body?: string;
+  readonly presentation?: AutomationPresentation;
+  readonly runId: string;
+  readonly suppressedReason?: string;
+}
+interface ScheduledAutomationDeliveryInput {
+  readonly body: string;
+  readonly idempotencyKey: string;
+  readonly presentation?: AutomationPresentation;
+}
+interface AutomationSchedulerClock {
+  now(): Date;
+  sleep(milliseconds: number): Effect.Effect<void, unknown>;
+}
+interface AutomationSchedulerOptions {
+  readonly automationId: string;
+  readonly binding: AutomationBinding;
+  readonly clock?: AutomationSchedulerClock;
+  readonly createInput: (tick: {
+    readonly occurrence: string;
+  }) => {
+    readonly text: string;
+  };
+  readonly deliver: (input: ScheduledAutomationDeliveryInput) => Effect.Effect<{
+    readonly providerMessageId: string;
+  }, unknown>;
+  readonly identity: AutomationIdentity;
+  readonly repository: AutomationOccurrenceRepository;
+  readonly onError?: (error: unknown) => Effect.Effect<void, unknown>;
+  readonly retryDelayMs?: number;
+  readonly run: (input: ScheduledAutomationRunInput) => Effect.Effect<ScheduledAutomationRunResult, unknown>;
+}
+interface AutomationScheduler {
+  running(): boolean;
+  runDue(at: Date): Effect.Effect<AutomationOccurrence | undefined, unknown>;
+  start(): Effect.Effect<void>;
+  stop(): Effect.Effect<void>;
+}
+declare function createAutomationScheduler(options: AutomationSchedulerOptions): AutomationScheduler;
+//#endregion
+//#region src/core/application/automation/outcome/automation-outcome.d.ts
+type AutomationOutcome = {
+  readonly kind: "suppressed";
+} | {
+  readonly kind: "report" | "alert";
+  readonly body: string;
+  readonly target: string;
+};
+interface PluginStateRecord {
+  readonly pluginId: string;
+  readonly agentId: string;
+  readonly key: string;
+  readonly value: unknown;
+  readonly revision: number;
+}
+interface PutPluginState {
+  readonly pluginId: string;
+  readonly agentId: string;
+  readonly key: string;
+  readonly value: unknown;
+  readonly expectedRevision: number;
+}
+type DeliveryJobStatus = "pending" | "delivered" | "reconciliation-required";
+interface DeliveryJob {
+  readonly id: string;
+  readonly tickId: string;
+  readonly kind: "report" | "alert";
+  readonly body: string;
+  readonly target: string;
+  readonly status: DeliveryJobStatus;
+  readonly receiptId?: string;
+}
+type DeliveryAttemptResult = {
+  readonly kind: "delivered";
+  readonly providerMessageId: string;
+} | {
+  readonly kind: "uncertain";
+};
+interface CommitAutomationOutcomeInput$1 {
+  readonly tickId: string;
+  readonly outcome: AutomationOutcome;
+  readonly stateUpdate: PutPluginState;
+}
+interface CommittedAutomationOutcome {
+  readonly state: PluginStateRecord;
+  readonly job?: DeliveryJob;
+}
+//#endregion
+//#region src/core/application/automation/outcome/automation-outcome-repository.d.ts
+interface AutomationOutcomeRepository {
+  commit(input: CommitAutomationOutcomeInput$1): Effect.Effect<CommittedAutomationOutcome, unknown>;
+  recordDeliveryAttempt(id: string, result: DeliveryAttemptResult): Effect.Effect<DeliveryJob, unknown>;
+}
+//#endregion
+//#region src/core/application/automation/outcome/commit-automation-outcome.d.ts
+interface CommitAutomationOutcomeCommand extends CommitAutomationOutcomeInput$1 {
+  readonly repository: AutomationOutcomeRepository;
+}
+declare function commitAutomationOutcome$1(command: CommitAutomationOutcomeCommand): Effect.Effect<CommittedAutomationOutcome, unknown>;
+//#endregion
+//#region src/core/application/agent-host/contracts/agent-instance.d.ts
+type AgentInstanceBinding = {
+  readonly kind: "endpoint";
+  readonly endpointId: string;
+} | {
+  readonly kind: "automation";
+  readonly automationId: string;
+} | {
+  readonly kind: "background-session";
+  readonly agentId: string;
+};
+interface AgentInstanceRecord {
+  readonly agentId: string;
+  readonly binding: AgentInstanceBinding;
+  readonly bindingKey: string;
+  readonly instanceId: string;
+  readonly runtimeGenerationId: string;
+}
+interface AgentRuntimeGenerationIdentity {
+  readonly agentId: string;
+  readonly profileRevision: string;
+  readonly projectSpaceId: string | null;
+  readonly projectSpaceRevision: string | null;
+  readonly runtimeToolGrantRevision: string;
+  readonly skillGrantRevision: string;
+  readonly toolGrantRevision: string;
+}
+//#endregion
+//#region src/core/application/agent-host/contracts/agent-host-runtime.d.ts
+interface AgentRuntimeInput$1 {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly onUpdate?: (update: AgentRunUpdate) => Effect.Effect<void, unknown>;
+  readonly payload?: unknown;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+interface AgentRuntimeCancellation$1 {
+  readonly reason?: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+interface AgentRuntimeSteering$1 {
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+interface AgentHostRuntime {
+  readonly concurrency?: "managed";
+  cancel?(input: AgentRuntimeCancellation$1): Effect.Effect<boolean, unknown>;
+  dispose?(): Effect.Effect<void, unknown>;
+  run(input: AgentRuntimeInput$1): Effect.Effect<unknown, unknown>;
+  steer?(input: AgentRuntimeSteering$1): Effect.Effect<boolean, unknown>;
+}
+interface AgentHostRuntimeFactoryPort {
+  create(instance: AgentInstanceRecord): Effect.Effect<AgentHostRuntime, unknown>;
+}
+interface AgentHostRuntimePort {
+  cancel(instance: AgentInstanceRecord, input: AgentRuntimeCancellation$1): Effect.Effect<boolean, unknown>;
+  disposeAll(): Effect.Effect<void, unknown>;
+  run(instance: AgentInstanceRecord, input: AgentRuntimeInput$1): Effect.Effect<unknown, unknown>;
+  steer(instance: AgentInstanceRecord, input: AgentRuntimeSteering$1): Effect.Effect<boolean, unknown>;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-agent-definition.d.ts
+interface RivusAgentProfile {
+  readonly id: string;
+  readonly displayName: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+}
+interface RegisteredRivusAgentProfile extends RivusAgentProfile {
+  readonly pluginId: string;
+}
+interface RivusAgentGrantRestriction {
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeToolIds: ReadonlyArray<RivusRuntimeToolId>;
+  readonly skillIds: ReadonlyArray<string>;
+  readonly toolIds: ReadonlyArray<string>;
+}
+interface RivusAgentDeployment {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly memory?: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeTools?: {
+    readonly allow: ReadonlyArray<RivusRuntimeToolId>;
+  };
+  readonly skills: {
+    readonly allow: ReadonlyArray<string>;
+  };
+  readonly tools: {
+    readonly allow: ReadonlyArray<string>;
+  };
+}
+interface ResolvedRivusAgentDefinition {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly projectSpaceRevision?: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly profileRevision: string;
+  readonly systemPrompt: string;
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly memory: {
+    readonly scopes: ReadonlyArray<RivusMemoryScope>;
+    readonly tool: boolean;
+  };
+  readonly runtimeToolGrantSet: RivusRuntimeToolGrantSet;
+  readonly skillGrantSet: RivusSkillGrantSet;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+//#endregion
+//#region src/core/application/agent-host/registry/agent-instance-registry.d.ts
+interface AgentInstanceIdentityFactory {
+  createInstanceId(input: {
+    readonly bindingKey: string;
+    readonly runtimeGenerationId: string;
+  }): string;
+  createRuntimeGenerationId(input: AgentRuntimeGenerationIdentity): string;
+}
+interface AgentInstanceRegistryOptions {
+  readonly initialRecords?: ReadonlyArray<AgentInstanceRecord>;
+}
+interface AgentInstanceRegistry$1 {
+  resolveAutomation(automationId: string, definition: ResolvedRivusAgentDefinition): Effect.Effect<AgentInstanceRecord, AgentInstanceConflict>;
+  resolveBackgroundSession(agentId: string, definition: ResolvedRivusAgentDefinition): Effect.Effect<AgentInstanceRecord, AgentInstanceConflict>;
+  resolveEndpoint(endpointId: string, definition: ResolvedRivusAgentDefinition): Effect.Effect<AgentInstanceRecord, AgentInstanceConflict>;
+  snapshot(): Effect.Effect<ReadonlyArray<AgentInstanceRecord>>;
+}
+declare class AgentInstanceConflict extends Error {
+  readonly name = "AgentInstanceConflict";
+}
+declare function createEffectAgentInstanceRegistry(identity: AgentInstanceIdentityFactory, options?: AgentInstanceRegistryOptions): AgentInstanceRegistry$1;
+//#endregion
+//#region src/core/application/agent-host/routing/agent-host.d.ts
+interface AgentEndpointDefinition {
+  readonly agentId: string;
+  readonly id: string;
+}
+interface AgentAutomationBindingDefinition {
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly id: string;
+}
+interface AgentBackgroundSessionBindingDefinition {
+  readonly agentId: string;
+  readonly definition: ResolvedRivusAgentDefinition;
+}
+interface AgentHostOptions {
+  readonly automations?: ReadonlyArray<AgentAutomationBindingDefinition>;
+  readonly backgroundSessions?: ReadonlyArray<AgentBackgroundSessionBindingDefinition>;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly endpoints: ReadonlyArray<AgentEndpointDefinition>;
+  readonly registry: AgentInstanceRegistry$1;
+  readonly runtime: AgentHostRuntimePort;
+}
+interface AgentHost {
+  cancelBackgroundSession(agentId: string, input: AgentRuntimeCancellation$1): Effect.Effect<boolean, unknown>;
+  cancelEndpoint(endpointId: string, input: AgentRuntimeCancellation$1): Effect.Effect<boolean, unknown>;
+  dispose(): Effect.Effect<void, unknown>;
+  handleAutomation(automationId: string, input: AgentRuntimeInput$1): Effect.Effect<unknown, unknown>;
+  handleBackgroundSession(agentId: string, input: AgentRuntimeInput$1): Effect.Effect<unknown, unknown>;
+  handleEndpoint(endpointId: string, input: AgentRuntimeInput$1): Effect.Effect<unknown, unknown>;
+  resolveAutomation(automationId: string): Effect.Effect<AgentInstanceRecord, InvalidAgentHostBinding>;
+  resolveBackgroundSession(agentId: string): Effect.Effect<AgentInstanceRecord, InvalidAgentHostBinding>;
+  resolveEndpoint(endpointId: string): Effect.Effect<AgentInstanceRecord, InvalidAgentHostBinding>;
+  steerEndpoint(endpointId: string, input: AgentRuntimeSteering$1): Effect.Effect<boolean, unknown>;
+}
+declare class InvalidAgentHostBinding extends Error {
+  readonly name = "InvalidAgentHostBinding";
+}
+declare function createEffectAgentHost(options: AgentHostOptions): Effect.Effect<AgentHost, Error>;
+//#endregion
+//#region src/adapters/agent/runtime/effect-agent-runtime-pool.d.ts
+declare class AgentInstanceBusy extends Error {
+  readonly name = "AgentInstanceBusy";
+}
+declare class AgentRuntimeDisposed extends Error {
+  readonly name = "AgentRuntimeDisposed";
+}
+declare function createAgentHostRuntimePool(factory: AgentHostRuntimeFactoryPort, disposeTimeoutMs?: number): AgentHostRuntimePort;
+//#endregion
+//#region src/adapters/compatibility/agent-host/agent-instance-registry.d.ts
+interface AgentInstanceRegistry {
+  resolveAutomation(automationId: string, definition: ResolvedRivusAgentDefinition): AgentInstanceRecord;
+  resolveBackgroundSession(agentId: string, definition: ResolvedRivusAgentDefinition): AgentInstanceRecord;
+  resolveEndpoint(endpointId: string, definition: ResolvedRivusAgentDefinition): AgentInstanceRecord;
+  snapshot(): ReadonlyArray<AgentInstanceRecord>;
+}
+declare function createAgentInstanceRegistry(options?: AgentInstanceRegistryOptions): AgentInstanceRegistry;
+//#endregion
+//#region src/adapters/compatibility/agent-host/agent-runtime-pool.d.ts
+interface AgentRuntimeInput {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly onUpdate?: (update: AgentRunUpdate) => void | Promise<void>;
+  readonly payload?: unknown;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+interface AgentRuntimeCancellation extends AgentRuntimeCancellation$1 {}
+interface AgentRuntimeSteering extends AgentRuntimeSteering$1 {}
+interface PooledAgentRuntime {
+  readonly concurrency?: "managed";
+  cancel?(input: AgentRuntimeCancellation): Promise<boolean>;
+  steer?(input: AgentRuntimeSteering): Promise<boolean>;
+  run(input: AgentRuntimeInput): Promise<unknown>;
+  dispose?(): Promise<void> | void;
+}
+interface AgentRuntimePoolOptions {
+  readonly disposeTimeoutMs?: number;
+  readonly registry: AgentInstanceRegistry;
+  readonly createRuntime: (instance: AgentInstanceRecord) => PooledAgentRuntime | Promise<PooledAgentRuntime>;
+}
+interface AgentRuntimePool {
+  readonly registry: AgentInstanceRegistry;
+  cancel(instance: AgentInstanceRecord, input: AgentRuntimeCancellation): Promise<boolean>;
+  steer(instance: AgentInstanceRecord, input: AgentRuntimeSteering): Promise<boolean>;
+  run(instance: AgentInstanceRecord, input: AgentRuntimeInput): Promise<unknown>;
+  disposeAll(): Promise<void>;
+}
+declare function createAgentRuntimePool(options: AgentRuntimePoolOptions): AgentRuntimePool;
+//#endregion
+//#region src/adapters/compatibility/agent-host/rivus-agent-host.d.ts
+interface RivusEndpointDefinition {
+  readonly id: string;
+  readonly agentId: string;
+}
+interface RivusAgentHostOptions {
+  readonly automations?: ReadonlyArray<RivusAutomationDefinition>;
+  readonly backgroundSessions?: ReadonlyArray<RivusBackgroundSessionDefinition>;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly endpoints: ReadonlyArray<RivusEndpointDefinition>;
+  readonly runtimePool: AgentRuntimePool;
+}
+interface RivusAutomationDefinition {
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly id: string;
+}
+interface RivusBackgroundSessionDefinition {
+  readonly agentId: string;
+  readonly definition: ResolvedRivusAgentDefinition;
+}
+interface RivusEndpointInput$1 extends AgentRuntimeInput {}
+interface RivusAgentHost {
+  cancelBackgroundSession(agentId: string, input: AgentRuntimeCancellation): Promise<boolean>;
+  cancelEndpoint(endpointId: string, input: AgentRuntimeCancellation): Promise<boolean>;
+  steerEndpoint(endpointId: string, input: AgentRuntimeSteering): Promise<boolean>;
+  handleAutomation(automationId: string, input: AgentRuntimeInput): Promise<unknown>;
+  handleBackgroundSession(agentId: string, input: AgentRuntimeInput): Promise<unknown>;
+  handleEndpoint(endpointId: string, input: RivusEndpointInput$1): Promise<unknown>;
+  resolveAutomation(automationId: string): AgentInstanceRecord;
+  resolveBackgroundSession(agentId: string): AgentInstanceRecord;
+  resolveEndpoint(endpointId: string): AgentInstanceRecord;
+}
+declare class InvalidRivusEndpointBinding extends Error {
+  readonly name = "InvalidRivusEndpointBinding";
+}
+declare function createRivusAgentHost(options: RivusAgentHostOptions): RivusAgentHost;
+//#endregion
+//#region src/adapters/agent/background-session/background-session-host-tools.d.ts
+interface CreateBackgroundSessionHostToolsOptions {
+  readonly createSessionId: () => string;
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly service: BackgroundSessionService;
+}
+declare function createBackgroundSessionHostTools(options: CreateBackgroundSessionHostToolsOptions): ReadonlyArray<RivusHostToolDescriptor>;
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin.d.ts
+declare const RIVUS_PLUGIN_API_VERSION = "1";
+interface RivusPluginManifest {
+  readonly apiVersion: string;
+  readonly id: string;
+  readonly version: string;
+}
+interface RegisteredRivusPlugin extends RivusPluginManifest {}
+declare class InvalidRivusPlugin extends Error {
+  readonly name = "InvalidRivusPlugin";
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-automation-template.d.ts
+interface RivusAutomationTemplate {
+  readonly id: string;
+  readonly profileId: string;
+  readonly requestedSkillIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly createInput: (tick: RivusAutomationTickContext) => RivusAutomationInput;
+  readonly createPresentation?: (output: RivusAutomationOutput) => AutomationPresentation;
+}
+interface RivusAutomationTickContext {
+  readonly occurrence: string;
+}
+interface RivusAutomationInput {
+  readonly text: string;
+}
+interface RivusAutomationOutput {
+  readonly occurrence: string;
+  readonly text: string;
+}
+interface RegisteredRivusAutomation extends RivusAutomationTemplate {
+  readonly pluginId: string;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-tool-descriptor-provider.d.ts
+type RivusCatalogToolContributionScope = "profile" | "runtime";
+interface RivusCatalogToolContribution {
+  readonly scope: RivusCatalogToolContributionScope;
+  readonly tool: RivusResolvedToolDescriptor;
+}
+interface RivusCatalogToolDescriptorRequest {
+  readonly deployment: RivusAgentDeployment;
+  readonly memoryScopes: ReadonlyArray<RivusMemoryScope>;
+  readonly profile: RegisteredRivusAgentProfile;
+}
+interface RivusCatalogToolDescriptorProvider {
+  provide(request: RivusCatalogToolDescriptorRequest): ReadonlyArray<RivusCatalogToolContribution>;
+}
+//#endregion
+//#region src/core/application/agent-catalog/contracts/rivus-plugin-contracts.d.ts
+interface RivusPluginRegistry {
+  registerAgentProfile(profile: RivusAgentProfile): void;
+  registerTool(tool: RivusToolDescriptor): void;
+  registerSkill(skill: RivusSkillDescriptor): void;
+  registerAutomation(template: RivusAutomationTemplate): void;
+}
+interface RivusPlugin {
+  readonly manifest: RivusPluginManifest;
+  register(registry: RivusPluginRegistry): void;
+}
+interface RivusPluginCatalogSnapshot {
+  readonly plugins: ReadonlyArray<RegisteredRivusPlugin>;
+  readonly profiles: ReadonlyArray<RegisteredRivusAgentProfile>;
+  readonly tools: ReadonlyArray<RegisteredRivusTool>;
+  readonly skills: ReadonlyArray<RegisteredRivusSkill>;
+  readonly automations: ReadonlyArray<RegisteredRivusAutomation>;
+}
+interface RivusPluginCatalog {
+  registerPlugin(plugin: RivusPlugin): void;
+  snapshot(): RivusPluginCatalogSnapshot;
+}
+//#endregion
+//#region src/core/application/agent-catalog/resolution/rivus-agent-definition-resolver.d.ts
+interface RivusAgentDefinitionResolver {
+  resolve(catalog: RivusPluginCatalog, deployment: RivusAgentDeployment): ResolvedRivusAgentDefinition;
+}
+interface RivusAgentCatalog extends RivusAgentDefinitionResolver {
+  createPluginCatalog(): RivusPluginCatalog;
+  readonly restrictGrants: (definition: ResolvedRivusAgentDefinition, restriction: RivusAgentGrantRestriction) => ResolvedRivusAgentDefinition;
+}
+//#endregion
+//#region src/adapters/compatibility/agent-catalog/rivus-agent-catalog.d.ts
+interface CreateCompatibleRivusAgentCatalogOptions {
+  readonly backgroundSessions?: boolean;
+}
+interface CreateRivusAgentCatalogOptions {
+  readonly toolDescriptorProviders?: ReadonlyArray<RivusCatalogToolDescriptorProvider>;
+}
+declare function createRivusPluginCatalog(): RivusPluginCatalog;
+declare function createRivusAgentCatalog(options?: CreateRivusAgentCatalogOptions): RivusAgentCatalog;
+declare function createCompatibleRivusAgentCatalog(options?: CreateCompatibleRivusAgentCatalogOptions): RivusAgentCatalog;
+declare function resolveRivusAgentDefinition(catalog: RivusPluginCatalog, deployment: RivusAgentDeployment, options?: {
+  readonly backgroundSessions?: boolean;
+}): ResolvedRivusAgentDefinition;
+//#endregion
+//#region src/core/application/agent-catalog/catalog/rivus-catalog-validation.d.ts
+declare function validateRivusPluginManifest(manifest: RivusPluginManifest): void;
+interface RivusCatalogRegistrationItem {
+  readonly id: string;
+  readonly kind: string;
+  readonly namespaced: boolean;
+  readonly pluginId: string;
+}
+declare function validateRivusCatalogRegistration(item: RivusCatalogRegistrationItem, existing: ReadonlyMap<string, unknown>, pending: ReadonlySet<string>): void;
+declare function validateRivusCatalogIdentifier(id: string, kind: string): void;
+//#endregion
+//#region src/core/application/deployment/model/model-state-repository.d.ts
+/** Durable application port for the managed model state snapshot. */
+interface ModelStateRepository {
+  load(): Effect.Effect<ModelState, unknown>;
+  persist(state: ModelState): Effect.Effect<ModelState, unknown>;
+}
+//#endregion
+//#region src/core/application/deployment/model/model-change-contracts.d.ts
+/**
+ * Gateway-persistent budget reservation. The Runtime boundary only sees the
+ * minimal {@link import("@rivus/runtime").ModelChangeBudgetReservation}
+ * shape (`id`, `maxOutputTokens`); the coordinator stores the full record
+ * (kind, paid-request count, reservation timestamp) for settlement and
+ * recovery policy.
+ */
+interface ModelChangeBudgetReservation {
+  readonly id: string;
+  readonly kind: ModelChangePaidCallKind;
+  readonly maxOutputTokens: number;
+  readonly paidRequests: 1;
+  readonly reservedAt: string;
+}
+declare const MODEL_STATE_SCHEMA_VERSION: 1;
+type ModelChangeOperation = "set" | "rollback";
+type ModelChangeStatus = "pending" | "applied" | "failed" | "restored" | "recovery-required";
+type ModelChangePhase = "awaiting-approval" | "accepted" | "waiting-for-boundary" | "validating" | "activating" | "committing" | "notifying" | "completed" | "validation-unknown" | "recovery-required";
+type ModelChangeFailureOutcome = "known" | "unknown";
+interface ModelChangeSourceHint {
+  /** This is a routing hint only. It does not grant authorization. */
+  readonly kind: "automation" | "human" | "unknown";
+  readonly reference?: string;
+}
+interface ModelChangeSubmission {
+  readonly expectedRevision: number;
+  readonly operation: ModelChangeOperation;
+  readonly requestId: string;
+  readonly target?: ModelReference;
+}
+/** An opaque transport reference resolved by the trusted authorization adapter. */
+interface ModelChangeTransportContext {
+  readonly reference: string;
+}
+interface ModelChangeSource {
+  readonly kind: "automation" | "human";
+  readonly reference: string;
+}
+interface ModelChangePrincipal {
+  readonly homeId: string;
+  readonly ownerId: string;
+  readonly source: ModelChangeSource;
+}
+interface ModelChangeBudgetLimits {
+  readonly deadlineAt: string;
+  readonly identity: string;
+  readonly maxOutputTokens: number;
+  readonly maxPaidRequests: number;
+  readonly recoveryReserveOutputTokens: number;
+  readonly recoveryReservePaidRequests: number;
+}
+interface ModelChangeAuthorizationInput {
+  readonly current: ModelBinding;
+  readonly homeId: string;
+  readonly request: ModelChangeSubmission;
+  readonly transport: ModelChangeTransportContext;
+  /** Server-derived prior receipt context, used to preserve a pending approval deadline. */
+  readonly existing?: {
+    readonly authorizationId?: string;
+    readonly deadlineAt?: string;
+  };
+}
+interface ApprovedModelChangeAuthorization {
+  readonly authorizationId: string;
+  readonly bindingRevision: string;
+  readonly budget: ModelChangeBudgetLimits;
+  readonly principal: ModelChangePrincipal;
+  readonly status: "approved";
+}
+interface AwaitingModelChangeAuthorization {
+  readonly authorizationId?: string;
+  readonly bindingRevision?: string;
+  readonly deadlineAt?: string;
+  readonly principal?: ModelChangePrincipal;
+  readonly reason: string;
+  readonly status: "awaiting-approval";
+}
+interface RejectedModelChangeAuthorization {
+  readonly code: string;
+  readonly reason: string;
+  readonly status: "rejected";
+}
+type ModelChangeAuthorizationDecision = ApprovedModelChangeAuthorization | AwaitingModelChangeAuthorization | RejectedModelChangeAuthorization;
+interface ModelChangeAuthorizationPort {
+  authorize(input: ModelChangeAuthorizationInput): Effect.Effect<ModelChangeAuthorizationDecision, unknown>;
+  revalidate(input: {
+    readonly authorizationId: string;
+    readonly current: ModelBinding;
+    readonly homeId: string;
+    readonly pending: ModelChangePending;
+  }): Effect.Effect<{
+    readonly bindingRevision: string;
+    readonly status: "approved";
+  } | {
+    readonly code: string;
+    readonly reason: string;
+    readonly status: "rejected";
+  }, unknown>;
+  /** Resolve a durable awaiting approval from the accepted-worker context. */
+  readonly resolvePending?: (input: {
+    readonly current: ModelBinding;
+    readonly homeId: string;
+    readonly pending: ModelChangePending;
+  }) => Effect.Effect<ModelChangeAuthorizationDecision, unknown>;
+}
+interface ModelChangeBudget {
+  readonly deadlineAt: string;
+  readonly identity: string;
+  readonly maxOutputTokens: number;
+  readonly maxPaidRequests: number;
+  readonly outputTokens: number;
+  readonly paidRequests: number;
+  readonly recoveryReserveOutputTokens: number;
+  readonly recoveryReservePaidRequests: number;
+  readonly reservations: Readonly<Record<string, ModelChangeBudgetReservation>>;
+  readonly reservedOutputTokens: number;
+  readonly reservedPaidRequests: number;
+}
+interface ModelChangeError {
+  readonly code: string;
+  readonly message: string;
+  readonly outcome: ModelChangeFailureOutcome;
+  readonly stage: "activation" | "boundary" | "commit" | "notification" | "restore" | "validation";
+}
+interface ModelChangeNotification {
+  readonly attempts: number;
+  readonly lastAttemptAt?: string;
+  readonly status: "pending" | "sent" | "unknown";
+}
+interface ModelChangeReceiptFields {
+  readonly acceptedAt: string;
+  readonly current?: ModelBinding;
+  readonly error?: ModelChangeError;
+  readonly expectedRevision: number;
+  readonly operation: ModelChangeOperation;
+  readonly phase: ModelChangePhase;
+  readonly previous?: ModelBinding;
+  readonly requestId: string;
+  readonly revision: number;
+  readonly status: ModelChangeStatus;
+  readonly target?: ModelReference;
+  readonly updatedAt: string;
+}
+interface ModelChangeReceipt extends ModelChangeReceiptFields {
+  readonly authorizationId?: string;
+  readonly bindingRevision: string;
+  readonly budget: ModelChangeBudget;
+  readonly budgetIdentity: string;
+  readonly inputDigest: string;
+  readonly notification?: ModelChangeNotification;
+  readonly principal?: ModelChangePrincipal;
+}
+interface ModelChangePending {
+  readonly acceptedAt: string;
+  readonly authorizationId?: string;
+  readonly bindingRevision: string;
+  readonly budget: ModelChangeBudget;
+  readonly budgetIdentity: string;
+  readonly expectedRevision: number;
+  readonly inputDigest: string;
+  readonly operation: ModelChangeOperation;
+  readonly ownerId?: string;
+  readonly phase: ModelChangePhase;
+  readonly principal?: ModelChangePrincipal;
+  readonly request: ModelChangeSubmission;
+  readonly recoveryAttemptedAt?: string;
+  readonly target?: ModelReference;
+  readonly unknownPaidCallId?: string;
+  readonly updatedAt: string;
+}
+interface ModelState {
+  readonly current: ModelBinding;
+  readonly homeId: string;
+  readonly ownerId: string;
+  readonly pending?: ModelChangePending;
+  readonly previous?: ModelBinding;
+  readonly recoveryRequired?: ModelChangeError;
+  readonly requests: Readonly<Record<string, ModelChangeReceipt>>;
+  readonly revision: number;
+  readonly schemaVersion: typeof MODEL_STATE_SCHEMA_VERSION;
+  readonly updatedAt: string;
+}
+interface ModelStatusView {
+  readonly actual?: ModelBinding;
+  readonly current: ModelBinding;
+  readonly homeId: string;
+  readonly pending?: Pick<ModelChangePending, "phase" | "request" | "target" | "updatedAt">;
+  readonly previous?: ModelBinding;
+  readonly request?: ModelChangePublicReceipt;
+  readonly persisted: ModelBinding;
+  readonly recoveryRequired?: ModelChangeError;
+  readonly revision: number;
+  readonly source: "legacy" | "managed";
+}
+type ModelChangeStatusView = ModelStatusView;
+interface ModelChangePublicReceipt extends ModelChangeReceiptFields {
+  readonly budget: Pick<ModelChangeBudget, "deadlineAt" | "maxOutputTokens" | "maxPaidRequests" | "outputTokens" | "paidRequests">;
+}
+interface ModelChangeBoundaryInput {
+  readonly deadlineAt: string;
+  readonly requestId: string;
+}
+interface ModelChangeBoundaryResult {
+  readonly activeRuns: 0;
+  readonly completedAt: string;
+}
+interface ModelChangeBoundaryPort {
+  resumeAfterChange(input: {
+    readonly requestId: string;
+  }): Effect.Effect<void, unknown>;
+  waitForSafeBoundary(input: ModelChangeBoundaryInput): Effect.Effect<ModelChangeBoundaryResult, unknown>;
+}
+interface ModelChangeNotificationPort {
+  notify(input: {
+    readonly receipt: ModelChangePublicReceipt;
+    readonly retry: boolean;
+  }): Effect.Effect<{
+    readonly delivered: true;
+  }, unknown>;
+}
+interface ModelChangeIdentityPort {
+  digest(input: {
+    readonly bindingRevision: string;
+    readonly expectedRevision: number;
+    readonly homeId: string;
+    readonly ownerId: string;
+    readonly operation: ModelChangeOperation;
+    readonly requestId: string;
+    readonly source: ModelChangeSource;
+    readonly target?: ModelReference;
+    readonly authorizationId?: string;
+    readonly budgetIdentity?: string;
+  }): string;
+}
+interface ModelChangeCoordinatorOptions {
+  readonly authorization: ModelChangeAuthorizationPort;
+  readonly boundary: ModelChangeBoundaryPort;
+  readonly clock: ModelChangeClock;
+  readonly homeId: string;
+  readonly identity: ModelChangeIdentityPort;
+  readonly notification?: ModelChangeNotificationPort;
+  readonly repository: ModelStateRepository;
+  readonly runtime: ModelChangeRuntimePort;
+}
+interface ModelChangeCoordinator {
+  accept(input: ModelChangeSubmission, transport: ModelChangeTransportContext): Effect.Effect<ModelChangeReceipt, unknown>;
+  recover(): Effect.Effect<ModelState, unknown>;
+  run(requestId: string): Effect.Effect<ModelChangeReceipt, unknown>;
+  status(requestId?: string): Effect.Effect<ModelStatusView, unknown>;
+}
+declare class ModelChangeRequestConflict extends Error {
+  readonly name = "ModelChangeRequestConflict";
+}
+declare class ModelChangeRevisionConflict extends Error {
+  readonly name = "ModelChangeRevisionConflict";
+}
+declare class ModelChangeBusy extends Error {
+  readonly name = "ModelChangeBusy";
+}
+declare class ModelChangeNotFound extends Error {
+  readonly name = "ModelChangeNotFound";
+}
+declare class ModelChangeAuthorizationRejected extends Error {
+  readonly name = "ModelChangeAuthorizationRejected";
+}
+declare class ModelStateCorrupted extends Error {
+  readonly name = "ModelStateCorrupted";
+}
+//#endregion
+//#region src/core/application/deployment/model/model-change-authorization-contracts.d.ts
+/** A Host-maintained grant. No field in this contract comes from the CLI request. */
+interface ModelManagementGrant {
+  readonly bindingRevision: string;
+  readonly budget: Omit<ModelChangeBudgetLimits, "identity" | "deadlineAt">;
+  readonly enabled: boolean;
+  readonly endpointId: string;
+  readonly homeId: string;
+  readonly operations: ReadonlyArray<ModelChangeOperation>;
+  readonly ownerId: string;
+  readonly provider: string;
+  readonly revision: number;
+  /** Host policy requiring a durable human decision before this request can run. */
+  readonly requireApproval?: boolean;
+  readonly tenantKey: string;
+  readonly timeoutMs: number;
+}
+interface ModelChangeApprovalInput {
+  /** Present only while creating the interaction from a live trusted Run. */
+  readonly authority?: ModelChangeApprovalAuthority;
+  readonly budget: ModelManagementGrant["budget"];
+  readonly expiresAt: string;
+  readonly grantRevision: number;
+  readonly interactionId: string;
+  readonly principal: ModelChangePrincipal;
+  readonly request: ModelChangeSubmission;
+}
+interface ModelChangeApprovalAuthority {
+  readonly agentId: string;
+  readonly endpointId?: string;
+  readonly instanceId: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+}
+type ModelChangeApprovalStatus = {
+  readonly status: "approved";
+} | {
+  readonly reason?: string;
+  readonly status: "pending";
+} | {
+  readonly reason?: string;
+  readonly status: "rejected";
+};
+/** Durable approval adapter. Initial authorization must stay non-blocking; accepted workers may wait. */
+interface ModelChangeApprovalPort {
+  requestOrGet(input: ModelChangeApprovalInput): Effect.Effect<ModelChangeApprovalStatus, unknown>;
+  waitForResolution(input: ModelChangeApprovalInput): Effect.Effect<ModelChangeApprovalStatus, unknown>;
+}
+interface ModelManagementTrustedRun {
+  readonly authority: InvocationAuthorityRef;
+  readonly kind: "human";
+}
+interface ModelChangeAuthorizationOptions {
+  readonly approval?: ModelChangeApprovalPort;
+  readonly clock: {
+    now(): string;
+  };
+  readonly digest: ToolInputDigest;
+  readonly grant: {
+    current(): Effect.Effect<ModelManagementGrant, unknown>;
+  };
+  /** Host-canonical Agent identity used for the Home-wide model operation. */
+  readonly managementAgentId: string;
+  readonly operations: ToolOperationLedger;
+  readonly resolveRun: (reference: string) => Effect.Effect<ModelManagementTrustedRun | undefined, unknown>;
+  /** Host-issued worker authority; it must be reconstructed from the persisted trusted binding. */
+  readonly resolveWorkerRun?: (input: {
+    readonly authorizationId: string;
+    readonly grant: ModelManagementGrant;
+    readonly principal: ModelChangePrincipal;
+    readonly request: ModelChangeSubmission;
+  }) => Effect.Effect<ModelManagementTrustedRun | undefined, unknown>;
+}
+//#endregion
+//#region src/core/application/deployment/model/model-change-authorization.d.ts
+/** Reuses Broker policy, exact approval binding and its durable operation ledger. */
+declare function createModelChangeAuthorization(options: ModelChangeAuthorizationOptions): ModelChangeAuthorizationPort;
+//#endregion
+//#region src/core/application/deployment/model/model-change-coordinator.d.ts
+declare function createModelChangeCoordinator(options: ModelChangeCoordinatorOptions): ModelChangeCoordinator;
+//#endregion
+//#region src/core/application/deployment/model/model-change-run-boundary.d.ts
+interface ModelChangeRunLease {
+  /** Release exactly one active Run. Releasing twice is harmless. */
+  readonly release: () => void;
+}
+interface ModelChangeRunBoundaryOptions {
+  readonly clock: ModelChangeClock;
+}
+/**
+ * Gateway-facing run boundary. Wraps the single Runtime {@link RunAdmission}
+ * mechanism with the model-change request identity (`requestId`) and drain
+ * deadline semantics owned by the coordinator.
+ *
+ * This is the required Gateway policy adapter; it does not create a second
+ * counter or parallel lifecycle. All foreground/background Runs still share
+ * one admission authority.
+ */
+interface ModelChangeRunBoundary extends ModelChangeBoundaryPort {
+  /** Acquire admission for one concrete Run before resolving a session/model. */
+  acquireRun(input?: {
+    readonly deadlineAt?: string;
+    readonly signal?: AbortSignal;
+  }): Effect.Effect<ModelChangeRunLease, unknown>;
+  /** Synchronously close admission; existing leases continue to drain. */
+  fence(): void;
+  readonly activeRunCount: () => number;
+  readonly admissionOpen: () => boolean;
+}
+declare function createModelChangeRunBoundary(options: ModelChangeRunBoundaryOptions): ModelChangeRunBoundary;
+//#endregion
+//#region src/bootstrap/deployment/model-management/model-management-control.d.ts
+interface ModelManagementControlOptions extends ModelChangeCoordinatorOptions {
+  /** Immediately close admission; this must not wait for existing Runs. */
+  readonly stopBusinessWork: () => void;
+  readonly resolveTrustedReference: (reference: string) => Promise<boolean>;
+  readonly runtimeVersion: string;
+  readonly socketPath: string;
+}
+interface ModelManagementControl {
+  /** Acquire the socket first, then recover before constructing business sessions. */
+  recover(): Promise<ModelState>;
+  start(): Promise<void>;
+  close(): Promise<void>;
+}
+/** Owns the control socket and the accepted-operation worker for one Home. */
+declare function createModelManagementControl(options: ModelManagementControlOptions): ModelManagementControl;
+//#endregion
+//#region src/platform/home/config/runtime/rivus-daemon-config.d.ts
+type RivusDaemonEnv = Readonly<Record<string, string | undefined>>;
+type RivusThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+type RivusTextFileReader = (path: string) => Promise<string> | string;
+interface RivusDaemonConfigLoaderOptions {
+  readonly readTextFile?: RivusTextFileReader;
+}
+interface RivusDaemonConfig {
+  readonly agentId: string;
+  readonly feishu: {
+    readonly appId: string;
+    readonly appSecret: string;
+    readonly baseUrl: string;
+    readonly cardStreamLeaseMs: number;
+    readonly streamMinIntervalMs: number;
+  };
+  readonly pi: {
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly model?: string;
+    readonly thinkingLevel?: RivusThinkingLevel;
+  };
+}
+declare class RivusDaemonConfigError {
+  readonly variable: string;
+  readonly message: string;
+  readonly _tag = "RivusDaemonConfigError";
+  constructor(variable: string, message: string);
+}
+declare function loadRivusDaemonConfig(env: RivusDaemonEnv, options?: RivusDaemonConfigLoaderOptions): Effect.Effect<RivusDaemonConfig, RivusDaemonConfigError>;
+//#endregion
+//#region src/platform/home/config/model-management/rivus-model-management-config-migration.d.ts
+interface RivusModelReference {
+  readonly model: string;
+  readonly provider: string;
+}
+//#endregion
+//#region src/platform/home/config/model-management/rivus-runtime-management-skill-installer.d.ts
+type RivusRuntimeManagementSkillInstallStatus = "conflict" | "installed" | "unchanged" | "updated";
+interface RivusRuntimeManagementSkillInstallResult {
+  readonly destination: string;
+  readonly requiresRefresh: boolean;
+  readonly sourceDigest: string;
+  readonly status: RivusRuntimeManagementSkillInstallStatus;
+}
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-run-context.d.ts
+type PiBashSpawnHook = PiManagedRunProviderResult["spawnHook"];
+declare const RIVUS_MODEL_CONTEXT_ENV: "RIVUS_MODEL_CONTEXT";
+declare const RIVUS_MODEL_SOCKET_ENV: "RIVUS_MODEL_SOCKET";
+declare const RIVUS_MODEL_CHANGE_TOOL_ID: "rivus.model.change";
+type PiModelContextReference = string & {
+  readonly __rivusModelContextReference: unique symbol;
+};
+interface PiModelRunContext {
+  readonly reference: PiModelContextReference;
+  readonly runId: string;
+}
+interface PiModelTrustedRun {
+  readonly authority: InvocationAuthorityRef;
+  readonly kind: "human";
+}
+interface PiModelRunContextRegistryOptions {
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly modelManagementEnabled?: boolean;
+  readonly toolGrantSet: InvocationToolGrantSet;
+}
+interface PiModelRunContextRegistry {
+  /** Issue one private context for one concrete AgentLoopInput/run. */
+  issue(input: AgentLoopInput): PiModelRunContext;
+  /** Resolve only a context issued by this registry while its Run is active. */
+  resolveRun(reference: PiModelContextReference | string): PiModelTrustedRun | undefined;
+  /** Revoke one context. Runtime should call this when the Run completes. */
+  revoke(reference: PiModelContextReference | string): boolean;
+}
+interface PiModelManagementBashSpawnHookOptions {
+  readonly context: PiModelRunContext;
+  readonly socketPath: string;
+}
+declare class PiModelRunContextError extends Error {
+  readonly code: "invalid-input" | "run-aborted" | "untrusted-invocation";
+  readonly name = "PiModelRunContextError";
+  constructor(code: PiModelRunContextError["code"], message: string);
+}
+/**
+ * Keep the model-management capability bound to a concrete host-owned Run.
+ * The reference is the only value that crosses into a child process; all
+ * invocation identity stays in this process behind the authority WeakMap.
+ */
+declare function createPiModelRunContextRegistry(options: PiModelRunContextRegistryOptions): PiModelRunContextRegistry;
+/**
+ * Inject the private transport values at process spawn time. The SDK passes
+ * this hook the command and environment separately, so the opaque reference
+ * never becomes model prompt content, an argv item, or a JSON request field.
+ */
+declare function createPiModelManagementBashSpawnHook(options: PiModelManagementBashSpawnHookOptions): PiBashSpawnHook;
+//#endregion
+//#region src/platform/home/rivus-home.d.ts
+type RivusHomeEnvironment = Readonly<Record<string, string | undefined>>;
+interface RivusHome {
+  readonly bootstrap: string;
+  readonly directory: string;
+  readonly envFilePath: string;
+  readonly logsDirectory: string;
+  readonly manifestPath: string;
+  readonly stateDirectory: string;
+  readonly workspaceDirectory: string;
+}
+interface InitializedRivusHome {
+  readonly directory: string;
+  readonly files: ReadonlyArray<string>;
+}
+interface RivusHomeDoctorCheck {
+  readonly message: string;
+  readonly name: "node" | "home" | "workspace" | "modules" | "manifest" | "credentials";
+  readonly status: "pass" | "fail";
+}
+interface RivusHomeDoctorReport {
+  readonly checks: ReadonlyArray<RivusHomeDoctorCheck>;
+  readonly directory: string;
+  readonly ready: boolean;
+}
+interface RivusHomeApi {
+  diagnose(input: {
+    readonly directory: string;
+    readonly env: RivusHomeEnvironment;
+    readonly envFilePath?: string;
+    readonly nodeVersion: string;
+  }): Effect.Effect<RivusHomeDoctorReport, Error>;
+  load(directory: string): Effect.Effect<RivusHome, Error>;
+  setup(directory: string): Effect.Effect<InitializedRivusHome, Error>;
+}
+//#endregion
+//#region src/bootstrap/deployment/model-management/pi-model-management-deployment.d.ts
+type PiModelManagementRuntime = Parameters<typeof createPiModelRuntime>[0]["modelRuntime"];
+interface PiModelManagementDeploymentOptions {
+  readonly agentId: string;
+  readonly approval?: ModelChangeApprovalPort;
+  readonly agentCount: number;
+  readonly endpointId: string;
+  readonly env: RivusDaemonEnv;
+  readonly environmentOverrides: RivusDaemonEnv;
+  readonly envFilePath?: string;
+  readonly homeDirectory?: string;
+  readonly modelAuthPath?: string;
+  readonly modelCatalogPath: string;
+  readonly modelRuntime: PiModelManagementRuntime;
+  readonly reply: (sourceMessageId: string, text: string) => Effect.Effect<void, unknown>;
+  readonly runtimeVersion?: string;
+  readonly stateDirectory: string;
+  readonly thinkingLevel: PiThinkingLevel;
+}
+/** Assemble one Home's model authority without constructing a business session. */
+declare function openPiModelManagementDeployment(options: PiModelManagementDeploymentOptions): Promise<{
+  enabled: false;
+  model: RivusModelReference;
+  binDirectory?: never;
+  boundary?: never;
+  close?: never;
+  recoveryRequired?: never;
+  runtime?: never;
+  socketPath?: never;
+  skillInstallation?: never;
+  createRunContexts?: never;
+} | {
+  binDirectory: string;
+  boundary: ModelChangeRunBoundary;
+  close: () => Promise<void>;
+  enabled: true;
+  recoveryRequired: boolean;
+  runtime: import("@rivus/runtime/pi").PiModelRuntime;
+  socketPath: string;
+  skillInstallation: RivusRuntimeManagementSkillInstallResult;
+  createRunContexts: (input: Omit<PiModelRunContextRegistryOptions, "modelManagementEnabled">) => {
+    registry: PiModelRunContextRegistry;
+    unregister: () => void;
+  };
+  model?: never;
+} | undefined>;
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-management-grant.d.ts
+interface PiModelManagementGrantOptions {
+  readonly endpointId: string;
+  readonly environmentOverrides: RivusDaemonEnv;
+  readonly envFilePath?: string;
+  readonly modelAuthPath?: string;
+  readonly thinkingLevel: PiThinkingLevel;
+}
+/** Read the Host's current grant and provider binding without exposing credentials. */
+declare function readPiModelManagementGrant(options: PiModelManagementGrantOptions, homeId: string, baseline: ModelReference): Promise<ModelManagementGrant>;
+//#endregion
+//#region src/adapters/pi/model-management/pi-managed-run-gateway-provider.d.ts
+interface PiManagedRunGatewayProviderOptions {
+  readonly binDirectory: string;
+  readonly contexts: PiModelRunContextRegistry;
+  readonly nodeExecutable: string;
+  readonly socketPath: string;
+  /** Returns the active Gateway Run input; read once per bind. */
+  readonly source: () => AgentLoopInput;
+}
+/**
+ * Gateway-side provider for the Runtime managed-run binding.
+ *
+ * The provider owns policy: it reads the private active Run from the Gateway
+ * closure, verifies the Runtime binding's run/session/signal match that source,
+ * decides whether the source is a single-actor human Feishu Run, and either
+ * issues a model-management context or falls back to the base environment
+ * policy. The Runtime binding never sees the registry, socket path, or
+ * invocation provenance logic.
+ */
+declare function createPiManagedRunGatewayProvider(options: PiManagedRunGatewayProviderOptions): PiManagedRunProvider;
+//#endregion
+//#region src/platform/project/setup/release-descriptor.d.ts
+interface RivusReleaseDescriptor {
+  readonly version: string;
+  readonly dependencies: {
+    readonly "@earendil-works/pi-coding-agent": string;
+    readonly "@larksuiteoapi/node-sdk": string;
+    readonly effect: string;
+  };
+}
+declare const RIVUS_RELEASE_DESCRIPTOR: RivusReleaseDescriptor;
+//#endregion
+//#region src/platform/project/setup/rivus-project-initializer.d.ts
+interface InitializeRivusProjectOptions {
+  readonly directory: string;
+  readonly nodeExecutable: string;
+  readonly releaseDescriptor?: RivusReleaseDescriptor;
+  readonly templateDirectory: string;
+  readonly writeProjectFile?: (path: string, contents: string) => Promise<void>;
+}
+interface InitializedRivusProject {
+  readonly directory: string;
+  readonly files: ReadonlyArray<string>;
+}
+declare function initializeRivusProject(options: InitializeRivusProjectOptions): Promise<InitializedRivusProject>;
+//#endregion
+//#region src/adapters/deployment/inspection/rivus-project-doctor.d.ts
+type RivusProjectDoctorStatus = "pass" | "fail";
+interface RivusProjectDoctorCheck {
+  readonly message: string;
+  readonly name: "node" | "files" | "dependencies" | "manifest" | "credentials";
+  readonly status: RivusProjectDoctorStatus;
+}
+interface RivusProjectDoctorReport {
+  readonly checks: ReadonlyArray<RivusProjectDoctorCheck>;
+  readonly directory: string;
+  readonly ready: boolean;
+}
+interface DiagnoseRivusProjectOptions {
+  readonly directory: string;
+  readonly env: RivusDaemonEnv;
+  readonly envFilePath?: string;
+  readonly nodeVersion: string;
+}
+declare function diagnoseRivusProject(options: DiagnoseRivusProjectOptions): Effect.Effect<RivusProjectDoctorReport, Error>;
+//#endregion
+//#region src/adapters/cli/model/rivus-model-cli-protocol.d.ts
+type RivusModelCliCommand = RivusModelCliStatusCommand | RivusModelCliSetCommand | RivusModelCliRollbackCommand;
+interface RivusModelCliStatusCommand {
+  readonly json: true;
+  readonly operation: "status";
+  readonly requestId?: string;
+  readonly verbose?: true;
+}
+interface RivusModelCliSetCommand {
+  readonly expectedRevision: number;
+  readonly json: true;
+  readonly model: string;
+  readonly operation: "set";
+  readonly requestId: string;
+  readonly verbose?: true;
+}
+interface RivusModelCliRollbackCommand {
+  readonly expectedRevision: number;
+  readonly json: true;
+  readonly operation: "rollback";
+  readonly requestId: string;
+  readonly verbose?: true;
+}
+type RivusModelCliResponse = Record<string, unknown>;
+//#endregion
+//#region src/adapters/cli/model/rivus-model-management-socket-client.d.ts
+interface RivusModelManagementSocketClient {
+  execute(command: RivusModelCliCommand): Promise<RivusModelCliResponse>;
+}
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-process.d.ts
+interface RivusDaemonTransport {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface RivusDaemonWorkerLoop {
+  running(): boolean;
+  start(): void;
+  stop(): Promise<void> | void;
+}
+interface RivusDaemonProcessOptions {
+  readonly transport: RivusDaemonTransport;
+  readonly workerLoop: RivusDaemonWorkerLoop;
+}
+interface RivusDaemonProcess {
+  running(): boolean;
+  start(): Effect.Effect<void, unknown>;
+  stop(): Effect.Effect<void, unknown>;
+}
+declare function createRivusDaemonProcess(options: RivusDaemonProcessOptions): RivusDaemonProcess;
+//#endregion
+//#region src/platform/daemon/process/rivus-daemon-shutdown-controller.d.ts
+type RivusDaemonShutdownSignal = "SIGINT" | "SIGTERM";
+interface RivusDaemonSignalSource {
+  on(signal: RivusDaemonShutdownSignal, listener: () => void): void;
+}
+interface RivusDaemonShutdownControllerOptions {
+  readonly daemon: Pick<RivusDaemonProcess, "stop">;
+  readonly signalSource: RivusDaemonSignalSource;
+  readonly signals?: ReadonlyArray<RivusDaemonShutdownSignal>;
+  readonly onError?: (error: unknown, signal: RivusDaemonShutdownSignal) => void | Promise<void>;
+  readonly onStopped?: (signal: RivusDaemonShutdownSignal) => void | Promise<void>;
+}
+interface RivusDaemonShutdownController {
+  handle(signal: RivusDaemonShutdownSignal): Promise<void>;
+  install(): void;
+  stopping(): boolean;
+}
+declare function createRivusDaemonShutdownController(options: RivusDaemonShutdownControllerOptions): RivusDaemonShutdownController;
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-receive-message.d.ts
+interface FeishuReceiveMessagePayload {
+  readonly header?: {
+    readonly tenant_key?: string;
+  };
+  readonly event: {
+    readonly sender?: {
+      readonly sender_id?: {
+        readonly open_id?: string;
+      };
+      readonly sender_type?: string;
+      readonly tenant_key?: string;
+    };
+    readonly message: {
+      readonly create_time?: string;
+      readonly message_id: string;
+      readonly chat_id: string;
+      readonly chat_type?: string;
+      readonly thread_id?: string;
+      readonly parent_id?: string;
+      readonly root_id?: string;
+      readonly message_type: string;
+      readonly mentions?: ReadonlyArray<{
+        readonly id?: Readonly<Record<string, string>>;
+        readonly key?: string;
+        readonly name?: string;
+      }>;
+      readonly content: string;
+    };
+  };
+}
+//#endregion
+//#region src/adapters/feishu/conversation-session/feishu-session-key.d.ts
+type ConversationSessionKey = string;
+interface FeishuSessionReference {
+  readonly tenantKey: string;
+  readonly chatId: string;
+  readonly threadId?: string;
+  readonly agentId: string;
+}
+type FeishuConversationReference = Omit<FeishuSessionReference, "agentId">;
+declare class InvalidFeishuSessionReference {
+  readonly field: keyof FeishuSessionReference;
+  readonly message: string;
+  readonly _tag = "InvalidFeishuSessionReference";
+  constructor(field: keyof FeishuSessionReference, message: string);
+}
+declare function createFeishuSessionKey(reference: FeishuSessionReference): Effect.Effect<ConversationSessionKey, InvalidFeishuSessionReference>;
+declare function createFeishuConversationId(reference: FeishuConversationReference): Effect.Effect<string, InvalidFeishuSessionReference>;
+//#endregion
+//#region src/adapters/feishu/conversation-session/feishu-session-store.d.ts
+interface FeishuSessionEpochRecord {
+  readonly baseSessionKey: string;
+  readonly generation: number;
+}
+interface FeishuSessionResetResult {
+  readonly generation: number;
+  readonly previousSessionKey: string;
+  readonly sessionKey: string;
+}
+interface FeishuSessionStore {
+  current(baseSessionKey: string): Effect.Effect<string, Error>;
+  reset(baseSessionKey: string): Effect.Effect<FeishuSessionResetResult, Error>;
+}
+interface FeishuSessionStoreOptions {
+  readonly initial?: ReadonlyArray<FeishuSessionEpochRecord>;
+  readonly persist?: (records: ReadonlyArray<FeishuSessionEpochRecord>) => Promise<void>;
+}
+declare function createFeishuSessionStore(options?: FeishuSessionStoreOptions): FeishuSessionStore;
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-message-content.d.ts
+declare class UnsupportedFeishuMessage extends Error {
+  readonly messageType: string;
+  readonly name = "UnsupportedFeishuMessage";
+  readonly _tag = "UnsupportedFeishuMessage";
+  constructor(messageType: string);
+}
+declare class InvalidFeishuMessageContent extends Error {
+  readonly reason: string;
+  readonly name = "InvalidFeishuMessageContent";
+  readonly _tag = "InvalidFeishuMessageContent";
+  constructor(reason: string, options?: ErrorOptions);
+}
+interface FeishuMessageContentInput {
+  readonly content: string;
+  readonly messageType: string;
+}
+declare function readFeishuMessageContent(input: FeishuMessageContentInput): Effect.Effect<string, UnsupportedFeishuMessage | InvalidFeishuMessageContent>;
+//#endregion
+//#region src/adapters/feishu/intake/feishu-message-intake.d.ts
+interface FeishuMessageIntakeOptions {
+  readonly agentId: string;
+  readonly botOpenId?: string;
+  readonly sessionStore?: FeishuSessionStore;
+}
+interface FeishuPromptAgentCommand {
+  readonly conversationId: string;
+  readonly messageId: string;
+  readonly command: PromptCommand;
+  readonly type: "prompt";
+}
+interface FeishuNewSessionCommand {
+  readonly messageId: string;
+  readonly previousSessionKey: SessionKey;
+  readonly sessionKey: SessionKey;
+  readonly type: "new_session";
+}
+interface FeishuCancelRunCommand {
+  readonly type: "cancel_run";
+  readonly messageId: string;
+  /** Omitted when `/cancel` targets the active run in this Feishu session. */
+  readonly runId?: AgentRunId;
+  readonly reason: string;
+  readonly sessionKey?: SessionKey;
+  readonly token?: string;
+}
+type FeishuAgentCommand = FeishuPromptAgentCommand | FeishuNewSessionCommand | FeishuCancelRunCommand;
+type FeishuMessageIntakeSummary = FeishuPromptMessageIntakeSummary | FeishuNewSessionMessageIntakeSummary | FeishuCancelMessageIntakeSummary;
+interface FeishuMessageIntakeBaseSummary {
+  readonly messageId: string;
+  readonly sessionKey: SessionKey;
+  readonly sessionReference: FeishuSessionReference;
+}
+interface FeishuPromptMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "prompt";
+  readonly text: string;
+}
+interface FeishuNewSessionMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "new_session";
+  readonly previousSessionKey: SessionKey;
+}
+interface FeishuCancelMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "cancel_run";
+  readonly reason: string;
+  readonly runId?: AgentRunId;
+}
+type FeishuMessageIntakeError = UnsupportedFeishuMessage | InvalidFeishuMessageContent | InvalidFeishuSessionReference;
+declare function createAgentCommandFromFeishuMessage(payload: FeishuReceiveMessagePayload, options: FeishuMessageIntakeOptions): Effect.Effect<FeishuAgentCommand, FeishuMessageIntakeError>;
+declare function describeFeishuMessageIntake(payload: FeishuReceiveMessagePayload, options: FeishuMessageIntakeOptions): Effect.Effect<FeishuMessageIntakeSummary, FeishuMessageIntakeError>;
+//#endregion
+//#region src/adapters/feishu/intake/feishu-card-action-intake.d.ts
+interface FeishuCardActionTriggerPayload {
+  readonly action?: {
+    readonly tag?: string;
+    readonly value?: unknown;
+  };
+  readonly context?: {
+    readonly chat_id?: string;
+    readonly open_chat_id?: string;
+    readonly open_message_id?: string;
+  };
+  readonly event?: FeishuCardActionTriggerPayload;
+  readonly event_type?: string;
+  readonly operator?: {
+    readonly open_id?: string;
+    readonly tenant_key?: string;
+    readonly union_id?: string;
+    readonly user_id?: string;
+  };
+  readonly token?: string;
+}
+declare class InvalidFeishuCardAction {
+  readonly reason: string;
+  readonly _tag = "InvalidFeishuCardAction";
+  constructor(reason: string);
+}
+declare class UnsupportedFeishuCardAction {
+  readonly reason: string;
+  readonly _tag = "UnsupportedFeishuCardAction";
+  constructor(reason: string);
+}
+type FeishuCardActionIntakeError = InvalidFeishuCardAction | UnsupportedFeishuCardAction;
+interface FeishuResolveInteractionCommand {
+  readonly action: HumanInteractionResolutionAction$1;
+  readonly actor: HumanInteractionActor$1;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly optionId?: string;
+  readonly token: string;
+  readonly type: "resolve_interaction";
+}
+type FeishuCardActionCommand = FeishuCancelRunCommand | FeishuResolveInteractionCommand;
+declare function createAgentCommandFromFeishuCardAction(payload: FeishuCardActionTriggerPayload): Effect.Effect<FeishuCardActionCommand, FeishuCardActionIntakeError>;
+//#endregion
+//#region src/adapters/feishu/card-presentation/streaming/feishu-stream-projector.d.ts
+type FeishuStreamAction = {
+  readonly type: "update_text";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly presentation: RunPresentation;
+  readonly runId: AgentRunId;
+  readonly type: "update_progress";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly runId: AgentRunId;
+  readonly sessionKey: string;
+  readonly text?: string;
+  readonly type: "update_presentation";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "finish";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "fail";
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "cancel";
+  readonly runId: AgentRunId;
+  readonly reason?: string;
+  readonly text?: string;
+};
+interface FeishuStreamProjector {
+  apply(event: AgentDomainEvent): ReadonlyArray<FeishuStreamAction>;
+  applyUpdate(update: AgentRunUpdate): ReadonlyArray<FeishuStreamAction>;
+}
+declare function createFeishuStreamProjector(): FeishuStreamProjector;
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-agent-run-preparation.d.ts
+interface FeishuAgentRunPreparation {
+  readonly messageId: string;
+  readonly prompt: string;
+  readonly receiveId: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+//#endregion
+//#region src/adapters/feishu/intake/feishu-prompt-context.d.ts
+interface FeishuPromptContextInput {
+  readonly payload: FeishuReceiveMessagePayload;
+  readonly text: string;
+}
+/** Resolves conversation context only when a message is about to start a run. */
+interface FeishuPromptContextResolver {
+  resolve(input: FeishuPromptContextInput): Effect.Effect<string, unknown>;
+}
+declare function composeFeishuTopicPrompt(currentText: string, rootText: string): string;
+//#endregion
+//#region src/adapters/feishu/intake/feishu-agent-daemon.d.ts
+interface FeishuAgentDaemonBaseOptions {
+  readonly acknowledgeSteering?: (messageId: string) => Effect.Effect<void, unknown>;
+  readonly agentId: string;
+  readonly botOpenId?: string;
+  readonly dedupe?: boolean;
+  readonly finalizeRun?: (runId: AgentRunId) => Effect.Effect<void>;
+  readonly interactions?: FeishuHumanInteractionActions;
+  readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly publishRunUpdate?: AgentRunUpdateHandler;
+  readonly reply?: (messageId: string, text: string) => Effect.Effect<void, unknown>;
+  readonly promptContext?: FeishuPromptContextResolver;
+  readonly resolveInvocation?: (payload: FeishuReceiveMessagePayload, conversationId: string) => AgentInvocationOrigin;
+  readonly sessionStore?: FeishuSessionStore;
+}
+type FeishuAgentDaemonOptions = FeishuAgentDaemonBaseOptions & ({
+  readonly execution: FeishuAgentExecution;
+  readonly harness?: never;
+} | {
+  readonly execution?: never;
+  readonly harness: AgentHarness;
+});
+interface FeishuAgentExecutionResult extends StandardAgentRunResult {}
+interface FeishuAgentExecution extends AgentExecutionControlPort {
+  promptWithUpdates(command: PromptCommand, onUpdate: AgentRunUpdateHandler): Effect.Effect<FeishuAgentExecutionResult, unknown>;
+}
+interface FeishuAgentDaemonRunResult {
+  readonly messageId: string;
+  readonly runId: string;
+  readonly finalText: string;
+}
+interface FeishuAgentDaemonSkippedResult {
+  readonly messageId: string;
+  readonly skipped: true;
+  readonly reason: "duplicate";
+}
+interface FeishuAgentDaemonCancelResult {
+  readonly cancelled: boolean;
+  readonly messageId: string;
+  readonly runId?: AgentRunId;
+  readonly reason?: "not_active";
+}
+interface FeishuAgentDaemonSteeredResult {
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+  readonly steered: true;
+}
+interface FeishuAgentDaemonInteractionResult {
+  readonly interaction: HumanInteractionSnapshot;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly resolved: true;
+}
+interface FeishuAgentDaemonSessionResetResult {
+  readonly messageId: string;
+  readonly previousSessionKey: SessionKey;
+  readonly sessionKey: SessionKey;
+  readonly reset: true;
+}
+interface FeishuHumanInteractionActions {
+  resolve(input: ResolveHumanInteractionInput$1): Effect.Effect<HumanInteractionSnapshot, unknown>;
+}
+type FeishuAgentDaemonHandleResult = FeishuAgentDaemonRunResult | FeishuAgentDaemonSkippedResult | FeishuAgentDaemonCancelResult | FeishuAgentDaemonSteeredResult | FeishuAgentDaemonInteractionResult | FeishuAgentDaemonSessionResetResult;
+interface FeishuAgentPreparedControl {
+  execute(): Effect.Effect<FeishuAgentDaemonHandleResult | undefined, unknown>;
+}
+type FeishuAgentMessageSideEffects = "enabled" | "disabled";
+interface FeishuAgentDaemonHandleMessageOptions {
+  readonly sideEffects?: FeishuAgentMessageSideEffects;
+}
+interface FeishuAgentDaemon {
+  handleCardAction(payload: FeishuCardActionTriggerPayload): Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+  prepareControlMessage(payload: FeishuReceiveMessagePayload): Effect.Effect<FeishuAgentPreparedControl | undefined, unknown>;
+  trySteerMessage(payload: FeishuReceiveMessagePayload): Effect.Effect<FeishuAgentDaemonHandleResult | undefined, unknown>;
+  handleMessage(payload: FeishuReceiveMessagePayload, options?: FeishuAgentDaemonHandleMessageOptions): Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+}
+declare function createFeishuAgentDaemon(options: FeishuAgentDaemonOptions): FeishuAgentDaemon;
+//#endregion
+//#region src/platform/durable-queue/processing/durable-queue.d.ts
+interface DurableQueuePreparedAction<Result> {
+  execute(): Effect.Effect<Result | undefined, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/inbound-delivery/feishu-inbound-delivery.d.ts
+type FeishuMessageAcceptResult = {
+  readonly accepted: true;
+  readonly messageId: string;
+  readonly pending: number;
+} | {
+  readonly accepted: false;
+  readonly messageId: string;
+  readonly pending: number;
+  readonly reason: "capacity" | "duplicate" | "ignored";
+};
+//#endregion
+//#region src/adapters/feishu/runtime/feishu-receive-status.d.ts
+type FeishuReceiveMessageReplayOptions = FeishuAgentDaemonHandleMessageOptions;
+interface FeishuReceiveMessageSummary {
+  readonly chatId: string;
+  readonly messageId: string;
+  readonly tenantKey?: string;
+  readonly threadId?: string;
+}
+interface FeishuReceiveAcceptedObservation {
+  readonly accepted: FeishuMessageAcceptResult;
+  readonly message: FeishuReceiveMessageSummary;
+  readonly observedAt: Date;
+}
+interface FeishuReceiveHandledObservation {
+  readonly intake: FeishuMessageIntakeSummary;
+  readonly messageId: string;
+  readonly observedAt: Date;
+  readonly result: FeishuAgentDaemonHandleResult;
+}
+interface FeishuReceiveRuntimeStatus {
+  readonly lastAccepted?: FeishuReceiveAcceptedObservation;
+  readonly lastHandled?: FeishuReceiveHandledObservation;
+}
+interface FeishuMessageWorkerDrainAvailableResult {
+  readonly drained: number;
+  readonly results: ReadonlyArray<{
+    readonly handled: true;
+    readonly messageId: string;
+    readonly result: FeishuAgentDaemonHandleResult;
+  }>;
+}
+interface FeishuReceiveMessageReplayResult {
+  readonly accepted: FeishuMessageAcceptResult;
+  readonly drained: FeishuMessageWorkerDrainAvailableResult;
+  readonly intake: FeishuMessageIntakeSummary;
+}
+//#endregion
+//#region src/adapters/agent/runtime/process-agent-runtime-adapter.d.ts
+interface ProcessAgentRuntimeInput extends Omit<AgentRuntimeInput$1, "onUpdate"> {
+  readonly onUpdate?: (update: AgentRunUpdate) => void | Promise<void>;
+}
+interface ProcessAgentRuntime {
+  readonly concurrency?: "managed";
+  cancel?(input: AgentRuntimeCancellation$1): Promise<boolean>;
+  dispose?(): Promise<void> | void;
+  run(input: ProcessAgentRuntimeInput): Promise<unknown>;
+  steer?(input: AgentRuntimeSteering$1): Promise<boolean>;
+}
+//#endregion
+//#region src/core/application/background-session/supervision/background-session-delivery-queue.d.ts
+type BackgroundSessionDeliveryKindForSupervisor = "progress" | "final" | "stopped" | "failed" | "reconciliation";
+type BackgroundSessionDeliverySink = (delivery: {
+  readonly deliveryId: string;
+  readonly kind: BackgroundSessionDeliveryKindForSupervisor;
+  readonly sessionId: string;
+  readonly text: string;
+}) => Promise<{
+  readonly providerMessageId: string;
+}>;
+//#endregion
+//#region src/core/application/background-session/supervision/background-session-supervisor.d.ts
+interface BackgroundSessionLimits {
+  readonly intervalMs: number;
+  readonly leaseMs: number;
+  readonly leaseRenewalIntervalMs: number;
+  readonly maxConcurrentSessions: number;
+  readonly maxConsecutiveFailures: number;
+  readonly retryBackoffMs: number;
+  readonly sessionLifetimeMs: number;
+}
+interface BackgroundSessionStepResult {
+  readonly finalText: string;
+  readonly runId: string;
+}
+interface BackgroundSessionSupervisorOptions$1 {
+  readonly clock: {
+    now(): string;
+  };
+  readonly config: BackgroundSessionLimits;
+  readonly deliveries: BackgroundSessionDeliveryStore;
+  readonly deliver: BackgroundSessionDeliverySink;
+  readonly onError?: (error: unknown) => void;
+  readonly repository: BackgroundSessionRepository$1;
+  readonly runStep: (input: {
+    readonly session: BackgroundSession;
+    readonly signal: AbortSignal;
+    readonly wakeText: string;
+  }) => Promise<BackgroundSessionStepResult>;
+  readonly sleep: (ms: number) => Effect.Effect<void>;
+}
+interface BackgroundSessionSupervisorStatus {
+  readonly capacity: number;
+  readonly counters: {
+    readonly completed: number;
+    readonly deliveriesDelivered: number;
+    readonly failed: number;
+    readonly started: number;
+    readonly staleLeaseEventsDropped: number;
+    readonly stopped: number;
+  };
+  readonly inFlightSteps: number;
+  readonly oldestDueAt?: string;
+  readonly owner: string;
+  readonly phaseCounts: Readonly<Record<BackgroundSessionPhase, number>>;
+  readonly reconciliationCount: number;
+  readonly repositoryHealthy: boolean;
+  readonly running: boolean;
+}
+interface BackgroundSessionSupervisor {
+  recover(): Effect.Effect<void>;
+  start(): Effect.Effect<void>;
+  status(): BackgroundSessionSupervisorStatus;
+  stop(): Effect.Effect<void>;
+  tick(): Effect.Effect<void>;
+}
+//#endregion
+//#region src/core/application/deployment/contracts/manifest.d.ts
+interface RivusPluginDeclaration {
+  readonly id: string;
+  readonly module: string;
+  readonly required: boolean;
+}
+interface RivusDeploymentManifest {
+  readonly agents: ReadonlyArray<RivusAgentDeployment>;
+  readonly automations?: ReadonlyArray<RivusAutomationDeployment>;
+  readonly backgroundSessions?: RivusBackgroundSessionsDeployment;
+  readonly defaultAgentId: string;
+  readonly defaultEndpointId: string;
+  readonly endpoints: ReadonlyArray<RivusEndpointDeployment>;
+  readonly plugins: ReadonlyArray<RivusPluginDeclaration>;
+  readonly projectSpaces?: ReadonlyArray<RivusProjectSpaceDeployment>;
+}
+interface RivusBackgroundSessionsDeployment {
+  readonly enabled: boolean;
+  readonly leaseMs: number;
+  readonly leaseRenewalIntervalMs: number;
+  readonly maxConsecutiveFailures: number;
+  readonly maxConcurrentSessions: number;
+  readonly required: boolean;
+  readonly retryBackoffMs: number;
+  readonly sessionLifetimeMs: number;
+  readonly stepTimeoutMs: number;
+}
+type RivusAutomationDeliveryTargetType = "chat_id" | "open_id" | "user_id" | "union_id" | "email";
+interface RivusAutomationDelivery {
+  readonly endpointId: string;
+  readonly targetRef: string;
+  readonly targetType: RivusAutomationDeliveryTargetType;
+}
+interface RivusAutomationDeployment {
+  readonly agentId: string;
+  readonly delivery: RivusAutomationDelivery;
+  readonly enabled: boolean;
+  readonly id: string;
+  readonly required: boolean;
+  readonly schedule: string;
+  readonly templateId: string;
+  readonly timeZone: string;
+}
+interface RivusEndpointDeployment {
+  readonly agentId: string;
+  readonly baseUrl: string;
+  readonly cardStreamLeaseMs: number;
+  readonly credentialRef: string;
+  readonly enabled: boolean;
+  readonly experimental?: RivusEndpointExperimentalFeatures;
+  readonly groupPolicy: "mention-only" | "ignore-unmentioned" | "default-responder";
+  readonly id: string;
+  readonly progressDisplay?: "hidden" | "collapsed" | "expanded";
+  readonly required: boolean;
+  readonly sessionNamespace: string;
+  readonly streamMinIntervalMs: number;
+}
+interface RivusEndpointExperimentalFeatures {
+  readonly cotMessages: boolean;
+}
+interface RivusProjectSpaceDeployment {
+  readonly id: string;
+  readonly root: string;
+  readonly workingDirectory: string;
+  readonly skills: {
+    readonly sources: ReadonlyArray<string>;
+  };
+}
+//#endregion
+//#region src/core/application/deployment/contracts/deployment.d.ts
+interface RivusPluginLoadStatus {
+  readonly error?: string;
+  readonly id: string;
+  readonly module: string;
+  readonly required: boolean;
+  readonly status: "loaded" | "failed";
+  readonly version?: string;
+}
+interface RivusAgentDeploymentStatus {
+  readonly agentId: string;
+  readonly definition?: ResolvedRivusAgentDefinition;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly reason?: string;
+  readonly status: "enabled" | "disabled";
+}
+interface ResolvedRivusAutomationDefinition extends RivusAutomationDeployment {
+  readonly runtimeDefinition: ResolvedRivusAgentDefinition;
+  readonly template: RegisteredRivusAutomation;
+}
+interface ResolvedRivusProjectSpace {
+  readonly id: string;
+  readonly root: string;
+  readonly workingDirectory: string;
+  readonly skillPaths: ReadonlyArray<string>;
+  readonly revision: string;
+}
+interface LoadedRivusDeployment {
+  readonly agents: ReadonlyArray<RivusAgentDeploymentStatus>;
+  readonly automationDefinitions: ReadonlyArray<ResolvedRivusAutomationDefinition>;
+  readonly catalog: RivusPluginCatalog;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly manifest: RivusDeploymentManifest;
+  readonly plugins: ReadonlyArray<RivusPluginLoadStatus>;
+}
+interface RivusPluginModuleLoadRequest {
+  readonly deploymentRoot: string;
+  readonly module: string;
+  readonly pluginId: string;
+}
+interface RivusDeploymentBackgroundSessionCancellation {
+  readonly agentId: string;
+  readonly reason?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+}
+//#endregion
+//#region src/adapters/deployment/process/process-deployment-adapters.d.ts
+interface ProcessDeploymentRuntime extends ProcessAgentRuntime {}
+interface CreateProcessDeploymentRuntimeInput extends AgentInstanceRecord {
+  readonly catalog: RivusPluginCatalog;
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly projectSpace?: ResolvedRivusProjectSpace;
+}
+interface ProcessDeploymentEndpoint {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface CreateProcessDeploymentEndpointInput {
+  readonly agentId: string;
+  readonly cancel: (input: AgentRuntimeCancellation$1) => Promise<boolean>;
+  readonly definition: RivusEndpointDeployment;
+  readonly endpointId: string;
+  readonly handle: (input: ProcessAgentRuntimeInput) => Promise<unknown>;
+  readonly instanceId: string;
+  readonly projectSpaceId?: string;
+  readonly steer?: (input: AgentRuntimeSteering$1) => Promise<boolean>;
+}
+interface ProcessDeploymentAutomation {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface CreateProcessDeploymentAutomationInput {
+  readonly automationId: string;
+  readonly definition: ResolvedRivusAutomationDefinition;
+  readonly deliveryEndpoint: RivusEndpointDeployment;
+  readonly instanceId: string;
+  readonly run: (input: ScheduledAutomationRunInput) => Promise<unknown>;
+}
+interface ProcessDeploymentBackgroundSession {
+  running(): boolean;
+  start(): Promise<void> | void;
+  status?(): BackgroundSessionSupervisorStatus;
+  stop(): Promise<void> | void;
+}
+interface CreateProcessDeploymentBackgroundSessionInput {
+  readonly agentIds: ReadonlyArray<string>;
+  readonly cancel: (input: RivusDeploymentBackgroundSessionCancellation) => Promise<boolean>;
+  readonly config: RivusBackgroundSessionsDeployment;
+  readonly run: (input: {
+    readonly agentId: string;
+    readonly invocation: AgentInvocationOrigin;
+    readonly onUpdate?: (update: AgentRunUpdate) => void | Promise<void>;
+    readonly sessionKey: string;
+    readonly text: string;
+  }) => Promise<unknown>;
+}
+//#endregion
+//#region src/core/application/background-session/authority/background-session-authority.d.ts
+declare const BACKGROUND_SESSION_TOOL_IDS: readonly ["background.start", "background.wait", "background.list", "background.status", "background.send", "background.stop"];
+declare const BACKGROUND_SESSION_START_TOOL_ID = "background.start";
+declare const BACKGROUND_SESSION_TOOL_PLUGIN_ID = "rivus-core";
+declare const BACKGROUND_SESSION_TOOL_VERSION = "1.0.0";
+interface BackgroundSessionToolContract {
+  readonly description: string;
+  readonly digest: string;
+  readonly id: string;
+  readonly idempotency: "none" | "supported" | "required";
+  readonly inputSchema: unknown;
+  readonly pluginId: string;
+  readonly risk: "observe" | "mutate" | "irreversible" | "host-control";
+  readonly version: string;
+}
+interface BackgroundSessionToolGrantSet {
+  readonly revision: string;
+  readonly toolIds: ReadonlyArray<string>;
+}
+interface BackgroundSessionAgentDefinition {
+  readonly agentId: string;
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly memory: {
+    readonly scopes: ReadonlyArray<BackgroundSessionMemoryScope>;
+  };
+  readonly model: Readonly<Record<string, unknown>>;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly profileRevision: string;
+  readonly projectSpaceId?: string;
+  readonly projectSpaceRevision?: string;
+  readonly skillGrantSet: {
+    readonly revision: string;
+    readonly skillIds: ReadonlyArray<string>;
+  };
+  readonly skills: ReadonlyArray<unknown>;
+  readonly systemPrompt: string;
+  readonly tools: ReadonlyArray<BackgroundSessionToolContract>;
+  readonly toolGrantSet: BackgroundSessionToolGrantSet;
+}
+type TransformedBackgroundSessionDefinition<T extends BackgroundSessionAgentDefinition> = Omit<T, "toolGrantSet" | "tools"> & {
+  readonly toolGrantSet: BackgroundSessionToolGrantSet;
+  readonly tools: ReadonlyArray<BackgroundSessionToolContract>;
+};
+declare function createBackgroundSessionToolContracts(): ReadonlyArray<BackgroundSessionToolContract>;
+declare function backgroundSessionToolIds(): ReadonlyArray<string>;
+declare function isBackgroundSessionToolId(toolId: string): boolean;
+//#endregion
+//#region src/core/application/deployment/lifecycle/deployment-lifecycle.d.ts
+type RivusDeploymentComponentLifecycle = "disabled" | "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+type RivusDeploymentControlLifecycle = "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+declare class RivusDeploymentDaemonLifecycleError extends Error {
+  readonly name = "RivusDeploymentDaemonLifecycleError";
+}
+//#endregion
+//#region src/core/application/deployment/lifecycle/deployment-control.d.ts
+type RivusDeploymentDaemonLifecycle = RivusDeploymentControlLifecycle;
+type RivusDeploymentEndpointLifecycle = RivusDeploymentComponentLifecycle;
+type RivusDeploymentAutomationLifecycle = RivusDeploymentComponentLifecycle;
+type RivusDeploymentBackgroundSessionLifecycle = RivusDeploymentComponentLifecycle;
+interface RivusDeploymentEndpointStatus extends RivusDeploymentComponentStatus {
+  readonly agentId: string;
+  readonly endpointId: string;
+}
+interface RivusDeploymentAutomationStatus extends RivusDeploymentComponentStatus {
+  readonly agentId: string;
+  readonly automationId: string;
+}
+interface RivusDeploymentBackgroundSessionStatus extends RivusDeploymentComponentStatus {
+  readonly supervisor?: BackgroundSessionSupervisorStatus;
+}
+interface RivusDeploymentComponentStatus {
+  readonly enabled: boolean;
+  readonly error?: string;
+  readonly lifecycle: RivusDeploymentComponentLifecycle;
+  readonly required: boolean;
+  readonly running: boolean;
+}
+interface RivusDeploymentDaemonStatus {
+  readonly agents: LoadedRivusDeployment["agents"];
+  readonly automations: ReadonlyArray<RivusDeploymentAutomationStatus>;
+  readonly backgroundSessions?: RivusDeploymentBackgroundSessionStatus;
+  readonly defaultAgentId: string;
+  readonly defaultEndpointId: string;
+  readonly endpoints: ReadonlyArray<RivusDeploymentEndpointStatus>;
+  readonly lifecycle: RivusDeploymentDaemonLifecycle;
+  readonly plugins: LoadedRivusDeployment["plugins"];
+  readonly ready: boolean;
+  readonly running: boolean;
+}
+declare class RivusDeploymentReadinessError extends Error {
+  readonly endpointIds: ReadonlyArray<string>;
+  readonly name = "RivusDeploymentReadinessError";
+  constructor(endpointIds: ReadonlyArray<string>);
+}
+declare class RivusDeploymentAutomationReadinessError extends Error {
+  readonly automationIds: ReadonlyArray<string>;
+  readonly name = "RivusDeploymentAutomationReadinessError";
+  constructor(automationIds: ReadonlyArray<string>);
+}
+declare class RivusDeploymentBackgroundSessionReadinessError extends Error {
+  readonly name = "RivusDeploymentBackgroundSessionReadinessError";
+  constructor();
+}
+//#endregion
+//#region src/core/application/recovery/contracts/recovery-control.d.ts
+type RecoveryToolOperationOutcome = {
+  readonly result: unknown;
+  readonly status: "applied";
+} | {
+  readonly status: "not-applied";
+};
+interface DeadLetterRecoveryItem {
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly deliveryId: string;
+  readonly endpointId: string;
+  readonly failureCode: "delivery_failed";
+  readonly failureSummary: string;
+  readonly failedAt: string;
+  readonly revision: number;
+}
+interface DeadLetterRequeueResult {
+  readonly acceptedAt: string;
+  readonly attempts: 0;
+  readonly availableAt: string;
+  readonly deliveryId: string;
+  readonly endpointId: string;
+  readonly recoveredAt: string;
+  readonly recoveredBy: string;
+  readonly revision: number;
+  readonly status: "pending";
+}
+interface RecoverySnapshot {
+  readonly deadLetters: ReadonlyArray<DeadLetterRecoveryItem>;
+  readonly toolOperations: ReadonlyArray<ToolOperationRecoveryItem>;
+}
+interface ToolOperationRecoveryItem {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly failureCode: "tool_outcome_unknown";
+  readonly failureSummary: string;
+  readonly revision: number;
+  readonly status: "reconciliation-required";
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface ToolOperationResolutionResult {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly reconciledAt: string;
+  readonly reconciledBy: string;
+  readonly revision: number;
+  readonly status: "aborted" | "completed";
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface RecoveryControl {
+  inspect(): Effect.Effect<RecoverySnapshot, unknown>;
+  requeueDeadLetter(input: {
+    readonly actorId: string;
+    readonly deliveryId: string;
+    readonly endpointId: string;
+    readonly expectedRevision: number;
+    readonly note: string;
+  }): Effect.Effect<DeadLetterRequeueResult, unknown>;
+  resolveToolOperation(input: {
+    readonly actorId: string;
+    readonly expectedRevision: number;
+    readonly instanceId: string;
+    readonly note: string;
+    readonly operationId: string;
+    readonly outcome: RecoveryToolOperationOutcome;
+  }): Effect.Effect<ToolOperationResolutionResult, unknown>;
+}
+//#endregion
+//#region src/bootstrap/deployment/rivus-deployment-cli-process.d.ts
+interface RivusDeploymentBootstrapAdapters {
+  readonly initialInstanceRecords?: AgentInstanceRegistryOptions["initialRecords"];
+  readonly dispose?: () => Promise<void> | void;
+  readonly createAutomation?: (input: CreateProcessDeploymentAutomationInput) => ProcessDeploymentAutomation | Promise<ProcessDeploymentAutomation>;
+  readonly createBackgroundSession?: (input: CreateProcessDeploymentBackgroundSessionInput) => ProcessDeploymentBackgroundSession | Promise<ProcessDeploymentBackgroundSession>;
+  readonly createRecoveryControl?: () => Promise<RecoveryControl> | RecoveryControl;
+  readonly createRuntime: (input: CreateProcessDeploymentRuntimeInput) => ProcessDeploymentRuntime | Promise<ProcessDeploymentRuntime>;
+  readonly createEndpoint: (input: CreateProcessDeploymentEndpointInput) => ProcessDeploymentEndpoint | Promise<ProcessDeploymentEndpoint>;
+  readonly replayReceiveMessage?: (handleDefault: (input: ProcessAgentRuntimeInput) => Promise<unknown>, payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions) => Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+interface RivusDeploymentBootstrapContext {
+  readonly argv: ReadonlyArray<string>;
+  readonly env: RivusDaemonEnv;
+  /** Explicit original configuration source, required for controlled export on disable. */
+  readonly envFilePath?: string;
+  /** Environment values before the explicit env file is merged. */
+  readonly environmentOverrides?: RivusDaemonEnv;
+  readonly manifestPath: string;
+  readonly pluginPackageManifestPath?: string;
+}
+type RivusDeploymentBootstrapFactory = (context: RivusDeploymentBootstrapContext) => Promise<RivusDeploymentBootstrapAdapters> | RivusDeploymentBootstrapAdapters;
+interface RivusDeploymentCliProcess extends RivusDaemonProcess {
+  readonly defaultSessionKey: string;
+  openRecoveryControl(): Effect.Effect<RecoveryControl, unknown>;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+  replayReceiveMessage?(payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions): Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+  status(): Effect.Effect<RivusDeploymentDaemonStatus>;
+}
+declare function createRivusDeploymentCliProcess(factory: RivusDeploymentBootstrapFactory, context: RivusDeploymentBootstrapContext): Promise<RivusDeploymentCliProcess>;
+//#endregion
+//#region src/bootstrap/daemon/rivus-daemon-cli.d.ts
+interface RivusDaemonBootstrapContext {
+  readonly argv: ReadonlyArray<string>;
+  readonly config: RivusDaemonConfig;
+  readonly env: RivusDaemonEnv;
+}
+type RivusDaemonBootstrapFactory = (context: RivusDaemonBootstrapContext) => Promise<RivusDaemonProcess> | RivusDaemonProcess;
+interface RivusDaemonBootstrapModule {
+  readonly createRivusDaemonProcess?: RivusDaemonBootstrapFactory;
+  readonly createRivusDeploymentAdapters?: RivusDeploymentBootstrapFactory;
+  readonly default?: RivusDaemonBootstrapFactory;
+}
+interface RivusDaemonCliWriter {
+  write(text: string): unknown;
+}
+interface RivusDaemonPromptRunner {
+  readonly defaultSessionKey?: string;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+}
+interface RivusDaemonFeishuReplayRunner {
+  replayReceiveMessage(payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions): Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+interface RivusDaemonRecoveryRunner {
+  openRecoveryControl(): Effect.Effect<RecoveryControl, unknown>;
+}
+interface RivusDaemonCliOptions {
+  readonly argv: ReadonlyArray<string>;
+  readonly env: RivusDaemonEnv;
+  readonly exitAfterSignal?: (exitCode: number) => void;
+  readonly loadBootstrap?: (specifier: string) => Promise<RivusDaemonBootstrapModule>;
+  readonly signalSource: RivusDaemonSignalSource;
+  readonly stderr: RivusDaemonCliWriter;
+  readonly stdout: RivusDaemonCliWriter;
+  readonly pluginPackageManifestPath?: string;
+}
+declare function runRivusDaemonCli(options: RivusDaemonCliOptions): Effect.Effect<number>;
+//#endregion
+//#region src/bootstrap/cli/rivus-cli.d.ts
+interface RivusCliOptions extends RivusDaemonCliOptions {
+  readonly changeWorkingDirectory: (directory: string) => void;
+  readonly cwd: string;
+  readonly homeApi: RivusHomeApi;
+  readonly homeDirectory: string;
+  readonly nodeExecutable: string;
+  readonly nodeVersion: string;
+  readonly modelManagementClient?: RivusModelManagementSocketClient;
+}
+declare function runRivusCli(options: RivusCliOptions): Effect.Effect<number>;
+//#endregion
+//#region src/bootstrap/cli/rivus-node-entrypoint.d.ts
+interface RivusNodeEntrypointOptions {
+  readonly argv: ReadonlyArray<string>;
+  readonly changeWorkingDirectory: (directory: string) => void;
+  readonly cwd: string;
+  readonly env: RivusDaemonEnv;
+  readonly exitAfterSignal?: RivusCliOptions["exitAfterSignal"];
+  readonly signalSource: RivusCliOptions["signalSource"];
+  readonly stderr: RivusCliOptions["stderr"];
+  readonly stdout: RivusCliOptions["stdout"];
+}
+declare function runRivusNodeEntrypoint(options: RivusNodeEntrypointOptions): Effect.Effect<number>;
+//#endregion
+//#region src/core/application/run-presentation/projection/conversation-progress.d.ts
+declare const DEFAULT_CONVERSATION_PROGRESS_DISPLAY: "collapsed";
+type ConversationProgressDisplay = "hidden" | "collapsed" | "expanded";
+//#endregion
+//#region src/adapters/feishu/card-presentation/delivery/feishu-card-delivery-ledger.d.ts
+interface FeishuCardDeliveryRecord {
+  readonly revision: number;
+  readonly runId: AgentRunId;
+  readonly sequence: number;
+  readonly terminalPublished: boolean;
+}
+interface FeishuCardDeliveryLedger {
+  isTerminalPublished(runId: AgentRunId): boolean;
+  markTerminal(runId: AgentRunId): Effect.Effect<void, unknown>;
+  reserveSequence(runId: AgentRunId): Effect.Effect<number, unknown>;
+}
+interface FeishuCardDeliveryLedgerStateOptions {
+  readonly initial?: ReadonlyArray<FeishuCardDeliveryRecord>;
+  readonly persist?: (record: FeishuCardDeliveryRecord) => Promise<void>;
+}
+interface FeishuCardDeliveryReconciler {
+  reconcile(): Effect.Effect<{
+    readonly repaired: number;
+    readonly skipped: number;
+    readonly terminalRuns: number;
+  }, unknown>;
+}
+interface FeishuCardDeliveryReconcilerOptions {
+  readonly events: ReadonlyArray<AgentDomainEvent>;
+  readonly ledger: FeishuCardDeliveryLedger;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+}
+declare function createFeishuCardDeliveryLedger(options?: FeishuCardDeliveryLedgerStateOptions): FeishuCardDeliveryLedger;
+declare function createFeishuCardDeliveryReconciler(options: FeishuCardDeliveryReconcilerOptions): FeishuCardDeliveryReconciler;
+//#endregion
+//#region src/adapters/compatibility/card-presentation/jsonl-feishu-card-delivery-ledger.d.ts
+interface JsonlFeishuCardDeliveryLedgerOptions {
+  readonly filePath: string;
+}
+declare function openJsonlFeishuCardDeliveryLedger(options: JsonlFeishuCardDeliveryLedgerOptions): Promise<FeishuCardDeliveryLedger>;
+//#endregion
+//#region src/adapters/compatibility/inbound-delivery/feishu-inbox-repository.d.ts
+interface FeishuInboxPendingState {
+  readonly availableAt: string;
+  readonly status: "pending";
+}
+interface FeishuInboxLeasedState {
+  readonly leaseExpiresAt: string;
+  readonly leaseId: string;
+  readonly leasedAt: string;
+  readonly status: "leased";
+}
+interface FeishuInboxCompletedState {
+  readonly completedAt: string;
+  readonly status: "completed";
+}
+interface FeishuInboxDeadState {
+  readonly failedAt: string;
+  readonly reason: string;
+  readonly status: "dead";
+}
+type FeishuInboxDeliveryState = FeishuInboxPendingState | FeishuInboxLeasedState | FeishuInboxCompletedState | FeishuInboxDeadState;
+interface FeishuInboxDelivery {
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly id: string;
+  readonly laneKey: string;
+  readonly options?: FeishuAgentDaemonHandleMessageOptions;
+  readonly payload: FeishuReceiveMessagePayload;
+  readonly recovery?: RecoveryAction;
+  readonly revision: number;
+  readonly state: FeishuInboxDeliveryState;
+}
+interface FeishuInboxClaimInput {
+  readonly leaseExpiresAt: string;
+  readonly leaseId: string;
+  readonly now: string;
+}
+interface FeishuInboxClaimByIdInput extends FeishuInboxClaimInput {
+  readonly id: string;
+}
+interface FeishuInboxCompleteInput {
+  readonly completedAt: string;
+  readonly id: string;
+  readonly leaseId: string;
+}
+interface FeishuInboxFailInput {
+  readonly availableAt?: string;
+  readonly failedAt: string;
+  readonly id: string;
+  readonly leaseId: string;
+  readonly reason: string;
+  readonly terminal: boolean;
+}
+interface FeishuInboxReleaseInput {
+  readonly availableAt: string;
+  readonly id: string;
+  readonly leaseId: string;
+}
+interface FeishuInboxRepository {
+  admit(delivery: FeishuInboxDelivery, maxPending: number): Effect.Effect<"created" | "duplicate" | "capacity", unknown>;
+  claim(input: FeishuInboxClaimInput): Effect.Effect<FeishuInboxDelivery | undefined, unknown>;
+  claimById(input: FeishuInboxClaimByIdInput): Effect.Effect<FeishuInboxDelivery | undefined, unknown>;
+  complete(input: FeishuInboxCompleteInput): Effect.Effect<void, unknown>;
+  create(delivery: FeishuInboxDelivery): Effect.Effect<boolean, unknown>;
+  deadLetters(): ReadonlyArray<FeishuInboxDelivery>;
+  fail(input: FeishuInboxFailInput): Effect.Effect<void, unknown>;
+  pendingCount(): number;
+  requeueDeadLetter(input: {
+    readonly availableAt: string;
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly recovery: RecoveryAction;
+  }): Effect.Effect<FeishuInboxDelivery, unknown>;
+  release(input: FeishuInboxReleaseInput): Effect.Effect<void, unknown>;
+}
+interface FeishuInboxRepositoryStateOptions {
+  readonly initial?: ReadonlyArray<FeishuInboxDelivery>;
+  readonly persist?: (delivery: FeishuInboxDelivery) => Promise<void>;
+}
+declare function createFeishuInboxRepository(options?: FeishuInboxRepositoryStateOptions): FeishuInboxRepository;
+//#endregion
+//#region src/adapters/compatibility/recovery/recovery-control.d.ts
+interface RecoveryControlOptions {
+  readonly clock: {
+    readonly now: () => string;
+  };
+  readonly inboxes: ReadonlyArray<{
+    readonly endpointId: string;
+    readonly repository: FeishuInboxRepository;
+  }>;
+  readonly toolOperations: ReadonlyArray<{
+    readonly instanceId: string;
+    readonly ledger: ToolOperationLedger$1;
+  }>;
+}
+declare function createRecoveryControl(options: RecoveryControlOptions): RecoveryControl;
+//#endregion
+//#region src/adapters/compatibility/inbound-delivery/jsonl-feishu-inbox-repository.d.ts
+interface JsonlFeishuInboxRepositoryOptions {
+  readonly filePath: string;
+}
+declare function openJsonlFeishuInboxRepository(options: JsonlFeishuInboxRepositoryOptions): Promise<FeishuInboxRepository>;
+//#endregion
+//#region src/adapters/compatibility/conversation-session/json-feishu-session-store.d.ts
+interface OpenJsonFeishuSessionStoreOptions {
+  readonly filePath: string;
+}
+declare function openJsonFeishuSessionStore(options: OpenJsonFeishuSessionStoreOptions): Promise<FeishuSessionStore>;
+//#endregion
+//#region src/adapters/compatibility/agent-host/session-scheduler.d.ts
+interface SessionSchedulerOptions {
+  readonly createRuntime: (sessionKey: string) => PooledAgentRuntime | Promise<PooledAgentRuntime>;
+  readonly maxConcurrentSessions: number;
+  readonly maxQueuedRuns: number;
+}
+interface SessionSchedulerStatus {
+  readonly activeSessions: number;
+  readonly queuedRuns: number;
+  readonly sessions: number;
+}
+interface SessionScheduler extends PooledAgentRuntime {
+  readonly concurrency: "managed";
+  status(): SessionSchedulerStatus;
+}
+declare class SessionSchedulerCapacityExceeded extends Error {
+  readonly name = "SessionSchedulerCapacityExceeded";
+}
+declare class SessionSchedulerDisposed extends Error {
+  readonly name = "SessionSchedulerDisposed";
+}
+declare function createSessionScheduler(options: SessionSchedulerOptions): SessionScheduler;
+//#endregion
+//#region src/adapters/http/client/json-fetch-request.d.ts
+interface JsonHttpRequest {
+  readonly method: string;
+  readonly url: string;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly body?: unknown;
+}
+interface JsonHttpResponse {
+  readonly status: number;
+  readonly body: unknown;
+}
+interface FetchLikeResponse {
+  readonly status: number;
+  json(): Promise<unknown>;
+}
+type FetchLike = (url: string, init: {
+  readonly method: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body?: string;
+  readonly signal: AbortSignal;
+}) => Promise<FetchLikeResponse>;
+interface JsonFetchRequestOptions {
+  readonly fetch?: FetchLike;
+}
+declare function createJsonFetchRequest(options?: JsonFetchRequestOptions): (request: JsonHttpRequest) => Effect.Effect<JsonHttpResponse, unknown>;
+//#endregion
+//#region src/adapters/feishu/config/feishu-endpoint-credentials.d.ts
+interface FeishuEndpointCredentials {
+  readonly appId: string;
+  readonly appSecret: string;
+}
+declare class FeishuEndpointCredentialError extends Error {
+  readonly name = "FeishuEndpointCredentialError";
+}
+declare function resolveFeishuEndpointCredentials(credentialRef: string, env: RivusDaemonEnv): FeishuEndpointCredentials;
+//#endregion
+//#region src/adapters/openclaw/config/openclaw-env-import.d.ts
+type RivusEnvFileVariables = Readonly<Record<string, string>>;
+interface OpenClawEnvImportOptions {
+  readonly feishuBaseUrl?: string;
+  readonly piApiKeyFile?: string;
+  readonly streamMinIntervalMs?: number;
+}
+interface OpenClawEnvImportResult {
+  readonly env: RivusEnvFileVariables;
+  readonly warnings: ReadonlyArray<string>;
+}
+declare class OpenClawEnvImportError extends Error {
+  constructor(message: string);
+}
+declare function createRivusEnvFromOpenClawConfig(openClawConfig: unknown, options?: OpenClawEnvImportOptions): OpenClawEnvImportResult;
+declare function formatRivusEnvFile(env: RivusEnvFileVariables): string;
+//#endregion
+//#region src/adapters/compatibility/inbound-delivery/feishu-message-queue.d.ts
+interface FeishuMessageQueueOptions {
+  readonly clock?: {
+    readonly now: () => string;
+  };
+  /**
+   * Applies cancellation, session reset, or steering immediately after the
+   * message is durably admitted. Returning undefined leaves it on the prompt
+   * lane; returning a result completes the durable delivery.
+   */
+  readonly handleControl?: (payload: FeishuReceiveMessagePayload) => Effect.Effect<FeishuAgentDaemonHandleResult | undefined, unknown>;
+  readonly handleMessage: (payload: FeishuReceiveMessagePayload, options?: FeishuAgentDaemonHandleMessageOptions) => Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+  readonly shouldRetryError?: (error: unknown) => boolean;
+  readonly leaseMs?: number;
+  readonly maxAttempts?: number;
+  readonly maxPending?: number;
+  readonly prepareControl?: (payload: FeishuReceiveMessagePayload) => Effect.Effect<FeishuMessagePreparedControl | undefined, unknown>;
+  readonly repository?: FeishuInboxRepository;
+  readonly retryDelayMs?: number;
+  /**
+   * Identifies a delivery that belongs to a run which was interrupted before
+   * the process restarted. Such a delivery is completed as a duplicate rather
+   * than starting the same user prompt a second time.
+   */
+  readonly shouldSkipReplay?: (payload: FeishuReceiveMessagePayload) => Effect.Effect<boolean, unknown>;
+}
+type FeishuMessagePreparedControl = DurableQueuePreparedAction<FeishuAgentDaemonHandleResult>;
+type FeishuMessageDrainResult = {
+  readonly handled: true;
+  readonly messageId: string;
+  readonly result: FeishuAgentDaemonHandleResult;
+} | {
+  readonly handled: false;
+  readonly reason: "empty";
+};
+interface FeishuMessageQueue {
+  accept(payload: FeishuReceiveMessagePayload, options?: FeishuAgentDaemonHandleMessageOptions): Effect.Effect<FeishuMessageAcceptResult, unknown>;
+  drainOne(): Effect.Effect<FeishuMessageDrainResult, unknown>;
+  deadLetters(): ReadonlyArray<FeishuInboxDelivery>;
+  pending(): number;
+}
+declare function createFeishuMessageQueue(options: FeishuMessageQueueOptions): FeishuMessageQueue;
+//#endregion
+//#region src/adapters/feishu/intake/feishu-group-policy.d.ts
+type FeishuEndpointGroupPolicy = "mention-only" | "ignore-unmentioned" | "default-responder";
+declare function shouldAcceptFeishuEndpointMessage(payload: FeishuReceiveMessagePayload, policy: FeishuEndpointGroupPolicy, botOpenId: string): boolean;
+//#endregion
+//#region src/adapters/compatibility/inbound-delivery/feishu-message-worker.d.ts
+interface FeishuMessageWorkerQueue {
+  drainOne(): Effect.Effect<FeishuMessageDrainResult, unknown>;
+  pending(): number;
+}
+interface FeishuMessageWorker {
+  drainAvailable(): Effect.Effect<FeishuMessageWorkerDrainAvailableResult, unknown>;
+}
+interface FeishuMessageWorkerOptions {
+  readonly concurrency?: number;
+  readonly queue: FeishuMessageWorkerQueue;
+}
+declare function createFeishuMessageWorker(options: FeishuMessageWorkerOptions): FeishuMessageWorker;
+//#endregion
+//#region src/adapters/compatibility/inbound-delivery/feishu-worker-loop.d.ts
+interface FeishuWorkerLoopOptions {
+  readonly drainAvailable: () => Effect.Effect<unknown, unknown>;
+  readonly intervalMs: number;
+  readonly onError?: (error: unknown) => void | Promise<void>;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+type FeishuWorkerLoop = PeriodicEffectLoop;
+declare function createFeishuWorkerLoop(options: FeishuWorkerLoopOptions): FeishuWorkerLoop;
+//#endregion
+//#region src/platform/daemon/transport/rivus-daemon-transport.d.ts
+interface CompositeRivusDaemonTransportOptions {
+  readonly transports: ReadonlyArray<RivusDaemonTransport>;
+}
+declare function createCompositeRivusDaemonTransport(options: CompositeRivusDaemonTransportOptions): RivusDaemonTransport;
+//#endregion
+//#region src/core/application/card-presentation/projection/card-presentation.d.ts
+type CardPresentationStatus = "streaming" | "handoff-pending" | "active" | "closed" | "terminal";
+interface CardPresentation {
+  readonly runId: string;
+  readonly presentationId: string;
+  readonly generation: number;
+  readonly cardId: string;
+  readonly elementId?: string;
+  readonly sourceMessageId: string;
+  readonly status: CardPresentationStatus;
+  readonly createdAt: string;
+  readonly leaseDeadlineAt: string;
+  readonly handoffAt?: string;
+  readonly handoffFailedAt?: string;
+  readonly predecessorPresentationId?: string;
+  readonly successorPresentationId?: string;
+  readonly terminalReceiptId?: string;
+}
+interface CardPresentationChain {
+  readonly runId: string;
+  readonly activeGeneration: number;
+  readonly activePresentationId: string;
+  readonly presentations: ReadonlyArray<CardPresentation>;
+  readonly revision: number;
+}
+interface CardPresentationBinding {
+  readonly cardId: string;
+  readonly createdAt: string;
+  readonly elementId?: string;
+  readonly leaseDeadlineAt: string;
+  readonly presentationId: string;
+  readonly runId: string;
+  readonly sourceMessageId: string;
+}
+interface CardPresentationSuccessor {
+  readonly cardId: string;
+  readonly createdAt: string;
+  readonly elementId?: string;
+  readonly leaseDeadlineAt: string;
+  readonly presentationId: string;
+}
+declare class CardPresentationTransitionDenied extends Error {
+  readonly name = "CardPresentationTransitionDenied";
+}
+declare function activeCardPresentation(chain: CardPresentationChain): CardPresentation;
+declare function acceptsCardPresentationProgress(chain: CardPresentationChain): boolean;
+declare function isCardPresentationHandoffDue(chain: CardPresentationChain, now: string): boolean;
+//#endregion
+//#region src/adapters/feishu/card-presentation/feishu-card-presentation-store.d.ts
+interface FeishuCardPresentationHandoffStart {
+  readonly presentation: CardPresentation;
+  readonly started: boolean;
+}
+interface FeishuCardPresentationStore {
+  bind(binding: CardPresentationBinding): Effect.Effect<CardPresentation, unknown>;
+  beginHandoff(input: {
+    readonly handoffAt: string;
+    readonly runId: string;
+  }): Effect.Effect<FeishuCardPresentationHandoffStart, unknown>;
+  chain(runId: string): CardPresentationChain | undefined;
+  chains(): ReadonlyArray<CardPresentationChain>;
+  compensateInterruptedHandoffs(compensatedAt: string): Effect.Effect<ReadonlyArray<CardPresentationChain>, unknown>;
+  completeHandoff(input: {
+    readonly runId: string;
+    readonly successor: CardPresentationSuccessor;
+  }): Effect.Effect<CardPresentation, unknown>;
+  failHandoff(input: {
+    readonly failedAt: string;
+    readonly runId: string;
+  }): Effect.Effect<void, unknown>;
+  markTerminal(input: {
+    readonly runId: string;
+    readonly terminalReceiptId: string;
+  }): Effect.Effect<void, unknown>;
+  release(runId: string): Effect.Effect<void, unknown>;
+  size(): number;
+}
+//#endregion
+//#region src/core/application/card-presentation/projection/card-presentation-lease.d.ts
+declare const DEFAULT_CARD_STREAM_LEASE_MS = 510000;
+//#endregion
+//#region src/adapters/feishu/card-presentation/rollover/feishu-card-rollover.d.ts
+interface FeishuCardRolloverTarget {
+  readonly cardId: string;
+  readonly elementId?: string;
+}
+interface FeishuCardRolloverSuccessorRequest {
+  readonly generation: number;
+  readonly presentationId: string;
+  readonly run: FeishuAgentRunPreparation;
+}
+interface FeishuCardRolloverStreamPublisher {
+  flush(runId?: string): Effect.Effect<void, unknown>;
+  publish(action: FeishuStreamAction): Effect.Effect<void, unknown>;
+}
+type FeishuCardRolloverEventType = "handoff_started" | "handoff_succeeded" | "handoff_failed" | "handoff_notice_failed" | "presentation_write_failed" | "stale_update_dropped" | "stream_closed" | "terminal_delivery_failed";
+interface FeishuCardRolloverEvent {
+  readonly at?: string;
+  readonly cardId?: string;
+  readonly error?: unknown;
+  readonly generation?: number;
+  readonly presentationId?: string;
+  readonly runId?: string;
+  readonly sourceMessageId?: string;
+  readonly successorCardId?: string;
+  readonly type: FeishuCardRolloverEventType;
+}
+type FeishuCardRolloverCounters = Readonly<Record<FeishuCardRolloverEventType, number>>;
+interface FeishuCardRolloverStatus {
+  readonly counters: FeishuCardRolloverCounters;
+  readonly leaseMs: number;
+  readonly live: ReadonlyArray<CardPresentation>;
+}
+type FeishuCardRolloverHandoffResult = {
+  readonly presentation: CardPresentation;
+  readonly status: "rolled-over";
+} | {
+  readonly reason: "already-pending" | "not-due" | "not-live" | "not-streaming";
+  readonly status: "skipped";
+} | {
+  readonly error: unknown;
+  readonly status: "failed";
+};
+interface FeishuCardRolloverOptions {
+  readonly clock: AgentClock;
+  readonly createSuccessor: (request: FeishuCardRolloverSuccessorRequest) => Effect.Effect<FeishuCardRolloverTarget, unknown>;
+  readonly leaseMs?: number;
+  readonly observe?: (event: FeishuCardRolloverEvent) => void;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly publisher: FeishuCardRolloverStreamPublisher;
+  readonly store: FeishuCardPresentationStore;
+}
+interface FeishuCardRollover extends FeishuCardRolloverStreamPublisher {
+  bindRun(run: FeishuAgentRunPreparation, target: FeishuCardRolloverTarget): Effect.Effect<CardPresentation, unknown>;
+  dueRunIds(now: Date): ReadonlyArray<string>;
+  handoff(runId: string): Effect.Effect<FeishuCardRolloverHandoffResult, unknown>;
+  observeStreamClosed(cardId: string): void;
+  recover(): Effect.Effect<{
+    readonly compensated: number;
+  }, unknown>;
+  releaseRun(runId: string): Effect.Effect<void>;
+  status(): FeishuCardRolloverStatus;
+}
+declare function createFeishuCardRollover(options: FeishuCardRolloverOptions): FeishuCardRollover;
+//#endregion
+//#region src/adapters/compatibility/daemon/rivus-daemon-status.d.ts
+interface RivusDaemonStatus {
+  readonly agentId: string;
+  readonly cards?: FeishuCardRolloverStatus;
+  readonly harness: {
+    readonly activeRunId?: AgentRunId;
+    readonly activeRunState?: AgentRunState;
+    readonly activeSessionKey?: SessionKey;
+    readonly busy: boolean;
+  };
+  readonly history: AgentHistory;
+  readonly process: {
+    readonly running: boolean;
+  };
+  readonly queue: {
+    readonly pending: number;
+  };
+  readonly receive?: FeishuReceiveRuntimeStatus;
+  readonly transport: {
+    readonly running: boolean;
+  };
+  readonly workerLoop: {
+    readonly running: boolean;
+  };
+}
+interface RivusDaemonStatusReporter {
+  status(): Effect.Effect<RivusDaemonStatus, unknown>;
+}
+interface RivusDaemonStatusReporterOptions {
+  readonly activeRun?: () => ActiveAgentRun | undefined;
+  readonly cardPresentations?: () => FeishuCardRolloverStatus;
+  readonly activeRunId?: () => AgentRunId | undefined;
+  readonly activeRunState?: () => AgentRunState | undefined;
+  readonly agentId: string;
+  readonly availability?: () => AgentHarnessAvailability;
+  readonly pending: () => number;
+  readonly processRunning: () => boolean;
+  readonly receiveStatus?: () => FeishuReceiveRuntimeStatus;
+  readonly restoreHistory: () => Effect.Effect<AgentHistory, unknown>;
+  readonly transportRunning: () => boolean;
+  readonly workerLoopRunning: () => boolean;
+}
+declare function createRivusDaemonStatusReporter(options: RivusDaemonStatusReporterOptions): RivusDaemonStatusReporter;
+//#endregion
+//#region src/adapters/compatibility/daemon/rivus-daemon-status-http-server.d.ts
+interface RivusDaemonStatusHttpServerOptions {
+  readonly host?: string;
+  readonly path?: string;
+  readonly port: number;
+  readonly statusReporter: RivusDaemonStatusReporter;
+}
+interface RivusDaemonStatusHttpServer extends RivusDaemonTransport {
+  url(): string | undefined;
+}
+declare function createRivusDaemonStatusHttpServer(options: RivusDaemonStatusHttpServerOptions): RivusDaemonStatusHttpServer;
+//#endregion
+//#region src/adapters/feishu/protocol/feishu-card-protocol.d.ts
+/** Shared raw-card schema used by Feishu protocol adapters. */
+interface FeishuRawCardJson {
+  readonly body: {
+    readonly direction?: "horizontal" | "vertical";
+    readonly elements: ReadonlyArray<unknown>;
+    readonly padding?: string;
+    readonly vertical_spacing?: string;
+  };
+  readonly config: {
+    readonly streaming_mode?: boolean;
+    readonly update_multi: true;
+  };
+  readonly header: {
+    readonly padding?: string;
+    readonly template: "blue" | "green" | "grey" | "orange" | "red";
+    readonly title: {
+      readonly content: string;
+      readonly tag: "plain_text";
+    };
+  };
+  readonly schema: "2.0";
+}
+//#endregion
+//#region src/adapters/feishu/runtime/card-action-response.d.ts
+interface FeishuCardActionCallbackResponse {
+  readonly card?: {
+    readonly data: FeishuRawCardJson;
+    readonly type: "raw";
+  };
+  readonly toast: FeishuCardActionToast;
+}
+interface FeishuCardActionToast {
+  readonly type: "success" | "info" | "warning" | "error";
+  readonly content: string;
+  readonly i18n?: {
+    readonly en_us?: string;
+    readonly zh_cn?: string;
+  };
+}
+declare function createFeishuCardActionCallbackResponse(result: FeishuAgentDaemonHandleResult): FeishuCardActionCallbackResponse;
+declare function createFeishuCardActionErrorResponse(): FeishuCardActionCallbackResponse;
+//#endregion
+//#region src/adapters/feishu/runtime/event-handlers.d.ts
+interface FeishuEventHandlerQueue {
+  accept(payload: FeishuReceiveMessagePayload): Effect.Effect<FeishuMessageAcceptResult, unknown>;
+  pending?(): number;
+}
+interface FeishuEventHandlerCardActions {
+  handleCardAction(payload: FeishuCardActionTriggerPayload): Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+}
+interface FeishuEventHandlersOptions {
+  readonly cardActions?: FeishuEventHandlerCardActions;
+  readonly queue: FeishuEventHandlerQueue;
+}
+interface FeishuSdkReceiveMessagePayload {
+  readonly message: FeishuReceiveMessagePayload["event"]["message"];
+  readonly sender?: FeishuReceiveMessagePayload["event"]["sender"];
+  readonly tenant_key?: string;
+}
+type FeishuReceiveMessageHandlerPayload = FeishuReceiveMessagePayload | FeishuSdkReceiveMessagePayload;
+interface FeishuEventHandlers {
+  readonly "card.action.trigger"?: (payload: FeishuCardActionTriggerPayload) => Promise<FeishuCardActionCallbackResponse>;
+  readonly "im.message.receive_v1": (payload: FeishuReceiveMessageHandlerPayload) => Promise<FeishuMessageAcceptResult>;
+}
+declare function createFeishuEventHandlers(options: FeishuEventHandlersOptions): FeishuEventHandlers;
+//#endregion
+//#region src/adapters/feishu/runtime/feishu-receive-runtime.d.ts
+interface FeishuPeriodicFlushSupervisor {
+  withPeriodicFlush<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, unknown, R>;
+}
+//#endregion
+//#region src/bootstrap/feishu/agent-runtime.d.ts
+interface FeishuAgentRuntimeOptions {
+  readonly acknowledgeSteering?: (messageId: string) => Effect.Effect<void, unknown>;
+  readonly agentId: string;
+  readonly botOpenId?: string;
+  readonly clock: AgentClock;
+  readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+  readonly finalizeRun?: (runId: AgentRunId) => Effect.Effect<void>;
+  readonly inboxRepository?: FeishuInboxRepository;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly loop: LegacyAgentLoop;
+  readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly promptContext?: FeishuPromptContextResolver;
+  readonly periodicFlush?: FeishuPeriodicFlushSupervisor;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly reply?: (messageId: string, text: string) => Effect.Effect<void, unknown>;
+  readonly runTimeoutMs?: number;
+  readonly runIds: RunIdGenerator;
+  readonly sessionStore?: FeishuSessionStore;
+}
+interface FeishuAgentRuntime {
+  readonly handlers: FeishuEventHandlers;
+  readonly harness: AgentHarness;
+  readonly queue: FeishuMessageQueue;
+  readonly worker: FeishuMessageWorker;
+  drainAvailable(): Effect.Effect<FeishuMessageWorkerDrainAvailableResult, unknown>;
+  drainOne(): Effect.Effect<FeishuMessageDrainResult, unknown>;
+  pending(): number;
+  receiveStatus(): FeishuReceiveRuntimeStatus;
+  replayReceiveMessage(payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions): Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+declare function createFeishuAgentRuntime(options: FeishuAgentRuntimeOptions): FeishuAgentRuntime;
+//#endregion
+//#region src/platform/daemon/status/daemon-status-reporter.d.ts
+interface DaemonStatusSnapshot<History, RunState, CardStatus, ReceiveStatus> {
+  readonly agentId: string;
+  readonly cards?: CardStatus;
+  readonly harness: {
+    readonly activeRunId?: string;
+    readonly activeRunState?: RunState;
+    readonly activeSessionKey?: string;
+    readonly busy: boolean;
+  };
+  readonly history: History;
+  readonly process: {
+    readonly running: boolean;
+  };
+  readonly queue: {
+    readonly pending: number;
+  };
+  readonly receive?: ReceiveStatus;
+  readonly transport: {
+    readonly running: boolean;
+  };
+  readonly workerLoop: {
+    readonly running: boolean;
+  };
+}
+interface DaemonStatusReporter<History, RunState, CardStatus, ReceiveStatus> {
+  status(): Effect.Effect<DaemonStatusSnapshot<History, RunState, CardStatus, ReceiveStatus>, unknown>;
+}
+//#endregion
+//#region src/adapters/feishu/runtime/websocket-daemon.d.ts
+interface FeishuWebSocketClientStartOptions {
+  readonly eventDispatcher: unknown;
+}
+interface FeishuWebSocketClient {
+  connected?(): boolean;
+  start(options: FeishuWebSocketClientStartOptions): void | Promise<void>;
+  close?(): void | Promise<void>;
+  disconnect?(): void | Promise<void>;
+  stop?(): void | Promise<void>;
+}
+interface FeishuWebSocketEventDispatcher {
+  register(handlers: FeishuEventHandlers): unknown;
+}
+declare function createLazyFeishuWebSocketEventDispatcher(create: () => FeishuWebSocketEventDispatcher): FeishuWebSocketEventDispatcher;
+interface FeishuWebSocketRuntime {
+  readonly handlers: FeishuEventHandlers;
+  drainAvailable?(): unknown;
+}
+type FeishuWebSocketDaemonOptions = {
+  readonly client: FeishuWebSocketClient;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly handlers: FeishuEventHandlers;
+  readonly runtime?: never;
+} | {
+  readonly client: FeishuWebSocketClient;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly handlers?: never;
+  readonly runtime: FeishuWebSocketRuntime;
+};
+interface FeishuWebSocketDaemon {
+  running(): boolean;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+declare function createFeishuWebSocketDaemon(options: FeishuWebSocketDaemonOptions): FeishuWebSocketDaemon;
+//#endregion
+//#region src/adapters/feishu/card-presentation/delivery/feishu-cardkit-publisher.d.ts
+interface FeishuCardTarget {
+  readonly cardId: string;
+  readonly elementId: string;
+  readonly progressElementId?: string;
+}
+interface FeishuCardKitTextUpdate {
+  readonly cardId: string;
+  readonly elementId: string;
+  readonly content: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitPresentationUpdate {
+  readonly cardId: string;
+  readonly presentation?: RunPresentation;
+  readonly runId: AgentRunId;
+  readonly sequence: number;
+  readonly sessionKey: string;
+  readonly text?: string;
+}
+interface FeishuCardKitFinish {
+  readonly cardId: string;
+  readonly presentation?: RunPresentation;
+  readonly text: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitFail {
+  readonly cardId: string;
+  readonly errorMessage: string;
+  readonly presentation?: RunPresentation;
+  readonly sequence: number;
+}
+interface FeishuCardKitCancel {
+  readonly cardId: string;
+  readonly presentation?: RunPresentation;
+  readonly reason?: string;
+  readonly sequence: number;
+  readonly text?: string;
+}
+interface FeishuCardKitClient {
+  cancel(request: FeishuCardKitCancel): Effect.Effect<void, unknown>;
+  updatePresentation(request: FeishuCardKitPresentationUpdate): Effect.Effect<void, unknown>;
+  updateText(request: FeishuCardKitTextUpdate): Effect.Effect<void, unknown>;
+  finish(request: FeishuCardKitFinish): Effect.Effect<void, unknown>;
+  fail(request: FeishuCardKitFail): Effect.Effect<void, unknown>;
+}
+interface FeishuCardKitPublisherOptions {
+  readonly client: FeishuCardKitClient;
+  readonly ledger?: FeishuCardDeliveryLedger;
+  readonly resolveTarget: (runId: AgentRunId) => Effect.Effect<FeishuCardTarget, unknown>;
+}
+interface FeishuCardKitPublisher {
+  publish(action: FeishuStreamAction): Effect.Effect<void, unknown>;
+}
+declare function createFeishuCardKitPublisher(options: FeishuCardKitPublisherOptions): FeishuCardKitPublisher;
+//#endregion
+//#region src/adapters/feishu/card-presentation/target/feishu-card-target-registry.d.ts
+declare class FeishuCardTargetNotFound {
+  readonly runId: AgentRunId;
+  readonly _tag = "FeishuCardTargetNotFound";
+  constructor(runId: AgentRunId);
+}
+type FeishuCardTargetRegistryOperation = "load" | "save";
+declare class FeishuCardTargetRegistryStoreError {
+  readonly operation: FeishuCardTargetRegistryOperation;
+  readonly cause: unknown;
+  readonly _tag = "FeishuCardTargetRegistryStoreError";
+  constructor(operation: FeishuCardTargetRegistryOperation, cause: unknown);
+}
+interface FeishuCardTargetRegistry extends FeishuCardPresentationStore {
+  resolveTarget(runId: AgentRunId): Effect.Effect<FeishuCardTarget, unknown>;
+}
+interface JsonFileFeishuCardTargetRegistryOptions {
+  readonly filePath: string;
+}
+declare function createInMemoryFeishuCardTargetRegistry(initial?: ReadonlyArray<CardPresentationChain>): FeishuCardTargetRegistry;
+declare function createJsonFileFeishuCardTargetRegistry(options: JsonFileFeishuCardTargetRegistryOptions): FeishuCardTargetRegistry;
+//#endregion
+//#region src/adapters/feishu/card-presentation/rollover/feishu-card-rollover-supervisor.d.ts
+interface FeishuCardRolloverSupervisorOptions {
+  readonly clock: AgentClock;
+  readonly intervalMs?: number;
+  readonly onError?: (error: unknown) => void | Promise<void>;
+  readonly rollover: Pick<FeishuCardRollover, "dueRunIds" | "handoff" | "recover">;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+interface FeishuCardRolloverSupervisorTickResult {
+  readonly results: ReadonlyArray<FeishuCardRolloverHandoffResult>;
+}
+interface FeishuCardRolloverSupervisor {
+  recover(): Effect.Effect<void, unknown>;
+  running(): boolean;
+  start(): void;
+  stop(): Promise<void>;
+  tick(): Effect.Effect<FeishuCardRolloverSupervisorTickResult, unknown>;
+}
+declare function createFeishuCardRolloverSupervisor(options: FeishuCardRolloverSupervisorOptions): FeishuCardRolloverSupervisor;
+//#endregion
+//#region src/adapters/feishu/client/feishu-tenant-token-provider.d.ts
+interface FeishuTenantAccessTokenRequest {
+  readonly method: "POST";
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body: {
+    readonly app_id: string;
+    readonly app_secret: string;
+  };
+}
+interface FeishuTenantAccessTokenResponse {
+  readonly status: number;
+  readonly body: {
+    readonly code?: number;
+    readonly msg?: string;
+    readonly tenant_access_token?: string;
+    readonly expire?: number;
+  };
+}
+interface FeishuTenantAccessTokenProviderOptions {
+  readonly appId: string;
+  readonly appSecret: string;
+  readonly baseUrl?: string;
+  readonly refreshWindowMs?: number;
+  readonly now?: () => number;
+  readonly request: (request: FeishuTenantAccessTokenRequest) => Effect.Effect<FeishuTenantAccessTokenResponse, unknown>;
+}
+interface FeishuTenantAccessTokenProvider {
+  getTenantAccessToken(): Effect.Effect<string, unknown>;
+}
+declare class FeishuTenantAccessTokenError {
+  readonly status: number;
+  readonly code: number | undefined;
+  readonly message: string;
+  readonly _tag = "FeishuTenantAccessTokenError";
+  constructor(status: number, code: number | undefined, message: string);
+}
+declare function createFeishuTenantAccessTokenProvider(options: FeishuTenantAccessTokenProviderOptions): FeishuTenantAccessTokenProvider;
+//#endregion
+//#region src/adapters/feishu/client/feishu-openapi-client.d.ts
+interface FeishuOpenApiRequest {
+  readonly method: "GET" | "PATCH" | "POST" | "PUT";
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly body?: unknown;
+}
+interface FeishuOpenApiResponse {
+  readonly status: number;
+  readonly body: {
+    readonly code?: number;
+    readonly msg?: string;
+    readonly data?: unknown;
+  };
+}
+interface FeishuOpenApiClient {
+  request(request: Omit<FeishuOpenApiRequest, "headers">, errorMessage?: string): Effect.Effect<FeishuOpenApiResponse, unknown>;
+}
+type ConfiguredFeishuOpenApiRequest = FeishuOpenApiRequest | FeishuTenantAccessTokenRequest;
+type ConfiguredFeishuOpenApiResponse = FeishuOpenApiResponse | FeishuTenantAccessTokenResponse;
+declare class FeishuOpenApiError extends Error {
+  readonly status: number;
+  readonly code: number | undefined;
+  readonly _tag = "FeishuOpenApiError";
+  readonly name = "FeishuOpenApiError";
+  constructor(status: number, code: number | undefined, message: string);
+}
+declare function createFeishuOpenApiClient(options: {
+  readonly getTenantAccessToken: () => Effect.Effect<string, unknown>;
+  readonly request: (request: FeishuOpenApiRequest) => Effect.Effect<FeishuOpenApiResponse, unknown>;
+}): FeishuOpenApiClient;
+declare function createConfiguredFeishuOpenApiClient(options: {
+  readonly config: RivusDaemonConfig;
+  readonly request: (request: ConfiguredFeishuOpenApiRequest) => Effect.Effect<ConfiguredFeishuOpenApiResponse, unknown>;
+}): FeishuOpenApiClient;
+//#endregion
+//#region src/bootstrap/feishu/card-rollover-runtime.d.ts
+interface ConfiguredFeishuCardRolloverRuntimeOptions {
+  readonly agentName?: string;
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly cancelButton?: boolean;
+  readonly client: FeishuOpenApiClient;
+  readonly clock: AgentClock;
+  readonly config: RivusDaemonConfig;
+  readonly elementId?: string;
+  readonly initialContent?: string;
+  readonly flushIntervalMs?: number;
+  readonly ledger?: FeishuCardDeliveryLedger;
+  readonly observe?: (event: FeishuCardRolloverEvent) => void;
+  readonly onError?: (error: unknown) => void | Promise<void>;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+  readonly supervisorIntervalMs?: number;
+  readonly title?: string;
+}
+interface ConfiguredFeishuCardRolloverRuntime {
+  readonly rollover: FeishuCardRollover;
+  readonly supervisor: FeishuCardRolloverSupervisor;
+  readonly transport: RivusDaemonTransport;
+  prepareRun(run: FeishuAgentRunPreparation): Effect.Effect<void, unknown>;
+}
+declare function createConfiguredFeishuCardRolloverRuntime(options: ConfiguredFeishuCardRolloverRuntimeOptions): ConfiguredFeishuCardRolloverRuntime;
+//#endregion
+//#region src/bootstrap/feishu/rivus-daemon-bootstrap.d.ts
+type ConfiguredRivusDaemonBootstrapRequest = ConfiguredFeishuOpenApiRequest;
+type ConfiguredRivusDaemonBootstrapResponse = ConfiguredFeishuOpenApiResponse;
+type ConfiguredRivusDaemonStatus = DaemonStatusSnapshot<AgentHistory, AgentRunState, FeishuCardRolloverStatus, FeishuReceiveRuntimeStatus>;
+type ConfiguredRivusDaemonStatusReporter = DaemonStatusReporter<AgentHistory, AgentRunState, FeishuCardRolloverStatus, FeishuReceiveRuntimeStatus>;
+interface ConfiguredRivusDaemonBootstrapOptions {
+  readonly botOpenId?: string;
+  readonly cardLedger?: FeishuCardDeliveryLedger;
+  readonly cardRolloverIntervalMs?: number;
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly clock: AgentClock;
+  readonly config: RivusDaemonConfig;
+  readonly createStatusTransport?: (statusReporter: ConfiguredRivusDaemonStatusReporter) => RivusDaemonTransport;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly eventLog: AgentEventLog;
+  readonly flushIntervalMs?: number;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly inboxRepository?: FeishuInboxRepository;
+  readonly loop: LegacyAgentLoop;
+  readonly observeCardRollover?: (event: FeishuCardRolloverEvent) => void;
+  readonly onWorkerError?: (error: unknown) => void | Promise<void>;
+  readonly request: (request: ConfiguredRivusDaemonBootstrapRequest) => Effect.Effect<ConfiguredRivusDaemonBootstrapResponse, unknown>;
+  readonly runIds: RunIdGenerator;
+  readonly runTimeoutMs?: number;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+  readonly websocketClient: FeishuWebSocketClient;
+  readonly workerIntervalMs?: number;
+}
+interface ConfiguredRivusDaemonBootstrap {
+  readonly cardRollover: ConfiguredFeishuCardRolloverRuntime;
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly eventLog: AgentEventLog;
+  readonly process: RivusDaemonProcess;
+  readonly publisher: FeishuCardRollover;
+  readonly runtime: FeishuAgentRuntime;
+  readonly statusReporter: ConfiguredRivusDaemonStatusReporter;
+  readonly transport: RivusDaemonTransport;
+  readonly websocketTransport: FeishuWebSocketDaemon;
+  readonly workerLoop: FeishuWorkerLoop;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+  restoreHistory(): Effect.Effect<AgentHistory, unknown>;
+  status(): Effect.Effect<ConfiguredRivusDaemonStatus, unknown>;
+}
+declare function restoreConfiguredRivusDaemonBootstrap(options: ConfiguredRivusDaemonBootstrapOptions): Effect.Effect<ConfiguredRivusDaemonBootstrap, unknown>;
+declare function createConfiguredRivusDaemonBootstrap(options: ConfiguredRivusDaemonBootstrapOptions): ConfiguredRivusDaemonBootstrap;
+//#endregion
+//#region src/adapters/compatibility/run-presentation/run-presentation-projector.d.ts
+interface RunPresentationProjector {
+  apply(event: AgentDomainEvent, canonicalText?: string): RunPresentation | undefined;
+  snapshot(runId: AgentRunId): RunPresentation | undefined;
+}
+declare function createRunPresentationProjector(): RunPresentationProjector;
+//#endregion
+//#region src/adapters/compatibility/card-presentation/feishu-card-presentation-store.d.ts
+declare class FeishuCardPresentationNotFound {
+  readonly runId: string;
+  readonly _tag = "FeishuCardPresentationNotFound";
+  constructor(runId: string);
+}
+interface FeishuCardPresentationStoreOptions {
+  readonly initial?: ReadonlyArray<CardPresentationChain>;
+  readonly persist?: (chains: ReadonlyArray<CardPresentationChain>) => Promise<void>;
+}
+declare function createFeishuCardPresentationStore(options?: FeishuCardPresentationStoreOptions): FeishuCardPresentationStore;
+//#endregion
+//#region src/adapters/feishu/card-presentation/delivery/feishu-cardkit-openapi-client.d.ts
+interface FeishuCardKitOpenApiClientOptions {
+  readonly agentName?: string;
+  readonly baseUrl?: string;
+  readonly cancelButton?: boolean;
+  readonly client: FeishuOpenApiClient;
+  readonly onStreamingClosed?: (cardId: string) => void;
+  readonly progressDisplay?: ConversationProgressDisplay;
+}
+declare function createFeishuCardKitOpenApiClient(options: FeishuCardKitOpenApiClientOptions): FeishuCardKitClient;
+//#endregion
+//#region src/adapters/feishu/intake/feishu-topic-context-resolver.d.ts
+interface FeishuTopicContextResolverOptions {
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+}
+declare class InvalidFeishuTopicContext extends Error {
+  readonly name = "InvalidFeishuTopicContext";
+}
+declare function createFeishuTopicContextResolver(options: FeishuTopicContextResolverOptions): FeishuPromptContextResolver;
+//#endregion
+//#region src/adapters/feishu/delivery/cot/feishu-cot-publisher.d.ts
+type FeishuCotRunPreparation = FeishuAgentRunPreparation;
+interface FeishuCotPublisher {
+  fail(runId: string): Effect.Effect<void, unknown>;
+  prepare(run: FeishuCotRunPreparation): Effect.Effect<void, unknown>;
+  publish(update: AgentRunUpdate): Effect.Effect<void, unknown>;
+}
+interface FeishuCotPublisherOptions {
+  readonly baseUrl: string;
+  readonly client: FeishuOpenApiClient;
+  readonly minIntervalMs: number;
+  readonly now?: () => number;
+}
+declare class FeishuCotProtocolError extends Error {
+  readonly name = "FeishuCotProtocolError";
+}
+declare function createFeishuCotPublisher(options: FeishuCotPublisherOptions): FeishuCotPublisher;
+//#endregion
+//#region src/adapters/feishu/card-presentation/target/feishu-cardkit-target-preparation.d.ts
+interface FeishuCardTargetCreateOptions {
+  readonly generation?: number;
+  readonly initialContent?: string;
+  readonly initialPresentation?: RunPresentation;
+}
+interface FeishuCardTargetCreator {
+  createTarget(run: FeishuAgentRunPreparation, options?: FeishuCardTargetCreateOptions): Effect.Effect<FeishuCardTarget, unknown>;
+}
+interface FeishuCardPresentationBinder {
+  bindRun(run: FeishuAgentRunPreparation, target: FeishuCardTarget): Effect.Effect<unknown, unknown>;
+}
+interface FeishuCardTargetPreparationOptions {
+  readonly createTarget: (run: FeishuAgentRunPreparation) => Effect.Effect<FeishuCardTarget, unknown>;
+  readonly presentations: FeishuCardPresentationBinder;
+}
+interface FeishuCardKitOpenApiTargetCreatorOptions {
+  readonly baseUrl?: string;
+  readonly cancelButton?: boolean;
+  readonly client: FeishuOpenApiClient;
+  readonly elementId: string;
+  readonly initialContent?: string;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly title?: string;
+}
+interface ConfiguredFeishuCardKitTargetCreatorOptions {
+  readonly cancelButton?: boolean;
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+  readonly elementId?: string;
+  readonly initialContent?: string;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly title?: string;
+}
+declare function createFeishuCardTargetPreparation(options: FeishuCardTargetPreparationOptions): (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+declare function createConfiguredFeishuCardKitTargetCreator(options: ConfiguredFeishuCardKitTargetCreatorOptions): FeishuCardTargetCreator;
+declare function createFeishuCardKitOpenApiTargetCreator(options: FeishuCardKitOpenApiTargetCreatorOptions): FeishuCardTargetCreator;
+//#endregion
+//#region src/adapters/feishu/card-presentation/streaming/feishu-rate-limited-publisher.d.ts
+interface FeishuStreamActionPublisher {
+  publish(action: FeishuStreamAction): Effect.Effect<void, unknown>;
+}
+interface RateLimitedFeishuPublisherOptions {
+  readonly publisher: FeishuStreamActionPublisher;
+  readonly minIntervalMs: number;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+declare function createRateLimitedFeishuPublisher(options: RateLimitedFeishuPublisherOptions): FeishuStreamActionPublisher;
+//#endregion
+//#region src/adapters/feishu/card-presentation/streaming/feishu-coalescing-publisher.d.ts
+interface FeishuCoalescingPublisher extends FeishuStreamActionPublisher {
+  flush(runId?: AgentRunId): Effect.Effect<void, unknown>;
+}
+interface FeishuCoalescingPublisherOptions {
+  readonly publisher: FeishuStreamActionPublisher;
+}
+declare function createCoalescingFeishuPublisher(options: FeishuCoalescingPublisherOptions): FeishuCoalescingPublisher;
+//#endregion
+//#region src/adapters/feishu/card-presentation/delivery/feishu-configured-cardkit-publisher.d.ts
+interface ConfiguredFeishuCardKitPublisherOptions {
+  readonly agentName?: string;
+  readonly cancelButton?: boolean;
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+  readonly ledger?: FeishuCardDeliveryLedger;
+  readonly onStreamingClosed?: (cardId: string) => void;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly resolveTarget: (runId: AgentRunId) => Effect.Effect<FeishuCardTarget, unknown>;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+declare function createConfiguredFeishuCardKitPublisher(options: ConfiguredFeishuCardKitPublisherOptions): FeishuCoalescingPublisher;
+//#endregion
+//#region src/adapters/feishu/delivery/cot/feishu-periodic-flush.d.ts
+interface FeishuPeriodicFlushOptions {
+  readonly flush: () => Effect.Effect<void, unknown>;
+  readonly intervalMs: number;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+interface FeishuPeriodicFlush {
+  withPeriodicFlush<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, unknown, R>;
+}
+declare function createFeishuPeriodicFlush(options: FeishuPeriodicFlushOptions): FeishuPeriodicFlush;
+//#endregion
+//#region src/adapters/compatibility/project-space/workspace-instructions.d.ts
+interface WorkspaceInstructionsProvider {
+  resolve(request: WorkspaceInstructionsRequest): Promise<WorkspaceInstructionsView>;
+}
+declare function createAgentsMdInstructionsProvider(): WorkspaceInstructionsProvider;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/tool-broker.d.ts
+interface AuthorizationPolicyState$1 extends AuthorizationPolicyState {}
+interface ToolApprovalRequest$1 extends ToolApprovalRequest {
+  readonly risk: RivusToolRisk;
+}
+interface AuthorizationPolicyProvider {
+  current(): Promise<AuthorizationPolicyState$1>;
+}
+interface ToolApprovalService {
+  consume(request: ToolApprovalRequest$1): Promise<boolean>;
+}
+interface ToolBrokerOptions {
+  readonly approvals: ToolApprovalService;
+  readonly catalog: RivusPluginCatalog;
+  readonly hostTools?: ReadonlyArray<RivusHostToolDescriptor>;
+  readonly policy: AuthorizationPolicyProvider;
+  readonly operations?: ToolOperationLedger$1;
+}
+interface ToolExecutionRequest$1 extends ToolExecutionRequest {
+  readonly authority: InvocationAuthorityRef$1;
+}
+interface ToolBroker {
+  execute(request: ToolExecutionRequest$1): Promise<unknown>;
+}
+declare function createToolBroker$1(options: ToolBrokerOptions): ToolBroker;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/jsonl-tool-operation-ledger.d.ts
+declare function openJsonlToolOperationLedger$1(options: {
+  readonly filePath: string;
+}): Promise<ToolOperationLedger$1>;
+//#endregion
+//#region src/adapters/compatibility/recovery/jsonl-recovery-control.d.ts
+interface JsonlRecoveryControlOptions {
+  readonly clock?: {
+    readonly now: () => string;
+  };
+  readonly endpointsDirectory: string;
+  readonly instancesDirectory: string;
+}
+declare function openJsonlRecoveryControl(options: JsonlRecoveryControlOptions): Promise<RecoveryControl>;
+//#endregion
+//#region src/adapters/compatibility/agent-host/runtime/agent-harness-pooled-runtime.d.ts
+declare function createAgentHarnessPooledRuntime(harness: AgentHarness): PooledAgentRuntime;
+//#endregion
+//#region src/bootstrap/feishu/deployment-endpoint.d.ts
+interface FeishuDeploymentEndpointOptions extends Pick<CreateProcessDeploymentEndpointInput, "agentId" | "cancel" | "handle" | "steer"> {
+  readonly acknowledgeSteering?: (messageId: string) => Effect.Effect<void, unknown>;
+  readonly botOpenId: string;
+  readonly cardRollover?: RivusDaemonTransport;
+  readonly endpointId?: string;
+  readonly finalizeRun?: (runId: string) => Effect.Effect<void>;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly groupPolicy: FeishuEndpointGroupPolicy;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly interactions?: FeishuHumanInteractionActions;
+  readonly inboxRepository?: FeishuInboxRepository;
+  readonly maxPendingMessages?: number;
+  readonly memoryTenantId?: string;
+  readonly projectSpaceId?: string;
+  readonly onWorkerError?: (error: unknown) => void | Promise<void>;
+  readonly onCapacityExceeded?: (payload: FeishuReceiveMessagePayload) => Effect.Effect<void, unknown>;
+  readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly promptContext: FeishuPromptContextResolver;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly publishRunUpdate?: AgentRunUpdateHandler;
+  readonly reply?: (messageId: string, text: string) => Effect.Effect<void, unknown>;
+  readonly sessionStore?: FeishuSessionStore;
+  readonly sessionNamespace: string;
+  readonly shutdownTimeoutMs?: number;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+  readonly websocketClient: FeishuWebSocketClient;
+  readonly workerIntervalMs?: number;
+  readonly workerConcurrency?: number;
+}
+declare function createFeishuDeploymentEndpoint(options: FeishuDeploymentEndpointOptions): ProcessDeploymentEndpoint;
+//#endregion
+//#region src/adapters/feishu/run-presentation/feishu-presentation-preparation.d.ts
+interface FeishuPresentationPreparationOptions {
+  readonly cotPublisher?: Pick<FeishuCotPublisher, "fail" | "prepare">;
+  readonly prepareCardTarget: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly reportCotError: (operation: "abort" | "create", error: unknown) => Effect.Effect<void>;
+}
+declare function createFeishuPresentationPreparation(options: FeishuPresentationPreparationOptions): (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+//#endregion
+//#region src/adapters/compatibility/memory/service/agent-memory-service.d.ts
+interface AgentMemoryServiceOptions {
+  readonly ids?: {
+    readonly next: () => string;
+  };
+  readonly initial?: ReadonlyArray<LegacyAgentMemorySnapshot>;
+  readonly persist?: (snapshot: LegacyAgentMemorySnapshot) => Promise<void>;
+}
+declare function createAgentMemoryService(options?: AgentMemoryServiceOptions): LegacyAgentMemoryService;
+//#endregion
+//#region src/adapters/compatibility/background-session/transitions.d.ts
+type BackgroundSessionState = BackgroundSessionSnapshot;
+declare function isBackgroundSessionTerminalPhase(phase: BackgroundSessionPhase): boolean;
+declare class BackgroundSessionTransitionDenied extends Error {
+  readonly sessionId: BackgroundSessionId;
+  readonly name = "BackgroundSessionTransitionDenied";
+  constructor(sessionId: BackgroundSessionId, message: string);
+}
+declare function createBackgroundSession(input: Parameters<typeof createBackgroundSession$1>[0]): BackgroundSessionState;
+declare function claimBackgroundSession(state: BackgroundSessionState, input: ClaimBackgroundSessionInput): BackgroundSessionState;
+declare function renewBackgroundSessionLease(state: BackgroundSessionState, lease: BackgroundSessionLease): BackgroundSessionState;
+declare function releaseBackgroundSessionLease(state: BackgroundSessionState): BackgroundSessionState;
+declare function suspendBackgroundSession(state: BackgroundSessionState, input: SuspendBackgroundSessionInput): BackgroundSessionState;
+declare function completeBackgroundSessionStep(state: BackgroundSessionState, input: {
+  readonly text: string;
+  readonly stepRunId: string;
+  readonly now: string;
+}): BackgroundSessionState;
+declare function failBackgroundSessionStep(state: BackgroundSessionState, input: {
+  readonly errorMessage: string;
+  readonly now: string;
+  readonly retryable: boolean;
+  readonly wakeAt?: string;
+}): BackgroundSessionState;
+declare function requestBackgroundSessionStop(state: BackgroundSessionState, input: {
+  readonly reason: string;
+  readonly now: string;
+}): BackgroundSessionState;
+declare function completeBackgroundSessionStop(state: BackgroundSessionState, input: {
+  readonly now: string;
+}): BackgroundSessionState;
+declare function parkBackgroundSessionForReconciliation(state: BackgroundSessionState, input: {
+  readonly reason: string;
+  readonly now: string;
+}): BackgroundSessionState;
+declare function resolveBackgroundSessionReconciliation(state: BackgroundSessionState, input: {
+  readonly outcome: "continue" | "stop";
+  readonly now: string;
+}): BackgroundSessionState;
+declare function appendBackgroundSessionInput(state: BackgroundSessionState, input: {
+  readonly message: string;
+  readonly now: string;
+}): BackgroundSessionState;
+declare function requeueInterruptedBackgroundSessionStep(state: BackgroundSessionState, input: {
+  readonly wakeText: string;
+  readonly now: string;
+}): BackgroundSessionState;
+declare function isBackgroundSessionDue(state: BackgroundSessionState, now: string): boolean;
+declare function isBackgroundSessionLeaseExpired(state: BackgroundSessionState, now: string): boolean;
+//#endregion
+//#region src/adapters/compatibility/background-session/repository.d.ts
+interface BackgroundSessionRepository {
+  create(state: BackgroundSessionState): Promise<BackgroundSessionState>;
+  get(sessionId: string): Promise<BackgroundSessionState | undefined>;
+  list(options?: {
+    readonly phase?: BackgroundSessionPhase;
+    readonly limit?: number;
+  }): Promise<ReadonlyArray<BackgroundSessionState>>;
+  update(input: {
+    readonly sessionId: string;
+    readonly expectedRevision: number;
+    readonly expectedLease?: BackgroundSessionLeasePrecondition | BackgroundSessionLeaseRequirement | BackgroundSessionLeaseStaleOrAbsent;
+    readonly now?: string;
+    readonly build: (state: BackgroundSessionState) => BackgroundSessionState;
+  }): Promise<BackgroundSessionState | undefined>;
+}
+//#endregion
+//#region src/adapters/compatibility/background-session/service.d.ts
+interface BackgroundSessionServiceOptions {
+  readonly clock: {
+    now(): string;
+  };
+  readonly deliveries: BackgroundSessionDeliveryStore;
+  readonly repository: BackgroundSessionRepository;
+}
+declare function createBackgroundSessionService(options: BackgroundSessionServiceOptions): BackgroundSessionService;
+//#endregion
+//#region src/adapters/outbound/persistence/background-session/session/jsonl-background-session-repository.d.ts
+declare const BACKGROUND_SESSION_JSONL_VERSION = 1;
+interface OpenJsonlBackgroundSessionRepositoryOptions {
+  readonly filePath: string;
+  readonly compactThreshold?: number;
+}
+declare function isBackgroundSessionState(value: unknown): value is BackgroundSessionSnapshot;
+//#endregion
+//#region src/adapters/outbound/persistence/background-session/delivery/in-memory-background-session-delivery-store.d.ts
+interface CreateBackgroundSessionDeliveryStoreOptions {
+  readonly initial?: ReadonlyArray<BackgroundSessionDeliveryRecord>;
+  readonly persist?: (record: BackgroundSessionDeliveryRecord) => Promise<void>;
+}
+declare function createBackgroundSessionDeliveryStore(options?: CreateBackgroundSessionDeliveryStoreOptions): BackgroundSessionDeliveryStore;
+//#endregion
+//#region src/adapters/outbound/persistence/background-session/delivery/jsonl-background-session-delivery-store.d.ts
+declare const BACKGROUND_SESSION_DELIVERY_JSONL_VERSION = 1;
+interface OpenJsonlBackgroundSessionDeliveryStoreOptions {
+  readonly filePath: string;
+  readonly compactThreshold?: number;
+}
+declare function openJsonlBackgroundSessionDeliveryStore(options: OpenJsonlBackgroundSessionDeliveryStoreOptions): Promise<BackgroundSessionDeliveryStore>;
+//#endregion
+//#region src/adapters/compatibility/background-session/persistence.d.ts
+interface CreateBackgroundSessionRepositoryOptions {
+  readonly initial?: ReadonlyArray<BackgroundSessionState>;
+  readonly persist?: (state: BackgroundSessionState) => Promise<void>;
+}
+declare function createBackgroundSessionRepository(options?: CreateBackgroundSessionRepositoryOptions): BackgroundSessionRepository;
+declare function openJsonlBackgroundSessionRepository(options: OpenJsonlBackgroundSessionRepositoryOptions): Promise<BackgroundSessionRepository>;
+//#endregion
+//#region src/adapters/compatibility/background-session/runtime.d.ts
+interface BackgroundSessionSupervisorOptions extends Pick<BackgroundSessionSupervisorOptions$1, "clock" | "config" | "deliver" | "deliveries" | "onError" | "sleep"> {
+  readonly repository: BackgroundSessionRepository;
+  readonly runStep: (input: {
+    readonly session: BackgroundSessionState;
+    readonly signal: AbortSignal;
+    readonly wakeText: string;
+  }) => Promise<{
+    readonly finalText: string;
+    readonly runId: string;
+  }>;
+}
+declare function createBackgroundSessionSupervisor(options: BackgroundSessionSupervisorOptions): BackgroundSessionSupervisor;
+//#endregion
+//#region src/adapters/compatibility/background-session/authority.d.ts
+declare function extendBackgroundSessionDefinition<T extends BackgroundSessionAgentDefinition>(definition: T): TransformedBackgroundSessionDefinition<T>;
+declare function narrowBackgroundSessionDefinition<T extends BackgroundSessionAgentDefinition>(definition: T): TransformedBackgroundSessionDefinition<T>;
+//#endregion
+//#region src/core/application/background-session/supervision/background-session-config.d.ts
+declare const DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS: number;
+declare const DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS = 4;
+declare const DEFAULT_BACKGROUND_SESSION_LEASE_MS = 30000;
+declare const DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS = 10000;
+declare const DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES = 3;
+declare const DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS = 30000;
+declare const DEFAULT_BACKGROUND_SESSION_LIFETIME_MS: number;
+declare const DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS = 1000;
+declare function resolveBackgroundSessionSupervisorIntervalMs(leaseMs: number): number;
+//#endregion
+//#region src/adapters/feishu/background-session/background-session-delivery.d.ts
+type FeishuBackgroundSessionDeliveryKind = "progress" | "final" | "stopped" | "failed" | "reconciliation";
+interface FeishuBackgroundSessionDeliveryInput {
+  readonly chatId: string;
+  readonly deliveryId: string;
+  readonly displayName: string;
+  readonly kind: FeishuBackgroundSessionDeliveryKind;
+  readonly sessionId: string;
+  readonly text: string;
+}
+interface FeishuBackgroundSessionDelivery {
+  deliver(input: FeishuBackgroundSessionDeliveryInput): Promise<{
+    readonly providerMessageId: string;
+  }>;
+}
+/**
+ * Background sessions keep the transport-authenticated Feishu conversation id
+ * (`feishu:<tenant>:<chat>:<thread>`) as their stable origin. Feishu's send
+ * API, however, accepts only the raw chat id. Keep the translation at the
+ * Feishu adapter boundary and retain support for older sessions that stored a
+ * raw chat id directly.
+ */
+declare function resolveFeishuDeliveryChatId(conversationId: string): string;
+declare function createConfiguredFeishuBackgroundSessionDelivery(options: {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}): FeishuBackgroundSessionDelivery;
+declare function createBackgroundSessionCard(input: {
+  readonly displayName: string;
+  readonly kind: FeishuBackgroundSessionDeliveryKind;
+  readonly sessionId: string;
+  readonly text: string;
+}): FeishuRawCardJson;
+//#endregion
+//#region src/core/application/deployment/manifest/deployment-manifest.d.ts
+declare class InvalidRivusProjectSpace extends Error {
+  readonly name = "InvalidRivusProjectSpace";
+}
+declare function validateRivusDeploymentManifest(manifest: RivusDeploymentManifest): void;
+//#endregion
+//#region src/adapters/deployment/project-space/node-project-space-resolver.d.ts
+declare function resolveRivusProjectSpace(input: {
+  readonly declaration: RivusProjectSpaceDeployment;
+  readonly deploymentRoot: string;
+}): Promise<ResolvedRivusProjectSpace>;
+//#endregion
+//#region src/adapters/compatibility/memory/service/jsonl-agent-memory-service.d.ts
+declare function openJsonlAgentMemoryService(options: {
+  readonly filePath: string;
+}): Promise<AgentMemoryService>;
+//#endregion
+//#region src/adapters/compatibility/automation/automation-mandate-store.d.ts
+declare function createAutomationMandateStore(): AutomationMandateStore;
+//#endregion
+//#region src/adapters/compatibility/automation/automation-tick-record.d.ts
+type AutomationTickStatus = "running" | "failed" | "generated" | "suppressed" | "delivered";
+interface AutomationTickRecord {
+  readonly automationId: string;
+  readonly body?: string;
+  readonly error?: string;
+  readonly occurrence: string;
+  readonly mandateId: string;
+  readonly providerMessageId?: string;
+  readonly presentation?: AutomationPresentation;
+  readonly revision: number;
+  readonly runId?: string;
+  readonly suppressionReason?: string;
+  readonly status: AutomationTickStatus;
+  readonly tickId: string;
+}
+//#endregion
+//#region src/adapters/compatibility/automation/scheduled-automation.d.ts
+interface ScheduledAutomationClock {
+  now(): Date;
+  sleep(milliseconds: number, signal: AbortSignal): Promise<void>;
+}
+interface ScheduledAutomationOptions {
+  readonly automationId: string;
+  readonly binding: AutomationBinding;
+  readonly clock?: ScheduledAutomationClock;
+  readonly createInput: (tick: {
+    readonly occurrence: string;
+  }) => {
+    readonly text: string;
+  };
+  readonly deliver: (input: ScheduledAutomationDeliveryInput) => Promise<{
+    readonly providerMessageId: string;
+  }>;
+  readonly repository: AutomationTickRepositoryCompatibility;
+  readonly onError?: (error: unknown) => Promise<void> | void;
+  readonly retryDelayMs?: number;
+  readonly run: (input: ScheduledAutomationRunInput) => Promise<ScheduledAutomationRunResult>;
+}
+interface AutomationTickRepositoryCompatibility {
+  get(automationId: string, occurrence: string): Promise<AutomationTickRecord | undefined>;
+  put(record: AutomationTickRecord): Promise<AutomationTickRecord>;
+}
+interface ScheduledAutomation {
+  running(): boolean;
+  runDue(at: Date): Promise<AutomationTickRecord | undefined>;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+}
+declare function createScheduledAutomation(options: ScheduledAutomationOptions): ScheduledAutomation;
+//#endregion
+//#region src/core/application/automation/policy/daily-automation-schedule.d.ts
+interface DailyAutomationSchedule {
+  currentOccurrence(now: Date): string | undefined;
+  nextOccurrence(now: Date): Date;
+}
+declare function createDailyAutomationSchedule(expression: string, timeZone: string, now?: Date): DailyAutomationSchedule;
+//#endregion
+//#region src/adapters/compatibility/automation/json-automation-tick-repository.d.ts
+interface OpenJsonAutomationTickRepositoryOptions {
+  readonly filePath: string;
+}
+declare function openJsonAutomationTickRepository(options: OpenJsonAutomationTickRepositoryOptions): Promise<AutomationTickRepositoryCompatibility>;
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/plugin-state-store.d.ts
+interface PluginStateStore {
+  get(pluginId: string, agentId: string, key: string): PluginStateRecord | undefined;
+  put(input: PutPluginState): PluginStateRecord;
+}
+declare class PluginStateConflict extends Error {
+  readonly name = "PluginStateConflict";
+}
+declare function createPluginStateStore(): PluginStateStore;
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/delivery-outbox.d.ts
+interface DeliveryOutbox {
+  enqueue(job: Omit<DeliveryJob, "status">): DeliveryJob;
+  recordAttempt(id: string, result: DeliveryAttemptResult): DeliveryJob;
+  snapshot(): ReadonlyArray<DeliveryJob>;
+}
+declare class DeliveryOutboxError extends Error {
+  readonly name = "DeliveryOutboxError";
+}
+declare function createDeliveryOutbox(): DeliveryOutbox;
+//#endregion
+//#region src/core/application/delegation/contracts/delegation.d.ts
+interface DelegationEdge {
+  readonly fromAgentId: string;
+  readonly toAgentId: string;
+  readonly toolIds: ReadonlyArray<string>;
+  readonly maxHops: number;
+  readonly maxBudget: number;
+}
+interface DelegationRequest {
+  readonly callerAuthority: InvocationAuthorityRef;
+  readonly targetAgentId: string;
+  readonly targetInstanceId: string;
+  readonly targetToolGrantSet: RivusToolGrantSet;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly hopCount: number;
+  readonly budget: number;
+}
+interface DelegationGrant {
+  readonly id: string;
+  readonly request: DelegationRequest;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly authority: InvocationAuthorityRef;
+}
+//#endregion
+//#region src/core/application/delegation/grant/delegation-service.d.ts
+declare class DelegationDenied extends Error {
+  readonly name = "DelegationDenied";
+}
+//#endregion
+//#region src/adapters/compatibility/delegation/delegation-service.d.ts
+interface DelegationService {
+  delegate(request: DelegationRequest): DelegationGrant;
+}
+declare function createDelegationService(options: {
+  readonly edges: ReadonlyArray<DelegationEdge>;
+}): DelegationService;
+declare function intersectToolIds(sets: ReadonlyArray<ReadonlyArray<string>>): RivusToolGrantSet;
+//#endregion
+//#region src/core/application/delegation/contracts/subagent.d.ts
+interface SpawnSubagentRequest {
+  readonly parentAuthority: InvocationAuthorityRef;
+  readonly childAgentId: string;
+  readonly childProfileToolIds: ReadonlyArray<string>;
+  readonly childDeploymentToolIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+}
+interface SubagentCapabilities {
+  readonly senderIdentity: false;
+  readonly privateMemory: false;
+  readonly shell: false;
+}
+interface SubagentRecord {
+  readonly id: string;
+  readonly parentRunId: string;
+  readonly childAgentId: string;
+  readonly status: "active" | "cancelled";
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly authority: InvocationAuthorityRef;
+  readonly capabilities: SubagentCapabilities;
+}
+//#endregion
+//#region src/adapters/compatibility/delegation/subagent-coordinator.d.ts
+interface SubagentCoordinator {
+  spawn(request: SpawnSubagentRequest): SubagentRecord;
+  cancelParent(parentRunId: string): void;
+  get(id: string): SubagentRecord | undefined;
+}
+declare function createSubagentCoordinator(): SubagentCoordinator;
+//#endregion
+//#region src/core/application/deployment/resolution/deployment-resolution.d.ts
+declare class RivusPluginLoadError extends Error {
+  readonly pluginId: string;
+  readonly moduleSpecifier: string;
+  readonly name = "RivusPluginLoadError";
+  constructor(pluginId: string, moduleSpecifier: string, message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/rivus-plugin-loader.d.ts
+type RivusPluginModule = RivusPlugin | {
+  readonly default: RivusPlugin | (() => RivusPlugin | Promise<RivusPlugin>);
+};
+interface LoadRivusDeploymentOptions {
+  readonly deploymentRoot: string;
+  readonly manifest: RivusDeploymentManifest;
+  readonly loadModule: (request: RivusPluginModuleLoadRequest) => Promise<RivusPluginModule> | RivusPluginModule;
+}
+declare function loadRivusDeployment(options: LoadRivusDeploymentOptions): Promise<LoadedRivusDeployment>;
+//#endregion
+//#region src/adapters/deployment/plugin/node-rivus-plugin-module-loader.d.ts
+interface NodeRivusPluginModuleLoaderOptions {
+  readonly packageManifestPath?: string;
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/node-rivus-plugin-module-loader.d.ts
+declare function loadNodeRivusPluginModule(request: RivusPluginModuleLoadRequest, options?: NodeRivusPluginModuleLoaderOptions): Promise<RivusPluginModule>;
+//#endregion
+//#region src/adapters/compatibility/deployment-control/rivus-deployment-daemon.d.ts
+interface RivusDeploymentEndpoint {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface RivusDeploymentAutomation {
+  running(): boolean;
+  start(): Promise<void> | void;
+  stop(): Promise<void> | void;
+}
+interface RivusDeploymentBackgroundSession {
+  running(): boolean;
+  start(): Promise<void> | void;
+  status?(): BackgroundSessionSupervisorStatus;
+  stop(): Promise<void> | void;
+}
+interface CreateRivusDeploymentAutomationInput {
+  readonly automationId: string;
+  readonly definition: ResolvedRivusAutomationDefinition;
+  readonly deliveryEndpoint: RivusEndpointDeployment;
+  readonly instanceId: string;
+  readonly run: (input: ScheduledAutomationRunInput) => Promise<unknown>;
+}
+interface CreateRivusDeploymentEndpointInput {
+  readonly agentId: string;
+  readonly cancel: (input: AgentRuntimeCancellation) => Promise<boolean>;
+  readonly endpointId: string;
+  readonly definition: RivusEndpointDeployment;
+  readonly handle: (input: RivusEndpointInput) => Promise<unknown>;
+  readonly steer?: (input: AgentRuntimeSteering) => Promise<boolean>;
+  readonly instanceId: string;
+  readonly projectSpaceId?: string;
+}
+interface CreateRivusDeploymentBackgroundSessionInput {
+  readonly agentIds: ReadonlyArray<string>;
+  readonly config: RivusBackgroundSessionsDeployment;
+  readonly cancel: (input: {
+    readonly agentId: string;
+    readonly reason?: string;
+    readonly runId: string;
+    readonly sessionKey: SessionKey;
+  }) => Promise<boolean>;
+  readonly run: (input: {
+    readonly agentId: string;
+    readonly invocation: AgentInvocationOrigin;
+    readonly onUpdate?: (update: AgentRunUpdate) => void | Promise<void>;
+    readonly sessionKey: SessionKey;
+    readonly text: string;
+  }) => Promise<unknown>;
+}
+interface CreateRivusDeploymentRuntimeInput extends AgentInstanceRecord {
+  readonly catalog: RivusPluginCatalog;
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly projectSpace?: ResolvedRivusProjectSpace;
+}
+interface CreateRivusDeploymentDaemonOptions {
+  readonly deploymentRoot: string;
+  readonly manifest: RivusDeploymentManifest;
+  readonly loadModule: (request: RivusPluginModuleLoadRequest) => Promise<RivusPluginModule> | RivusPluginModule;
+  readonly initialInstanceRecords?: AgentInstanceRegistryOptions["initialRecords"];
+  readonly createRuntime: (input: CreateRivusDeploymentRuntimeInput) => PooledAgentRuntime | Promise<PooledAgentRuntime>;
+  readonly createEndpoint: (input: CreateRivusDeploymentEndpointInput) => RivusDeploymentEndpoint | Promise<RivusDeploymentEndpoint>;
+  readonly createAutomation?: (input: CreateRivusDeploymentAutomationInput) => RivusDeploymentAutomation | Promise<RivusDeploymentAutomation>;
+  readonly createBackgroundSession?: (input: CreateRivusDeploymentBackgroundSessionInput) => RivusDeploymentBackgroundSession | Promise<RivusDeploymentBackgroundSession>;
+  readonly resolveProjectSpace?: (input: {
+    readonly declaration: RivusProjectSpaceDeployment;
+    readonly deploymentRoot: string;
+  }) => Promise<ResolvedRivusProjectSpace> | ResolvedRivusProjectSpace;
+}
+interface RivusEndpointInput extends AgentRuntimeInput {}
+interface RivusDeploymentDaemon {
+  readonly deployment: LoadedRivusDeployment;
+  handleDefault(input: RivusEndpointInput): Promise<unknown>;
+  handleEndpoint(endpointId: string, input: RivusEndpointInput): Promise<unknown>;
+  runDefaultAgent(input: RivusEndpointInput): Promise<unknown>;
+  running(): boolean;
+  start(): Promise<void>;
+  status(): RivusDeploymentDaemonStatus;
+  stop(): Promise<void>;
+}
+//#endregion
+//#region src/bootstrap/deployment/rivus-deployment-daemon.d.ts
+declare function createRivusDeploymentDaemon(options: CreateRivusDeploymentDaemonOptions): Promise<RivusDeploymentDaemon>;
+//#endregion
+//#region src/adapters/deployment/manifest/node-rivus-deployment-manifest.d.ts
+interface LoadRivusDeploymentManifestOptions {
+  readonly maxBytes?: number;
+}
+declare class RivusDeploymentManifestError extends Error {
+  readonly manifestPath: string;
+  readonly name = "RivusDeploymentManifestError";
+  constructor(manifestPath: string, message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/adapters/compatibility/deployment-control/rivus-deployment-manifest.d.ts
+declare function loadRivusDeploymentManifest(manifestPath: string, options?: LoadRivusDeploymentManifestOptions): Promise<RivusDeploymentManifest>;
+//#endregion
+//#region src/bootstrap/deployment/configured-rivus-deployment-daemon.d.ts
+type CreateConfiguredRivusDeploymentDaemonOptions = Omit<CreateRivusDeploymentDaemonOptions, "deploymentRoot" | "loadModule" | "manifest"> & {
+  readonly manifestPath: string;
+  readonly manifestOptions?: LoadRivusDeploymentManifestOptions;
+  readonly pluginPackageManifestPath?: string;
+};
+declare function createConfiguredRivusDeploymentDaemon(options: CreateConfiguredRivusDeploymentDaemonOptions): Promise<RivusDeploymentDaemon>;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/snapshot.d.ts
+interface ApprovedHumanInteractionState extends ApprovedHumanInteractionState$1 {}
+interface CancelledHumanInteractionState extends CancelledHumanInteractionState$1 {}
+interface ExpiredHumanInteractionState extends ExpiredHumanInteractionState$1 {}
+interface HumanInteractionActor extends HumanInteractionActor$1 {}
+interface HumanInteractionBase extends HumanInteractionBase$1 {}
+interface HumanInteractionFact extends HumanInteractionFact$1 {}
+type HumanInteractionId = HumanInteractionId$1;
+type HumanInteractionResolutionAction = HumanInteractionResolutionAction$1;
+type HumanInteractionTransition = HumanInteractionTransition$1;
+interface PendingHumanInteractionState extends PendingHumanInteractionState$1 {}
+interface RejectedHumanInteractionState extends RejectedHumanInteractionState$1 {}
+interface RequestToolApprovalInput extends RequestToolApprovalInput$1 {}
+interface RequestUserDecisionInput extends RequestUserDecisionInput$1 {}
+interface SelectedHumanInteractionState extends SelectedHumanInteractionState$1 {}
+interface ToolApprovalBinding extends ToolApprovalBinding$1 {}
+type ToolApprovalInteractionState = ToolApprovalInteractionState$1;
+type UserDecisionInteractionState = UserDecisionInteractionState$1;
+interface UserDecisionOption extends UserDecisionOption$1 {}
+type HumanInteraction = ToolApprovalInteraction | UserDecisionInteraction;
+interface ToolApprovalInteraction extends ToolApprovalInteraction$2 {}
+interface UserDecisionInteraction extends UserDecisionInteraction$2 {}
+//#endregion
+//#region src/adapters/compatibility/human-interaction/transitions.d.ts
+declare class HumanInteractionTransitionDenied extends Error {
+  readonly name = "HumanInteractionTransitionDenied";
+}
+declare function transitionHumanInteraction(interaction: HumanInteraction, transition: HumanInteractionTransition): HumanInteraction;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/presenter.d.ts
+interface HumanInteractionPresenter extends HumanInteractionPresenterContract<HumanInteraction> {}
+//#endregion
+//#region src/adapters/compatibility/human-interaction/repository.d.ts
+interface HumanInteractionRepository extends HumanInteractionRepositoryContract<HumanInteraction> {}
+//#endregion
+//#region src/adapters/compatibility/human-interaction/service.d.ts
+interface HumanInteractionClock extends HumanInteractionClock$1 {}
+interface ResolveHumanInteractionInput extends ResolveHumanInteractionInput$1 {}
+interface ConsumeToolApprovalInput extends ConsumeToolApprovalInput$1 {}
+interface HumanInteractionService extends HumanInteractionServiceContract<HumanInteraction, ToolApprovalInteraction, UserDecisionInteraction, RequestToolApprovalInput, RequestUserDecisionInput, ResolveHumanInteractionInput, ConsumeToolApprovalInput> {}
+interface HumanInteractionServiceOptions extends HumanInteractionServiceOptionsContract<HumanInteractionClock, HumanInteractionPresenter, HumanInteractionRepository> {}
+declare function createHumanInteractionService(options: HumanInteractionServiceOptions): HumanInteractionService;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/endpoint-registry.d.ts
+interface HumanInteractionEndpointRegistry {
+  register(endpointId: string, service: HumanInteractionService): void;
+  resolve(endpointId: string): HumanInteractionService | undefined;
+  services(): ReadonlyArray<HumanInteractionService>;
+}
+declare function createHumanInteractionEndpointRegistry(): HumanInteractionEndpointRegistry;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/tool-approval-gateway.d.ts
+declare function createHumanInteractionToolApprovalGateway(options: {
+  readonly clock?: {
+    readonly now: () => string;
+  };
+  readonly expiresAfterMs?: number;
+  readonly registry: HumanInteractionEndpointRegistry;
+}): PiToolApprovalGateway;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/model-change-approval.d.ts
+/** Route accepted model requests through the existing durable human decision service. */
+declare function createHumanInteractionModelChangeApproval(options: {
+  readonly endpointId: string;
+  readonly registry: HumanInteractionEndpointRegistry;
+}): ModelChangeApprovalPort;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/routed-tool-approval-service.d.ts
+declare function createRoutedHumanInteractionToolApprovalService(registry: HumanInteractionEndpointRegistry): ToolApprovalService;
+//#endregion
+//#region src/adapters/feishu/delivery/feishu-text-reply.d.ts
+interface FeishuTextReplySender {
+  reply(messageId: string, text: string): Effect.Effect<void, unknown>;
+}
+declare function createConfiguredFeishuTextReplySender(options: {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}): FeishuTextReplySender;
+//#endregion
+//#region src/adapters/feishu/delivery/feishu-message-reaction.d.ts
+interface FeishuMessageReactionSender {
+  add(messageId: string, emojiType?: string): Effect.Effect<void, unknown>;
+}
+declare function createConfiguredFeishuMessageReactionSender(options: {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}): FeishuMessageReactionSender;
+//#endregion
+//#region src/adapters/feishu/automation/automation-card-sender.d.ts
+interface FeishuAutomationCardInput {
+  readonly idempotencyKey: string;
+  readonly markdown: string;
+  readonly presentation?: AutomationPresentation;
+  readonly receiveId: string;
+  readonly receiveIdType: RivusAutomationDeliveryTargetType;
+}
+interface FeishuAutomationCardSender {
+  send(input: FeishuAutomationCardInput): Effect.Effect<{
+    readonly providerMessageId: string;
+  }, unknown>;
+}
+declare function createConfiguredFeishuAutomationCardSender(options: {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}): FeishuAutomationCardSender;
+//#endregion
+//#region src/adapters/outbound/persistence/human-interaction/jsonl-human-interaction-repository.d.ts
+interface JsonlHumanInteractionRepositoryOptions {
+  readonly filePath: string;
+}
+//#endregion
+//#region src/adapters/compatibility/human-interaction/persistence.d.ts
+declare function createInMemoryHumanInteractionRepository(): HumanInteractionRepository;
+declare function createJsonlHumanInteractionRepository(options: JsonlHumanInteractionRepositoryOptions): HumanInteractionRepository;
+//#endregion
+//#region src/adapters/compatibility/human-interaction/feishu.d.ts
+declare function createFeishuHumanInteractionCard(interaction: HumanInteraction): FeishuRawCardJson;
+interface FeishuHumanInteractionPresenterOptions {
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+}
+declare function createFeishuHumanInteractionPresenter(options: FeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+interface ConfiguredFeishuHumanInteractionPresenterOptions {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}
+declare function createConfiguredFeishuHumanInteractionPresenter(options: ConfiguredFeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+//#endregion
+//#region src/adapters/feishu/run-presentation/feishu-agent-run-card.d.ts
+declare const FEISHU_AGENT_CARD_ELEMENT_ID = "rivus_agent_answer";
+declare const FEISHU_AGENT_CARD_PROGRESS_ELEMENT_ID = "rivus_agent_progress";
+type FeishuAgentRunCardInput = {
+  readonly agentName: string;
+  readonly elementId?: string;
+  readonly generation?: number;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly status: "running"; /** Disable only when a deployment has not subscribed to the modern card.action.trigger callback. */
+  readonly cancelButton?: boolean;
+  readonly presentation?: RunPresentation;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly text?: string;
+} | {
+  readonly agentName: string;
+  readonly presentation?: RunPresentation;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly status: "completed";
+  readonly text: string;
+} | {
+  readonly agentName: string;
+  readonly presentation?: RunPresentation;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly reason?: string;
+  readonly status: "cancelled";
+  readonly text?: string;
+} | {
+  readonly agentName: string;
+  readonly presentation?: RunPresentation;
+  readonly progressDisplay?: ConversationProgressDisplay;
+  readonly status: "failed";
+};
+declare function createFeishuAgentRunCard(input: FeishuAgentRunCardInput): FeishuRawCardJson;
+//#endregion
+//#region src/adapters/compatibility/automation/outcome/commit-automation-outcome.d.ts
+interface CommitAutomationOutcomeInput {
+  readonly tickId: string;
+  readonly outcome: AutomationOutcome;
+  readonly state: PluginStateStore;
+  readonly stateUpdate: PutPluginState;
+  readonly outbox: DeliveryOutbox;
+}
+declare function commitAutomationOutcome(input: CommitAutomationOutcomeInput): CommittedAutomationOutcome;
+//#endregion
+export { ToolApprovalInteraction as $, createFeishuMessageQueue as $a, describeFeishuMessageIntake as $c, RivusEndpointInput$1 as $d, ScheduledAutomationDeliveryInput as $f, createFeishuAgentRuntime as $i, RivusDaemonConfig as $l, MemorySearchQuery as $n, RivusDaemonBootstrapModule as $o, PresentedValue as $p, createRunPresentationProjector as $r, RivusProjectSpaceDeployment as $s, openJsonlAgentMemoryService as $t, ModelChangePublicReceipt as $u, HumanInteractionServiceOptions as A, FeishuCardPresentationStore as Aa, FeishuAgentRunPreparation as Ac, RivusPluginCatalogSnapshot as Ad, AgentHostRuntime as Af, JsonFileFeishuCardTargetRegistryOptions as Ai, InitializeRivusProjectOptions as Al, BackgroundSessionRepository as An, FeishuInboxDeliveryState as Ao, GatewayPresentationPort as Ap, createRateLimitedFeishuPublisher as Ar, RivusDeploymentDaemonLifecycleError as As, intersectToolIds as At, ModelChangeAuthorizationRejected as Au, HumanInteraction as B, FeishuWorkerLoop as Ba, createAgentCommandFromFeishuCardAction as Bc, RivusAutomationTickContext as Bd, commitAutomationOutcome$1 as Bf, FeishuCardKitTextUpdate as Bi, openPiModelManagementDeployment as Bl, isBackgroundSessionLeaseExpired as Bn, FeishuCardDeliveryReconciler as Bo, GatewaySteerAction as Bp, FeishuCotPublisher as Br, ResolvedRivusAutomationDefinition as Bs, createPluginStateStore as Bt, ModelChangeCoordinatorOptions as Bu, createHumanInteractionModelChangeApproval as C, FeishuCardRolloverEventType as Ca, FeishuAgentMessageSideEffects as Cc, createCompatibleRivusAgentCatalog as Cd, createEffectAgentInstanceRegistry as Cf, FeishuCardRolloverSupervisor as Ci, RivusDaemonWorkerLoop as Cl, openJsonlBackgroundSessionRepository as Cn, JsonlFeishuInboxRepositoryOptions as Co, GatewayActionResult as Cp, ConfiguredFeishuCardKitPublisherOptions as Cr, RivusDeploymentBackgroundSessionStatus as Cs, RivusPluginLoadError as Ct, ApprovedModelChangeAuthorization as Cu, ConsumeToolApprovalInput as D, createFeishuCardRollover as Da, FeishuPromptContextInput as Dc, RivusAgentCatalog as Dd, RivusAgentGrantRestriction as Df, FeishuCardTargetRegistry as Di, RivusProjectDoctorReport as Dl, BACKGROUND_SESSION_JSONL_VERSION as Dn, FeishuInboxCompletedState as Do, GatewayExecutionPort as Dp, createCoalescingFeishuPublisher as Dr, RivusDeploymentEndpointStatus as Ds, SubagentRecord as Dt, ModelChangeAuthorizationDecision as Du, createHumanInteractionEndpointRegistry as E, FeishuCardRolloverStatus as Ea, createFeishuAgentDaemon as Ec, resolveRivusAgentDefinition as Ed, RivusAgentDeployment as Ef, FeishuCardTargetNotFound as Ei, RivusProjectDoctorCheck as El, createBackgroundSessionDeliveryStore as En, createRecoveryControl as Eo, GatewayExecuteOptions as Ep, FeishuCoalescingPublisherOptions as Er, RivusDeploymentEndpointLifecycle as Es, SpawnSubagentRequest as Et, ModelBinding$1 as Eu, HumanInteractionTransitionDenied as F, acceptsCardPresentationProgress as Fa, FeishuCardActionIntakeError as Fc, RivusCatalogToolDescriptorRequest as Fd, AgentRuntimeSteering$1 as Ff, FeishuCardKitFail as Fi, PiManagedRunGatewayProviderOptions as Fl, completeBackgroundSessionStep as Fn, createFeishuInboxRepository as Fo, GatewayResetAction as Fp, FeishuCardTargetPreparationOptions as Fr, backgroundSessionToolIds as Fs, DeliveryOutbox as Ft, ModelChangeBudgetLimits as Fu, HumanInteractionResolutionAction as G, FeishuMessageWorkerQueue as Ga, FeishuMessageIntakeError as Gc, CreateBackgroundSessionHostToolsOptions as Gd, DeliveryAttemptResult as Gf, FeishuWebSocketDaemon as Gi, PiModelRunContextRegistry as Gl, requestBackgroundSessionStop as Gn, ConversationProgressDisplay as Go, PresentationStepStatus as Gp, InvalidFeishuTopicContext as Gr, RivusAutomationDelivery as Gs, AutomationTickRepositoryCompatibility as Gt, ModelChangeNotFound as Gu, HumanInteractionBase as H, createFeishuWorkerLoop as Ha, FeishuCancelMessageIntakeSummary as Hc, RIVUS_PLUGIN_API_VERSION as Hd, AutomationOutcome as Hf, createFeishuCardKitPublisher as Hi, PiModelManagementBashSpawnHookOptions as Hl, parkBackgroundSessionForReconciliation as Hn, FeishuCardDeliveryRecord as Ho, AssistantPresentationStep as Hp, FeishuCotRunPreparation as Hr, RivusAgentDeploymentStatus as Hs, openJsonAutomationTickRepository as Ht, ModelChangeExecutionBudget as Hu, transitionHumanInteraction as I, activeCardPresentation as Ia, FeishuCardActionTriggerPayload as Ic, RegisteredRivusAutomation as Id, AgentInstanceBinding as If, FeishuCardKitFinish as Ii, createPiManagedRunGatewayProvider as Il, completeBackgroundSessionStop as In, JsonlFeishuCardDeliveryLedgerOptions as Io, GatewayResetResult as Ip, createConfiguredFeishuCardKitTargetCreator as Ir, createBackgroundSessionToolContracts as Is, DeliveryOutboxError as It, ModelChangeBudgetReservation as Iu, RejectedHumanInteractionState as J, shouldAcceptFeishuEndpointMessage as Ja, FeishuNewSessionCommand as Jc, RivusAgentHost as Jd, PluginStateRecord as Jf, FeishuWebSocketRuntime as Ji, RIVUS_MODEL_CHANGE_TOOL_ID as Jl, suspendBackgroundSession as Jn, runRivusNodeEntrypoint as Jo, RunPresentation as Jp, createFeishuCardKitOpenApiClient as Jr, RivusBackgroundSessionsDeployment as Js, ScheduledAutomationOptions as Jt, ModelChangeOperation as Ju, HumanInteractionTransition as K, createFeishuMessageWorker as Ka, FeishuMessageIntakeOptions as Kc, createBackgroundSessionHostTools as Kd, DeliveryJob as Kf, FeishuWebSocketDaemonOptions as Ki, PiModelRunContextRegistryOptions as Kl, requeueInterruptedBackgroundSessionStep as Kn, DEFAULT_CONVERSATION_PROGRESS_DISPLAY as Ko, RUN_PRESENTATION_SCHEMA_VERSION as Kp, createFeishuTopicContextResolver as Kr, RivusAutomationDeliveryTargetType as Ks, ScheduledAutomation as Kt, ModelChangeNotification as Ku, ApprovedHumanInteractionState as L, isCardPresentationHandoffDue as La, FeishuResolveInteractionCommand as Lc, RivusAutomationInput as Ld, AgentInstanceRecord as Lf, FeishuCardKitPresentationUpdate as Li, PiModelManagementGrantOptions as Ll, createBackgroundSession as Ln, openJsonlFeishuCardDeliveryLedger as Lo, GatewayResolveInteractionAction as Lp, createFeishuCardKitOpenApiTargetCreator as Lr, isBackgroundSessionToolId as Ls, createDeliveryOutbox as Lt, ModelChangeBusy as Lu, createHumanInteractionService as M, CardPresentationChain as Ma, FeishuStreamProjector as Mc, RivusCatalogToolContribution as Md, AgentHostRuntimePort as Mf, createJsonFileFeishuCardTargetRegistry as Mi, initializeRivusProject as Ml, BackgroundSessionTransitionDenied as Mn, FeishuInboxPendingState as Mo, GatewayPromptAction as Mp, FeishuCardPresentationBinder as Mr, BACKGROUND_SESSION_TOOL_IDS as Ms, DelegationEdge as Mt, ModelChangeBoundaryPort as Mu, HumanInteractionRepository as N, CardPresentationStatus as Na, createFeishuStreamProjector as Nc, RivusCatalogToolContributionScope as Nd, AgentRuntimeCancellation$1 as Nf, FeishuCardKitCancel as Ni, RIVUS_RELEASE_DESCRIPTOR as Nl, appendBackgroundSessionInput as Nn, FeishuInboxRepository as No, GatewayPromptCommand as Np, FeishuCardTargetCreateOptions as Nr, BACKGROUND_SESSION_TOOL_PLUGIN_ID as Ns, DelegationGrant as Nt, ModelChangeBoundaryResult as Nu, HumanInteractionClock as O, DEFAULT_CARD_STREAM_LEASE_MS as Oa, FeishuPromptContextResolver as Oc, RivusPlugin as Od, RivusAgentProfile as Of, FeishuCardTargetRegistryOperation as Oi, RivusProjectDoctorStatus as Ol, isBackgroundSessionState as On, FeishuInboxDeadState as Oo, GatewayHumanInteractionPort as Op, FeishuStreamActionPublisher as Or, RivusDeploymentReadinessError as Os, DelegationService as Ot, ModelChangeAuthorizationInput as Ou, HumanInteractionPresenter as P, CardPresentationTransitionDenied as Pa, FeishuCardActionCommand as Pc, RivusCatalogToolDescriptorProvider as Pd, AgentRuntimeInput$1 as Pf, FeishuCardKitClient as Pi, RivusReleaseDescriptor as Pl, claimBackgroundSession as Pn, FeishuInboxRepositoryStateOptions as Po, GatewayReplyPort as Pp, FeishuCardTargetCreator as Pr, BACKGROUND_SESSION_TOOL_VERSION as Ps, DelegationRequest as Pt, ModelChangeBudget as Pu, ToolApprovalBinding as Q, FeishuMessageQueueOptions as Qa, createAgentCommandFromFeishuMessage as Qc, RivusEndpointDefinition as Qd, AutomationSchedulerOptions as Qf, FeishuAgentRuntimeOptions as Qi, createPiModelRunContextRegistry as Ql, AgentMemoryServiceOptions as Qn, RivusDaemonBootstrapFactory as Qo, hasInspectableRunProgress as Qp, RunPresentationProjector as Qr, RivusPluginDeclaration as Qs, createAutomationMandateStore as Qt, ModelChangePrincipal as Qu, CancelledHumanInteractionState as R, CompositeRivusDaemonTransportOptions as Ra, InvalidFeishuCardAction as Rc, RivusAutomationOutput as Rd, AgentRuntimeGenerationIdentity as Rf, FeishuCardKitPublisher as Ri, readPiModelManagementGrant as Rl, failBackgroundSessionStep as Rn, FeishuCardDeliveryLedger as Ro, GatewayRunResult as Rp, createFeishuCardTargetPreparation as Rr, ProcessDeploymentEndpoint as Rs, PluginStateConflict as Rt, ModelChangeClock$1 as Ru, createRoutedHumanInteractionToolApprovalService as S, FeishuCardRolloverEvent as Sa, FeishuAgentExecutionResult as Sc, CreateRivusAgentCatalogOptions as Sd, AgentInstanceRegistryOptions as Sf, createFeishuTenantAccessTokenProvider as Si, RivusDaemonTransport as Sl, createBackgroundSessionRepository as Sn, openJsonFeishuSessionStore as So, GatewayAction as Sp, createFeishuPeriodicFlush as Sr, RivusDeploymentBackgroundSessionReadinessError as Ss, loadRivusDeployment as St, ModelManagementTrustedRun as Su, HumanInteractionEndpointRegistry as T, FeishuCardRolloverOptions as Ta, FeishuHumanInteractionActions as Tc, createRivusPluginCatalog as Td, ResolvedRivusAgentDefinition as Tf, createFeishuCardRolloverSupervisor as Ti, DiagnoseRivusProjectOptions as Tl, openJsonlBackgroundSessionDeliveryStore as Tn, RecoveryControlOptions as To, GatewayCancelResult as Tp, FeishuCoalescingPublisher as Tr, RivusDeploymentDaemonStatus as Ts, createSubagentCoordinator as Tt, MODEL_STATE_SCHEMA_VERSION as Tu, HumanInteractionFact as U, FeishuMessageWorker as Ua, FeishuCancelRunCommand as Uc, RegisteredRivusPlugin as Ud, CommitAutomationOutcomeInput$1 as Uf, FeishuWebSocketClient as Ui, PiModelRunContext as Ul, releaseBackgroundSessionLease as Un, createFeishuCardDeliveryLedger as Uo, ModelPresentationStep as Up, createFeishuCotPublisher as Ur, RivusPluginLoadStatus as Us, DailyAutomationSchedule as Ut, ModelChangeFailureOutcome as Uu, HumanInteractionActor as V, FeishuWorkerLoopOptions as Va, FeishuAgentCommand as Vc, InvalidRivusPlugin as Vd, AutomationOutcomeRepository as Vf, FeishuCardTarget as Vi, PiModelContextReference as Vl, isBackgroundSessionTerminalPhase as Vn, FeishuCardDeliveryReconcilerOptions as Vo, GatewaySteeredResult as Vp, FeishuCotPublisherOptions as Vr, ResolvedRivusProjectSpace as Vs, OpenJsonAutomationTickRepositoryOptions as Vt, ModelChangeError as Vu, HumanInteractionId as W, FeishuMessageWorkerOptions as Wa, FeishuMessageIntakeBaseSummary as Wc, RivusPluginManifest as Wd, CommittedAutomationOutcome as Wf, FeishuWebSocketClientStartOptions as Wi, PiModelRunContextError as Wl, renewBackgroundSessionLease as Wn, createFeishuCardDeliveryReconciler as Wo, PresentationStep as Wp, FeishuTopicContextResolverOptions as Wr, RivusPluginModuleLoadRequest as Ws, createDailyAutomationSchedule as Wt, ModelChangeIdentityPort as Wu, RequestUserDecisionInput as X, FeishuMessagePreparedControl as Xa, FeishuPromptAgentCommand as Xc, RivusAutomationDefinition as Xd, AUTOMATION_SUPPRESSION_PREFIX as Xf, createLazyFeishuWebSocketEventDispatcher as Xi, RIVUS_MODEL_SOCKET_ENV as Xl, AgentMemoryHandle as Xn, runRivusCli as Xo, SkillPresentationStep as Xp, FeishuCardPresentationStoreOptions as Xr, RivusEndpointDeployment as Xs, AutomationTickRecord as Xt, ModelChangePending as Xu, RequestToolApprovalInput as Y, FeishuMessageDrainResult as Ya, FeishuNewSessionMessageIntakeSummary as Yc, RivusAgentHostOptions as Yd, PutPluginState as Yf, createFeishuWebSocketDaemon as Yi, RIVUS_MODEL_CONTEXT_ENV as Yl, AgentMemoryError as Yn, RivusCliOptions as Yo, RunPresentationPhase as Yp, FeishuCardPresentationNotFound as Yr, RivusDeploymentManifest as Ys, createScheduledAutomation as Yt, ModelChangePaidCallKind$1 as Yu, SelectedHumanInteractionState as Z, FeishuMessageQueue as Za, FeishuPromptMessageIntakeSummary as Zc, RivusBackgroundSessionDefinition as Zd, AutomationScheduler as Zf, FeishuAgentRuntime as Zi, createPiModelManagementBashSpawnHook as Zl, AgentMemoryService as Zn, RivusDaemonBootstrapContext as Zo, ToolPresentationStep as Zp, createFeishuCardPresentationStore as Zr, RivusEndpointExperimentalFeatures as Zs, AutomationTickStatus as Zt, ModelChangePhase as Zu, createConfiguredFeishuAutomationCardSender as _, RivusDaemonStatusReporter as _a, FeishuAgentDaemonRunResult as _c, ModelStateRepository as _d, InvalidAgentHostBinding as _f, FeishuTenantAccessTokenError as _i, RivusDaemonShutdownSignal as _l, resolveBackgroundSessionSupervisorIntervalMs as _n, SessionSchedulerDisposed as _o, AutomationMandateStore as _p, createToolBroker$1 as _r, ToolOperationResolutionResult as _s, RivusDeploymentDaemon as _t, ModelChangeApprovalInput as _u, FeishuAgentRunCardInput as a, FeishuReceiveMessageHandlerPayload as aa, FeishuReceiveHandledObservation as ac, ModelChangeRuntimePort$1 as ad, AgentRuntimeSteering as af, restoreConfiguredRivusDaemonBootstrap as ai, FeishuSessionResetResult as al, HumanInteractionRepository$1 as am, FeishuBackgroundSessionDeliveryKind as an, formatRivusEnvFile as ao, AutomationPresentationInput as ap, createAgentHarnessPooledRuntime as ar, runRivusDaemonCli as as, createConfiguredRivusDeploymentDaemon as at, loadRivusDaemonConfig as au, FeishuTextReplySender as b, FeishuCardRollover as ba, FeishuAgentDaemonSteeredResult as bc, validateRivusPluginManifest as bd, AgentInstanceIdentityFactory as bf, FeishuTenantAccessTokenRequest as bi, RivusDaemonProcess as bl, BackgroundSessionSupervisorOptions as bn, createSessionScheduler as bo, MessageGatewayOptions as bp, FeishuPeriodicFlush as br, RivusDeploymentAutomationStatus as bs, LoadRivusDeploymentOptions as bt, ModelChangeAuthorizationOptions as bu, FeishuHumanInteractionPresenterOptions as c, FeishuCardActionCallbackResponse as ca, FeishuReceiveMessageSummary as cc, ModelChangeStatus as cd, createAgentInstanceRegistry as cf, createConfiguredFeishuCardRolloverRuntime as ci, createFeishuSessionStore as cl, ConsumeToolApprovalInput$1 as cm, resolveFeishuDeliveryChatId as cn, resolveFeishuEndpointCredentials as co, AutomationPresentationSection as cp, openJsonlToolOperationLedger$1 as cr, RivusDeploymentBootstrapFactory as cs, RivusDeploymentManifestError as ct, createModelManagementControl as cu, createFeishuHumanInteractionPresenter as d, createFeishuCardActionErrorResponse as da, FeishuAgentDaemon as dc, ModelChangeTransportContext as dd, createAgentHostRuntimePool as df, FeishuOpenApiClient as di, InvalidFeishuSessionReference as dl, DEFAULT_BACKGROUND_SESSION_LIFETIME_MS as dn, JsonFetchRequestOptions as do, createAutomationPresentation as dp, ToolApprovalRequest$1 as dr, DeadLetterRecoveryItem as ds, CreateRivusDeploymentBackgroundSessionInput as dt, ModelChangeRunBoundaryOptions as du, FeishuPeriodicFlushSupervisor as ea, BackgroundSessionLimits as ec, ModelChangeReceipt as ed, createRivusAgentHost as ef, ConfiguredRivusDaemonBootstrap as ei, FeishuMessageContentInput as el, PresentedValueOptions as em, resolveRivusProjectSpace as en, OpenClawEnvImportError as eo, ScheduledAutomationRunInput as ep, createAgentMemoryService as er, RivusDaemonCliOptions as es, ToolApprovalInteractionState as et, RivusDaemonConfigError as eu, createInMemoryHumanInteractionRepository as f, FeishuRawCardJson as fa, FeishuAgentDaemonCancelResult as fc, ModelChangeValidationResult as fd, AgentAutomationBindingDefinition as ff, FeishuOpenApiError as fi, createFeishuConversationId as fl, DEFAULT_BACKGROUND_SESSION_MAX_CONCURRENT_SESSIONS as fn, JsonHttpRequest as fo, readAutomationPresentation as fp, ToolApprovalService as fr, DeadLetterRequeueResult as fs, CreateRivusDeploymentDaemonOptions as ft, ModelChangeRunLease as fu, FeishuAutomationCardSender as g, RivusDaemonStatus as ga, FeishuAgentDaemonOptions as gc, RejectedModelChangeAuthorization as gd, AgentHostOptions as gf, createFeishuOpenApiClient as gi, RivusDaemonShutdownControllerOptions as gl, DEFAULT_BACKGROUND_SESSION_SUPERVISOR_INTERVAL_MS as gn, SessionSchedulerCapacityExceeded as go, AutomationMandateError as gp, ToolInvocationDenied$1 as gr, ToolOperationRecoveryItem as gs, RivusDeploymentBackgroundSession as gt, ModelChangeApprovalAuthority as gu, FeishuAutomationCardInput as h, createRivusDaemonStatusHttpServer as ha, FeishuAgentDaemonInteractionResult as hc, ModelStateCorrupted as hd, AgentHost as hf, createConfiguredFeishuOpenApiClient as hi, RivusDaemonShutdownController as hl, DEFAULT_BACKGROUND_SESSION_STEP_TIMEOUT_MS as hn, SessionScheduler as ho, AutomationMandate as hp, ToolExecutionRequest$1 as hr, RecoverySnapshot as hs, RivusDeploymentAutomation as ht, createModelChangeAuthorization as hu, FEISHU_AGENT_CARD_PROGRESS_ELEMENT_ID as i, FeishuEventHandlersOptions as ia, FeishuReceiveAcceptedObservation as ic, ModelChangeRuntimeContext as id, AgentRuntimePoolOptions as if, createConfiguredRivusDaemonBootstrap as ii, FeishuSessionEpochRecord as il, createHumanInteractionService$1 as im, FeishuBackgroundSessionDeliveryInput as in, createRivusEnvFromOpenClawConfig as io, AutomationPresentation as ip, createFeishuDeploymentEndpoint as ir, RivusDaemonRecoveryRunner as is, CreateConfiguredRivusDeploymentDaemonOptions as it, RivusThinkingLevel as iu, ResolveHumanInteractionInput as j, CardPresentation as ja, FeishuStreamAction as jc, RivusPluginRegistry as jd, AgentHostRuntimeFactoryPort as jf, createInMemoryFeishuCardTargetRegistry as ji, InitializedRivusProject as jl, BackgroundSessionState as jn, FeishuInboxLeasedState as jo, GatewayPresentationUpdate as jp, FeishuCardKitOpenApiTargetCreatorOptions as jr, BACKGROUND_SESSION_START_TOOL_ID as js, DelegationDenied as jt, ModelChangeBoundaryInput as ju, HumanInteractionService as k, FeishuCardPresentationHandoffStart as ka, composeFeishuTopicPrompt as kc, RivusPluginCatalog as kd, RivusRuntimeToolGrantSet$1 as kf, FeishuCardTargetRegistryStoreError as ki, diagnoseRivusProject as kl, createBackgroundSessionService as kn, FeishuInboxDelivery as ko, GatewayObservationPort as kp, RateLimitedFeishuPublisherOptions as kr, RivusDeploymentComponentLifecycle as ks, createDelegationService as kt, ModelChangeAuthorizationPort as ku, createConfiguredFeishuHumanInteractionPresenter as l, FeishuCardActionToast as la, FeishuReceiveRuntimeStatus as lc, ModelChangeStatusView as ld, AgentInstanceBusy as lf, ConfiguredFeishuOpenApiRequest as li, FeishuConversationReference as ll, ResolveHumanInteractionInput$1 as lm, DEFAULT_BACKGROUND_SESSION_LEASE_MS as ln, FetchLike as lo, AutomationPresentationSource as lp, AuthorizationPolicyProvider as lr, RivusDeploymentCliProcess as ls, createRivusDeploymentDaemon as lt, ModelChangeBoundaryDeadlineError as lu, JsonlHumanInteractionRepositoryOptions as m, RivusDaemonStatusHttpServerOptions as ma, FeishuAgentDaemonHandleResult as mc, ModelState as md, AgentEndpointDefinition as mf, FeishuOpenApiResponse as mi, FeishuReceiveMessagePayload as ml, DEFAULT_BACKGROUND_SESSION_RETRY_BACKOFF_MS as mn, createJsonFetchRequest as mo, AutomationDeliveryBinding as mp, ToolBrokerOptions as mr, RecoveryControl as ms, CreateRivusDeploymentRuntimeInput as mt, createModelChangeCoordinator as mu, commitAutomationOutcome as n, FeishuEventHandlerQueue as na, BackgroundSessionSupervisorStatus as nc, ModelChangeRestoreResult as nd, AgentRuntimeInput as nf, ConfiguredRivusDaemonBootstrapRequest as ni, UnsupportedFeishuMessage as nl, HumanInteractionService$1 as nm, validateRivusDeploymentManifest as nn, OpenClawEnvImportResult as no, createAutomationScheduler as np, createFeishuPresentationPreparation as nr, RivusDaemonFeishuReplayRunner as ns, UserDecisionInteractionState as nt, RivusDaemonEnv as nu, createFeishuAgentRunCard as o, FeishuSdkReceiveMessagePayload as oa, FeishuReceiveMessageReplayOptions as oc, ModelChangeSource as od, PooledAgentRuntime as of, ConfiguredFeishuCardRolloverRuntime as oi, FeishuSessionStore as ol, HumanInteractionRepositoryError as om, createBackgroundSessionCard as on, FeishuEndpointCredentialError as oo, AutomationPresentationItem as op, JsonlRecoveryControlOptions as or, RivusDeploymentBootstrapAdapters as os, loadRivusDeploymentManifest as ot, ModelManagementControl as ou, createJsonlHumanInteractionRepository as p, RivusDaemonStatusHttpServer as pa, FeishuAgentDaemonHandleMessageOptions as pc, ModelReference$1 as pd, AgentBackgroundSessionBindingDefinition as pf, FeishuOpenApiRequest as pi, createFeishuSessionKey as pl, DEFAULT_BACKGROUND_SESSION_MAX_CONSECUTIVE_FAILURES as pn, JsonHttpResponse as po, AutomationBinding as pp, ToolBroker as pr, RecoveryAction as ps, CreateRivusDeploymentEndpointInput as pt, createModelChangeRunBoundary as pu, PendingHumanInteractionState as q, FeishuEndpointGroupPolicy as qa, FeishuMessageIntakeSummary as qc, InvalidRivusEndpointBinding as qd, DeliveryJobStatus as qf, FeishuWebSocketEventDispatcher as qi, PiModelTrustedRun as ql, resolveBackgroundSessionReconciliation as qn, RivusNodeEntrypointOptions as qo, ResponsePresentationStep as qp, FeishuCardKitOpenApiClientOptions as qr, RivusAutomationDeployment as qs, ScheduledAutomationClock as qt, ModelChangeNotificationPort as qu, FEISHU_AGENT_CARD_ELEMENT_ID as r, FeishuEventHandlers as ra, FeishuMessageWorkerDrainAvailableResult as rc, ModelChangeRevisionConflict as rd, AgentRuntimePool as rf, ConfiguredRivusDaemonBootstrapResponse as ri, readFeishuMessageContent as rl, HumanInteractionServiceOptions$1 as rm, FeishuBackgroundSessionDelivery as rn, RivusEnvFileVariables as ro, AUTOMATION_PRESENTATION_SCHEMA_VERSION as rp, FeishuDeploymentEndpointOptions as rr, RivusDaemonPromptRunner as rs, UserDecisionOption as rt, RivusTextFileReader as ru, ConfiguredFeishuHumanInteractionPresenterOptions as s, createFeishuEventHandlers as sa, FeishuReceiveMessageReplayResult as sc, ModelChangeSourceHint as sd, createAgentRuntimePool as sf, ConfiguredFeishuCardRolloverRuntimeOptions as si, FeishuSessionStoreOptions as sl, HumanInteractionPresenter$1 as sm, createConfiguredFeishuBackgroundSessionDelivery as sn, FeishuEndpointCredentials as so, AutomationPresentationKind as sp, openJsonlRecoveryControl as sr, RivusDeploymentBootstrapContext as ss, LoadRivusDeploymentManifestOptions as st, ModelManagementControlOptions as su, CommitAutomationOutcomeInput as t, FeishuEventHandlerCardActions as ta, BackgroundSessionSupervisor as tc, ModelChangeRequestConflict as td, AgentRuntimeCancellation as tf, ConfiguredRivusDaemonBootstrapOptions as ti, InvalidFeishuMessageContent as tl, createPresentedValue as tm, InvalidRivusProjectSpace as tn, OpenClawEnvImportOptions as to, ScheduledAutomationRunResult as tp, FeishuPresentationPreparationOptions as tr, RivusDaemonCliWriter as ts, UserDecisionInteraction as tt, RivusDaemonConfigLoaderOptions as tu, createFeishuHumanInteractionCard as u, createFeishuCardActionCallbackResponse as ua, FeishuMessageAcceptResult as uc, ModelChangeSubmission as ud, AgentRuntimeDisposed as uf, ConfiguredFeishuOpenApiResponse as ui, FeishuSessionReference as ul, DEFAULT_BACKGROUND_SESSION_LEASE_RENEWAL_INTERVAL_MS as un, FetchLikeResponse as uo, InvalidAutomationPresentation as up, AuthorizationPolicyState$1 as ur, createRivusDeploymentCliProcess as us, CreateRivusDeploymentAutomationInput as ut, ModelChangeRunBoundary as uu, FeishuMessageReactionSender as v, RivusDaemonStatusReporterOptions as va, FeishuAgentDaemonSessionResetResult as vc, validateRivusCatalogIdentifier as vd, createEffectAgentHost as vf, FeishuTenantAccessTokenProvider as vi, RivusDaemonSignalSource as vl, extendBackgroundSessionDefinition as vn, SessionSchedulerOptions as vo, AutomationTick as vp, WorkspaceInstructionsProvider as vr, RivusDeploymentAutomationLifecycle as vs, RivusDeploymentEndpoint as vt, ModelChangeApprovalPort as vu, createHumanInteractionToolApprovalGateway as w, FeishuCardRolloverHandoffResult as wa, FeishuAgentPreparedControl as wc, createRivusAgentCatalog as wd, RegisteredRivusAgentProfile as wf, FeishuCardRolloverSupervisorOptions as wi, createRivusDaemonProcess as wl, BACKGROUND_SESSION_DELIVERY_JSONL_VERSION as wn, openJsonlFeishuInboxRepository as wo, GatewayCancelAction as wp, createConfiguredFeishuCardKitPublisher as wr, RivusDeploymentDaemonLifecycle as ws, SubagentCoordinator as wt, AwaitingModelChangeAuthorization as wu, createConfiguredFeishuTextReplySender as x, FeishuCardRolloverCounters as xa, FeishuAgentExecution as xc, CreateCompatibleRivusAgentCatalogOptions as xd, AgentInstanceRegistry$1 as xf, FeishuTenantAccessTokenResponse as xi, RivusDaemonProcessOptions as xl, createBackgroundSessionSupervisor as xn, OpenJsonFeishuSessionStoreOptions as xo, createMessageGateway as xp, FeishuPeriodicFlushOptions as xr, RivusDeploymentBackgroundSessionLifecycle as xs, RivusPluginModule as xt, ModelManagementGrant as xu, createConfiguredFeishuMessageReactionSender as y, createRivusDaemonStatusReporter as ya, FeishuAgentDaemonSkippedResult as yc, validateRivusCatalogRegistration as yd, AgentInstanceConflict as yf, FeishuTenantAccessTokenProviderOptions as yi, createRivusDaemonShutdownController as yl, narrowBackgroundSessionDefinition as yn, SessionSchedulerStatus as yo, MessageGateway as yp, createAgentsMdInstructionsProvider as yr, RivusDeploymentAutomationReadinessError as ys, loadNodeRivusPluginModule as yt, ModelChangeApprovalStatus as yu, ExpiredHumanInteractionState as z, createCompositeRivusDaemonTransport as za, UnsupportedFeishuCardAction as zc, RivusAutomationTemplate as zd, CommitAutomationOutcomeCommand as zf, FeishuCardKitPublisherOptions as zi, PiModelManagementDeploymentOptions as zl, isBackgroundSessionDue as zn, FeishuCardDeliveryLedgerStateOptions as zo, GatewaySkippedResult as zp, FeishuCotProtocolError as zr, LoadedRivusDeployment as zs, PluginStateStore as zt, ModelChangeCoordinator as zu };