@rivus/agent 0.13.2 → 0.14.1

package/dist/chunks/index.d.ts

@@ -0,0 +1,3662 @@
+import { $ as AgentSessionSnapshot, F as AgentDomainEventHandler, G as AgentRunUpdate, Gt as AgentRunSummary, I as AgentDomainEventListener, It as AgentTranscript, J as AgentSessionAvailability, K as AgentRunUpdateHandler, Kt as AgentSessionSummary, L as AgentDomainEventSink, N as ActiveAgentRun, P as AgentClock, R as AgentHarness, U as AgentPromptResult, W as AgentRunSnapshot, Wt as AgentHistory, X as AgentSessionHandle, Yt as AgentRunState, a as AgentLoopInput, cn as AgentRunId$1, en as AgentDomainEvent, et as PromptCommand, g as AgentModelContentObserver, jt as AgentInvocationOrigin, l as TextAgentLoopCallback, n as AgentLoopCallback, q as AgentRunUpdateListener, t as AgentLoop, tt as RunIdGenerator, yn as SessionKey, z as AgentHarnessAvailability, zt as AgentTranscriptTurn } from "./agent-loop.js";
+import { d as MemoryScope, g as CompactionSnapshot, h as CompactionInput, i as MemoryRecord, l as MemoryBinding, n as MemorySearchQuery, r as AgentMemorySnapshot } from "./api.js";
+import { B as CommittedAutomationOutcome, G as PutPluginState, H as DeliveryJob, J as RivusAgentDeployment, L as AutomationMandateStore, N as AutomationBinding, V as DeliveryAttemptResult, W as PluginStateRecord, Z as RivusHostToolDescriptor, a as RivusPlugin, b as ScheduledAutomationRunResult, o as RivusPluginCatalog, q as ResolvedRivusAgentDefinition, rt as RivusToolGrantSet, u as RegisteredRivusAutomation, v as ScheduledAutomationDeliveryInput, w as AutomationPresentation, x as AutomationTickRecord, y as ScheduledAutomationRunInput, z as AutomationOutcome } from "./api2.js";
+import { T as InvocationAuthorityRef, _ as ToolOperationInspectResult, b as ToolOperationRecord, f as AuthorizationPolicyState, g as ToolOperationBinding, h as ToolOperationBeginResult, p as ToolApprovalRequest, t as PiToolApprovalGateway, y as ToolOperationReconciliationOutcome } from "./pi-tool-proxy.js";
+import { A as BackgroundSessionRepository, F as BackgroundSessionDeliveryStore, J as BackgroundSessionAuthority, P as BackgroundSessionDeliveryRecord, Q as BackgroundSessionOrigin, X as BackgroundSessionId, Z as BackgroundSessionLease, et as BackgroundSessionState, i as BackgroundSessionSupervisorStatus, w as BackgroundSessionService } from "./api3.js";
+import { Effect } from "effect";
+import { Tracer } from "@opentelemetry/api";
+
+//#region src/modules/run-presentation/domain/value/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/modules/run-presentation/domain/presentation/run-presentation.d.ts
+declare const RUN_PRESENTATION_SCHEMA_VERSION: 2;
+type AgentRunId = 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;
+  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/modules/run-presentation/domain/presentation/conversation-progress.d.ts
+declare const DEFAULT_CONVERSATION_PROGRESS_DISPLAY: "collapsed";
+type ConversationProgressDisplay = "hidden" | "collapsed" | "expanded";
+//#endregion
+//#region src/adapters/feishu/card-presentation/streaming/feishu-stream-projector.d.ts
+type FeishuStreamAction = {
+  readonly type: "update_text";
+  readonly runId: AgentRunId$1;
+  readonly text: string;
+} | {
+  readonly presentation: RunPresentation;
+  readonly runId: AgentRunId$1;
+  readonly type: "update_progress";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly runId: AgentRunId$1;
+  readonly sessionKey: string;
+  readonly text?: string;
+  readonly type: "update_presentation";
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "finish";
+  readonly runId: AgentRunId$1;
+  readonly text: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "fail";
+  readonly runId: AgentRunId$1;
+  readonly errorMessage: string;
+} | {
+  readonly presentation?: RunPresentation;
+  readonly type: "cancel";
+  readonly runId: AgentRunId$1;
+  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/card-presentation/delivery/feishu-card-delivery-ledger.d.ts
+interface FeishuCardDeliveryRecord {
+  readonly revision: number;
+  readonly runId: AgentRunId$1;
+  readonly sequence: number;
+  readonly terminalPublished: boolean;
+}
+interface FeishuCardDeliveryLedger {
+  isTerminalPublished(runId: AgentRunId$1): boolean;
+  markTerminal(runId: AgentRunId$1): Effect.Effect<void, unknown>;
+  reserveSequence(runId: AgentRunId$1): 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/modules/human-interaction/domain/interaction/human-interaction-model.d.ts
+type HumanInteractionId = string;
+type HumanInteractionToolRisk = "observe" | "mutate" | "irreversible" | "host-control";
+interface HumanInteractionActor {
+  readonly openId: string;
+  readonly tenantKey: string;
+}
+interface HumanInteractionFact {
+  readonly label: string;
+  readonly value: string;
+}
+interface ToolApprovalBinding {
+  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 {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly createdAt: string;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact>;
+  readonly id: HumanInteractionId;
+  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 {
+  readonly status: "pending";
+}
+interface ApprovedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly consumedAt?: string;
+  readonly resolvedAt: string;
+  readonly status: "approved";
+}
+interface RejectedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly resolvedAt: string;
+  readonly status: "rejected";
+}
+interface SelectedHumanInteractionState {
+  readonly actor: HumanInteractionActor;
+  readonly optionId: string;
+  readonly resolvedAt: string;
+  readonly status: "selected";
+}
+interface ExpiredHumanInteractionState {
+  readonly expiredAt: string;
+  readonly status: "expired";
+}
+interface CancelledHumanInteractionState {
+  readonly cancelledAt: string;
+  readonly reason?: string;
+  readonly status: "cancelled";
+}
+type ToolApprovalInteractionState = PendingHumanInteractionState | ApprovedHumanInteractionState | RejectedHumanInteractionState | ExpiredHumanInteractionState | CancelledHumanInteractionState;
+interface ToolApprovalInteraction extends HumanInteractionBase {
+  readonly kind: "tool-approval";
+  readonly request: Omit<ToolApprovalBinding, "agentId" | "instanceId" | "runId" | "sessionKey" | "tenantKey">;
+  readonly state: ToolApprovalInteractionState;
+}
+interface UserDecisionOption {
+  readonly description: string;
+  readonly id: string;
+  readonly label: string;
+}
+type UserDecisionInteractionState = PendingHumanInteractionState | SelectedHumanInteractionState | RejectedHumanInteractionState | ExpiredHumanInteractionState | CancelledHumanInteractionState;
+interface UserDecisionInteraction extends HumanInteractionBase {
+  readonly kind: "user-decision";
+  readonly options: ReadonlyArray<UserDecisionOption>;
+  readonly recommendedOptionId?: string;
+  readonly state: UserDecisionInteractionState;
+}
+type HumanInteraction = ToolApprovalInteraction | UserDecisionInteraction;
+type HumanInteractionResolutionAction = "approve" | "reject" | "select";
+type HumanInteractionTransition = {
+  readonly action: HumanInteractionResolutionAction;
+  readonly actor: HumanInteractionActor;
+  readonly now: string;
+  readonly optionId?: string;
+  readonly type: "resolve";
+} | {
+  readonly binding: ToolApprovalBinding;
+  readonly now: string;
+  readonly type: "consume-approval";
+} | {
+  readonly now: string;
+  readonly reason?: string;
+  readonly type: "cancel";
+};
+//#endregion
+//#region src/modules/human-interaction/application/interaction/human-interaction-request.d.ts
+interface RequestToolApprovalInput {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact>;
+  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 {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly expiresAt: string;
+  readonly facts: ReadonlyArray<HumanInteractionFact>;
+  readonly instanceId: string;
+  readonly interactionId: string;
+  readonly options: ReadonlyArray<UserDecisionOption>;
+  readonly recommendedOptionId?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly summary: string;
+  readonly tenantKey: string;
+  readonly title: string;
+}
+//#endregion
+//#region src/modules/human-interaction/application/interaction/human-interaction-presenter.d.ts
+interface HumanInteractionPresenter {
+  present(interaction: HumanInteraction): Effect.Effect<void, unknown>;
+}
+//#endregion
+//#region src/modules/human-interaction/application/interaction/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 HumanInteractionRepository {
+  create(interaction: HumanInteraction): Effect.Effect<void, HumanInteractionRepositoryError>;
+  get(id: HumanInteractionId): Effect.Effect<HumanInteraction | undefined, HumanInteractionRepositoryError>;
+  update(id: HumanInteractionId, transition: (current: HumanInteraction) => HumanInteraction): Effect.Effect<HumanInteraction, HumanInteractionRepositoryError>;
+}
+//#endregion
+//#region src/modules/human-interaction/application/interaction/human-interaction-service.d.ts
+interface HumanInteractionClock {
+  now(): string;
+}
+interface ResolveHumanInteractionInput {
+  readonly action: HumanInteractionResolutionAction;
+  readonly actor: HumanInteractionActor;
+  readonly interactionId: string;
+  readonly optionId?: string;
+}
+interface ConsumeToolApprovalInput {
+  readonly approvalId: string;
+  readonly binding: ToolApprovalBinding;
+}
+interface HumanInteractionService {
+  consumeToolApproval(input: ConsumeToolApprovalInput): Effect.Effect<boolean, unknown>;
+  get(interactionId: string): Effect.Effect<HumanInteraction | undefined, unknown>;
+  resolve(input: ResolveHumanInteractionInput): Effect.Effect<HumanInteraction, unknown>;
+  requestToolApproval(input: RequestToolApprovalInput): Effect.Effect<ToolApprovalInteraction, unknown>;
+  requestUserDecision(input: RequestUserDecisionInput): Effect.Effect<UserDecisionInteraction, unknown>;
+  waitForResolution(input: {
+    readonly interactionId: string;
+    readonly signal?: AbortSignal;
+  }): Effect.Effect<HumanInteraction, unknown>;
+}
+interface HumanInteractionServiceOptions {
+  readonly clock: HumanInteractionClock;
+  readonly presenter: HumanInteractionPresenter;
+  readonly repository: HumanInteractionRepository;
+  readonly sleep?: (ms: number) => Promise<void>;
+}
+declare function createHumanInteractionService(options: HumanInteractionServiceOptions): HumanInteractionService;
+//#endregion
+//#region src/modules/human-interaction/domain/interaction/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/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/modules/conversation-session/domain/session/conversation-session.d.ts
+type ConversationSessionKey = string;
+//#endregion
+//#region src/adapters/feishu/conversation-session/feishu-session-key.d.ts
+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$1;
+  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$1;
+}
+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;
+  readonly actor: HumanInteractionActor;
+  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/protocol/feishu-agent-run-preparation.d.ts
+/** Channel contract shared by Feishu intake and presentation adapters. */
+interface FeishuAgentRunPreparation {
+  readonly messageId: string;
+  readonly prompt: string;
+  readonly receiveId: string;
+  readonly runId: AgentRunId$1;
+  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$1) => 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 {
+  readonly finalText: string;
+  readonly runId: AgentRunId$1;
+}
+interface FeishuAgentExecution {
+  cancelActiveRun(input: {
+    readonly reason: string;
+    readonly sessionKey: SessionKey;
+  }): Effect.Effect<AgentRunId$1 | undefined, unknown>;
+  cancelRun(input: {
+    readonly reason: string;
+    readonly runId: AgentRunId$1;
+    readonly sessionKey?: SessionKey;
+  }): Effect.Effect<boolean, unknown>;
+  getActiveRun?(input: {
+    readonly sessionKey: SessionKey;
+  }): Effect.Effect<AgentRunId$1 | undefined, unknown>;
+  /** Routes a message into the active run without creating a second run/card. */
+  steerRun(input: {
+    readonly sessionKey: SessionKey;
+    readonly text: string;
+  }): Effect.Effect<{
+    readonly runId: AgentRunId$1;
+    readonly steered: true;
+  } | undefined, unknown>;
+  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$1;
+  readonly reason?: "not_active";
+}
+interface FeishuAgentDaemonSteeredResult {
+  readonly messageId: string;
+  readonly runId: AgentRunId$1;
+  readonly steered: true;
+}
+interface FeishuAgentDaemonInteractionResult {
+  readonly interaction: HumanInteraction;
+  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): Effect.Effect<HumanInteraction, 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/modules/recovery/domain/action/recovery-action.d.ts
+interface RecoveryAction {
+  readonly actorId: string;
+  readonly at: string;
+  readonly note: string;
+}
+declare class InvalidRecoveryAction extends Error {
+  readonly name = "InvalidRecoveryAction";
+}
+declare function createRecoveryAction(input: RecoveryAction): RecoveryAction;
+//#endregion
+//#region src/modules/recovery/application/control/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/modules/inbound-delivery/domain/delivery/inbound-delivery.d.ts
+interface InboundDeliveryPendingState {
+  readonly availableAt: string;
+  readonly status: "pending";
+}
+interface InboundDeliveryLeasedState {
+  readonly leaseExpiresAt: string;
+  readonly leaseId: string;
+  readonly leasedAt: string;
+  readonly status: "leased";
+}
+interface InboundDeliveryCompletedState {
+  readonly completedAt: string;
+  readonly status: "completed";
+}
+interface InboundDeliveryDeadState {
+  readonly failedAt: string;
+  readonly reason: string;
+  readonly status: "dead";
+}
+type InboundDeliveryState = InboundDeliveryPendingState | InboundDeliveryLeasedState | InboundDeliveryCompletedState | InboundDeliveryDeadState;
+interface InboundDeliveryRecoveryAudit {
+  readonly actorId: string;
+  readonly at: string;
+  readonly note: string;
+}
+interface InboundDelivery<Payload = unknown, Metadata = unknown> {
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly id: string;
+  readonly laneKey: string;
+  readonly metadata?: Metadata;
+  readonly payload: Payload;
+  readonly recovery?: InboundDeliveryRecoveryAudit;
+  readonly revision: number;
+  readonly state: InboundDeliveryState;
+}
+//#endregion
+//#region src/modules/inbound-delivery/application/inbox/inbound-delivery-repository.d.ts
+type InboundDeliveryAdmission = "created" | "duplicate" | "capacity";
+interface InboundDeliveryRepository<Payload = unknown, Metadata = unknown> {
+  admit(delivery: InboundDelivery<Payload, Metadata>, maxPending: number): Effect.Effect<InboundDeliveryAdmission, unknown>;
+  claim(input: {
+    readonly leaseExpiresAt: string;
+    readonly leaseId: string;
+    readonly now: string;
+  }): Effect.Effect<InboundDelivery<Payload, Metadata> | undefined, unknown>;
+  claimById(input: {
+    readonly id: string;
+    readonly leaseExpiresAt: string;
+    readonly leaseId: string;
+    readonly now: string;
+  }): Effect.Effect<InboundDelivery<Payload, Metadata> | undefined, unknown>;
+  complete(input: {
+    readonly completedAt: string;
+    readonly id: string;
+    readonly leaseId: string;
+  }): Effect.Effect<void, unknown>;
+  create(delivery: InboundDelivery<Payload, Metadata>): Effect.Effect<boolean, unknown>;
+  deadLetters(): ReadonlyArray<InboundDelivery<Payload, Metadata>>;
+  fail(input: {
+    readonly availableAt?: string;
+    readonly failedAt: string;
+    readonly id: string;
+    readonly leaseId: string;
+    readonly reason: string;
+    readonly terminal: boolean;
+  }): Effect.Effect<void, unknown>;
+  pendingCount(): number;
+  renew(input: {
+    readonly id: string;
+    readonly leaseExpiresAt: string;
+    readonly leaseId: string;
+    readonly now: string;
+  }): Effect.Effect<InboundDelivery<Payload, Metadata>, unknown>;
+  requeueDeadLetter(input: {
+    readonly availableAt: string;
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly recovery: InboundDeliveryRecoveryAudit;
+  }): Effect.Effect<InboundDelivery<Payload, Metadata>, unknown>;
+  release(input: {
+    readonly availableAt: string;
+    readonly id: string;
+    readonly leaseId: string;
+  }): Effect.Effect<void, unknown>;
+}
+//#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;
+}
+type FeishuInboundDeliveryRepository = InboundDeliveryRepository<FeishuReceiveMessagePayload, FeishuAgentDaemonHandleMessageOptions>;
+interface FeishuInboxRepository {
+  admit(delivery: FeishuInboxDelivery, maxPending: number): ReturnType<FeishuInboundDeliveryRepository["admit"]>;
+  claim(input: Parameters<FeishuInboundDeliveryRepository["claim"]>[0]): Effect.Effect<FeishuInboxDelivery | undefined, unknown>;
+  claimById(input: Parameters<FeishuInboundDeliveryRepository["claimById"]>[0]): Effect.Effect<FeishuInboxDelivery | undefined, unknown>;
+  complete(input: Parameters<FeishuInboundDeliveryRepository["complete"]>[0]): ReturnType<FeishuInboundDeliveryRepository["complete"]>;
+  create(delivery: FeishuInboxDelivery): Effect.Effect<boolean, unknown>;
+  deadLetters(): ReadonlyArray<FeishuInboxDelivery>;
+  fail(input: Parameters<FeishuInboundDeliveryRepository["fail"]>[0]): ReturnType<FeishuInboundDeliveryRepository["fail"]>;
+  pendingCount(): number;
+  requeueDeadLetter(input: {
+    readonly availableAt: string;
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly recovery: RecoveryAction;
+  }): Effect.Effect<FeishuInboxDelivery, unknown>;
+  release(input: Parameters<FeishuInboundDeliveryRepository["release"]>[0]): ReturnType<FeishuInboundDeliveryRepository["release"]>;
+}
+interface FeishuInboxRepositoryStateOptions {
+  readonly initial?: ReadonlyArray<FeishuInboxDelivery>;
+  readonly persist?: (delivery: FeishuInboxDelivery) => Promise<void>;
+}
+declare function createFeishuInboxRepository(options?: FeishuInboxRepositoryStateOptions): FeishuInboxRepository;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/tool-operation-ledger.d.ts
+interface ToolOperationLedger {
+  abort(operationId: string, binding: ToolOperationBinding): Promise<void>;
+  begin(operationId: string, binding: ToolOperationBinding): Promise<ToolOperationBeginResult>;
+  complete(operationId: string, binding: ToolOperationBinding, result: unknown): Promise<void>;
+  inspect(operationId: string, binding: ToolOperationBinding): Promise<ToolOperationInspectResult>;
+  reconciliationRequired(): ReadonlyArray<ToolOperationRecord>;
+  reconcile(input: {
+    readonly action: RecoveryAction;
+    readonly expectedRevision: number;
+    readonly operationId: string;
+    readonly outcome: ToolOperationReconciliationOutcome;
+  }): Promise<ToolOperationRecord>;
+  requireReconciliation(operationId: string, binding: ToolOperationBinding, reason: string): Promise<void>;
+  unresolvedForSource(sourceMessageId: string): ReadonlyArray<ToolOperationRecord>;
+}
+declare function createToolOperationLedger(options?: {
+  readonly initial?: ReadonlyArray<ToolOperationRecord>;
+  readonly persist?: (record: ToolOperationRecord) => Promise<void>;
+}): ToolOperationLedger;
+//#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;
+  }>;
+}
+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/modules/agent-host/domain/instance/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;
+}
+declare class AgentInstanceConflict extends Error {
+  readonly name = "AgentInstanceConflict";
+}
+//#endregion
+//#region src/modules/agent-host/application/registry/agent-instance-registry.d.ts
+interface AgentInstanceRegistryOptions {
+  readonly initialRecords?: ReadonlyArray<AgentInstanceRecord>;
+}
+//#endregion
+//#region src/modules/agent-host/application/runtime/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$1;
+  readonly sessionKey: SessionKey;
+}
+interface AgentRuntimeSteering$1 {
+  readonly runId: AgentRunId$1;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+declare class AgentInstanceBusy extends Error {
+  readonly name = "AgentInstanceBusy";
+}
+declare class AgentRuntimeDisposed extends Error {
+  readonly name = "AgentRuntimeDisposed";
+}
+//#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/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/compatibility/agent-execution/runtime/agent-harness.d.ts
+interface AgentHarnessOptions {
+  readonly loop: AgentLoop;
+  readonly runIds: RunIdGenerator;
+  readonly clock: AgentClock;
+  readonly runTimeoutMs?: number;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+}
+declare function createAgentHarness(options: AgentHarnessOptions): AgentHarness;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-callback-adapters.d.ts
+type AgentDomainEventCallback = (event: AgentDomainEvent) => void | Promise<void>;
+type AgentDomainEventSinkCallback = AgentDomainEventCallback;
+type AgentRunUpdateCallback = (update: AgentRunUpdate) => void | Promise<void>;
+declare function createAgentDomainEventSinkFromCallback(append: AgentDomainEventSinkCallback): AgentDomainEventSink;
+declare function createAgentDomainEventHandler(handle: AgentDomainEventCallback): AgentDomainEventHandler;
+declare function createAgentRunUpdateHandler(handle: AgentRunUpdateCallback): AgentRunUpdateHandler;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-harness-client.d.ts
+interface AgentRunLookupClient {
+  getRunSummary(runId: AgentRunId$1): AgentRunSummary | undefined;
+  getRunUpdates(runId: AgentRunId$1): ReadonlyArray<AgentRunUpdate> | undefined;
+  getRunEvents(runId: AgentRunId$1): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunState(runId: AgentRunId$1): AgentRunState | undefined;
+  getRunSnapshot(runId: AgentRunId$1): AgentRunSnapshot | undefined;
+}
+interface AgentHarnessClient extends AgentRunLookupClient {
+  readonly harness: AgentHarness;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId$1, reason?: string): Promise<boolean>;
+  forSession(sessionKey: SessionKey): AgentSessionClient;
+  getSessionHistory(sessionKey: SessionKey): AgentHistory;
+  getSessionTranscript(sessionKey: SessionKey): AgentTranscript;
+  getSessionSnapshot(sessionKey: SessionKey): AgentSessionSnapshot;
+  getSessionSummary(sessionKey: SessionKey): AgentSessionSummary | undefined;
+  getSessionState(sessionKey: SessionKey): AgentRunState | undefined;
+  getSessionRuns(sessionKey: SessionKey): ReadonlyArray<AgentRunSummary>;
+  getSessionLatestRunSummary(sessionKey: SessionKey): AgentRunSummary | undefined;
+  getSessionLatestRunSnapshot(sessionKey: SessionKey): AgentRunSnapshot | undefined;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunId(): AgentRunId$1 | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentHarnessAvailability;
+  getHistory(): AgentHistory;
+  getState(): AgentRunState;
+  prompt(command: PromptCommand): Promise<AgentPromptResult>;
+  promptRunSnapshot(command: PromptCommand): Promise<AgentRunSnapshot>;
+  promptSnapshot(command: PromptCommand): Promise<AgentSessionSnapshot>;
+  promptText(command: PromptCommand): Promise<string>;
+  promptTurn(command: PromptCommand): Promise<AgentTranscriptTurn>;
+  promptWithEvents(command: PromptCommand, onEvent: AgentDomainEventCallback): Promise<AgentPromptResult>;
+  promptWithText(command: PromptCommand, onTextDelta: AgentTextDeltaCallback): Promise<AgentPromptResult>;
+  promptWithUpdates(command: PromptCommand, onUpdate: AgentRunUpdateCallback): Promise<AgentPromptResult>;
+  stream(command: PromptCommand): AsyncIterable<AgentDomainEvent>;
+  streamText(command: PromptCommand): AsyncIterable<string>;
+  streamUpdates(command: PromptCommand): AsyncIterable<AgentRunUpdate>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId$1, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId$1, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+  tryPrompt(command: PromptCommand): Promise<AgentClientAttempt<AgentPromptResult, unknown>>;
+  tryPromptText(command: PromptCommand): Promise<AgentClientAttempt<string, unknown>>;
+}
+interface AgentSessionClient extends AgentRunLookupClient {
+  readonly handle: AgentSessionHandle;
+  readonly sessionKey: SessionKey;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId$1, reason?: string): Promise<boolean>;
+  getSnapshot(): AgentSessionSnapshot;
+  getState(): AgentRunState | undefined;
+  getSummary(): AgentSessionSummary | undefined;
+  getTranscript(): AgentTranscript;
+  getRuns(): ReadonlyArray<AgentRunSummary>;
+  getLatestRunSnapshot(): AgentRunSnapshot | undefined;
+  getLatestRunSummary(): AgentRunSummary | undefined;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentSessionAvailability;
+  getHistory(): AgentHistory;
+  prompt(text: string): Promise<AgentPromptResult>;
+  promptRunSnapshot(text: string): Promise<AgentRunSnapshot>;
+  promptSnapshot(text: string): Promise<AgentSessionSnapshot>;
+  promptText(text: string): Promise<string>;
+  promptTurn(text: string): Promise<AgentTranscriptTurn>;
+  promptWithEvents(text: string, onEvent: AgentDomainEventCallback): Promise<AgentPromptResult>;
+  promptWithText(text: string, onTextDelta: AgentTextDeltaCallback): Promise<AgentPromptResult>;
+  promptWithUpdates(text: string, onUpdate: AgentRunUpdateCallback): Promise<AgentPromptResult>;
+  stream(text: string): AsyncIterable<AgentDomainEvent>;
+  streamText(text: string): AsyncIterable<string>;
+  streamUpdates(text: string): AsyncIterable<AgentRunUpdate>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId$1, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId$1, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+  tryPrompt(text: string): Promise<AgentClientAttempt<AgentPromptResult, unknown>>;
+  tryPromptText(text: string): Promise<AgentClientAttempt<string, unknown>>;
+}
+type AgentTextDeltaCallback = (delta: string) => void | Promise<void>;
+type AgentClientAttempt<T, E = unknown> = AgentClientSuccess<T> | AgentClientFailure<E>;
+interface AgentClientSuccess<T> {
+  readonly ok: true;
+  readonly value: T;
+}
+interface AgentClientFailure<E = unknown> {
+  readonly ok: false;
+  readonly error: E;
+}
+declare function createAgentHarnessClient(harness: AgentHarness): AgentHarnessClient;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-runtime-primitives.d.ts
+type DefaultAgentHarnessOptions = Omit<AgentHarnessOptions, "clock" | "runIds"> & {
+  readonly clock?: AgentClock;
+  readonly runIds?: RunIdGenerator;
+};
+type DefaultAgentHarnessFromCallbackOptions = Omit<DefaultAgentHarnessOptions, "loop">;
+type DefaultAgentHarnessFromTextCallbackOptions = DefaultAgentHarnessFromCallbackOptions;
+type DefaultAgentHarnessClientOptions = DefaultAgentHarnessOptions;
+type DefaultAgentHarnessClientFromCallbackOptions = DefaultAgentHarnessFromCallbackOptions;
+type DefaultAgentHarnessClientFromTextCallbackOptions = DefaultAgentHarnessFromTextCallbackOptions;
+interface DefaultAgentRuntimeSessionOptions {
+  readonly mainSessionKey?: SessionKey;
+}
+interface AgentRuntime {
+  readonly client: AgentHarnessClient;
+  readonly harness: AgentHarness;
+  readonly mainClient: AgentSessionClient;
+  readonly mainSession: AgentSessionHandle;
+  readonly mainSessionKey: SessionKey;
+  forSession(sessionKey: SessionKey): AgentSessionHandle;
+  forSessionClient(sessionKey: SessionKey): AgentSessionClient;
+  prompt(text: string): Promise<AgentPromptResult>;
+  promptText(text: string): Promise<string>;
+  promptTurn(text: string): Promise<AgentTranscriptTurn>;
+  tryPrompt(text: string): Promise<AgentClientAttempt<AgentPromptResult, unknown>>;
+  tryPromptText(text: string): Promise<AgentClientAttempt<string, unknown>>;
+}
+type DefaultAgentRuntimeOptions = DefaultAgentHarnessOptions;
+type DefaultAgentRuntimeFromCallbackOptions = DefaultAgentHarnessFromCallbackOptions;
+type DefaultAgentRuntimeFromTextCallbackOptions = DefaultAgentHarnessFromTextCallbackOptions;
+declare function createDefaultAgentHarness(options: DefaultAgentHarnessOptions): AgentHarness;
+declare function createDefaultAgentHarnessFromCallback(run: AgentLoopCallback, options?: DefaultAgentHarnessFromCallbackOptions): AgentHarness;
+declare function createDefaultAgentHarnessFromTextCallback(generate: TextAgentLoopCallback, options?: DefaultAgentHarnessFromTextCallbackOptions): AgentHarness;
+declare function createDefaultAgentHarnessClient(options: DefaultAgentHarnessClientOptions): AgentHarnessClient;
+declare function createDefaultAgentHarnessClientFromCallback(run: AgentLoopCallback, options?: DefaultAgentHarnessClientFromCallbackOptions): AgentHarnessClient;
+declare function createDefaultAgentHarnessClientFromTextCallback(generate: TextAgentLoopCallback, options?: DefaultAgentHarnessClientFromTextCallbackOptions): AgentHarnessClient;
+declare function createDefaultAgentRuntime(options: DefaultAgentRuntimeOptions, runtimeOptions?: DefaultAgentRuntimeSessionOptions): AgentRuntime;
+declare function createDefaultAgentRuntimeFromCallback(run: AgentLoopCallback, options?: DefaultAgentRuntimeFromCallbackOptions, runtimeOptions?: DefaultAgentRuntimeSessionOptions): AgentRuntime;
+declare function createDefaultAgentRuntimeFromTextCallback(generate: TextAgentLoopCallback, options?: DefaultAgentRuntimeFromTextCallbackOptions, runtimeOptions?: DefaultAgentRuntimeSessionOptions): AgentRuntime;
+declare function createSystemClock(): AgentClock;
+declare function createUuidRunIds(): RunIdGenerator;
+declare function createAgentRuntime(harness: AgentHarness, options?: DefaultAgentRuntimeSessionOptions): AgentRuntime;
+//#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/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/pi/config/pi-model-overrides.d.ts
+interface MergePiProviderBaseUrlOverrideOptions {
+  readonly baseUrl: string;
+  readonly filePath: string;
+  readonly provider: string;
+}
+declare function mergePiProviderBaseUrlOverride(options: MergePiProviderBaseUrlOverrideOptions): Promise<void>;
+//#endregion
+//#region src/modules/inbound-delivery/application/queue/inbound-delivery-queue.d.ts
+interface InboundDeliveryPreparedControl<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/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 = InboundDeliveryPreparedControl<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/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/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/platform/concurrency/periodic-effect-loop.d.ts
+interface PeriodicEffectLoop {
+  running(): boolean;
+  start(): void;
+  stop(): Promise<void>;
+}
+//#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/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/transport/rivus-daemon-transport.d.ts
+interface CompositeRivusDaemonTransportOptions {
+  readonly transports: ReadonlyArray<RivusDaemonTransport>;
+}
+declare function createCompositeRivusDaemonTransport(options: CompositeRivusDaemonTransportOptions): RivusDaemonTransport;
+//#endregion
+//#region src/modules/card-presentation/domain/presentation/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/modules/card-presentation/domain/presentation/card-presentation-lease.d.ts
+declare const DEFAULT_CARD_STREAM_LEASE_MS = 510000;
+//#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/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 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$1;
+    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$1 | 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/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/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/modules/background-session/domain/session/background-session-transitions.d.ts
+interface CreateBackgroundSessionInput {
+  readonly sessionId: BackgroundSessionId;
+  readonly displayName: string;
+  readonly prompt: string;
+  readonly parentRunId: string;
+  readonly sourceMessageId: string;
+  readonly origin: BackgroundSessionOrigin;
+  readonly authority: BackgroundSessionAuthority;
+  readonly now: string;
+}
+declare function createBackgroundSession(input: CreateBackgroundSessionInput): BackgroundSessionState;
+interface ClaimBackgroundSessionInput {
+  readonly lease: BackgroundSessionLease;
+  readonly stepRunId: string;
+  readonly wakeText: string;
+  readonly now: string;
+}
+declare function claimBackgroundSession(state: BackgroundSessionState, input: ClaimBackgroundSessionInput): BackgroundSessionState;
+declare function renewBackgroundSessionLease(state: BackgroundSessionState, lease: BackgroundSessionLease): BackgroundSessionState;
+declare function releaseBackgroundSessionLease(state: BackgroundSessionState): BackgroundSessionState;
+interface SuspendBackgroundSessionInput {
+  readonly wakeAt?: string;
+  readonly reason?: string;
+  readonly now: string;
+}
+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 isBackgroundSessionLeaseExpired(state: BackgroundSessionState, now: string): boolean;
+declare function isBackgroundSessionDue(state: BackgroundSessionState, now: string): boolean;
+//#endregion
+//#region src/modules/project-space/application/workspace/workspace-instructions.d.ts
+interface WorkspaceRootHandle {
+  readonly id: string;
+}
+interface WorkspaceInstructionSource {
+  readonly relativePath: string;
+  readonly digest: string;
+  readonly bytes: number;
+  readonly content: string;
+}
+type WorkspaceInstructionsDiagnosticCode = "workspace-instructions-refresh-required" | "workspace-instructions-source-omitted";
+interface WorkspaceInstructionsDiagnostic {
+  readonly code: WorkspaceInstructionsDiagnosticCode;
+  readonly relativePath?: string;
+  readonly reason: string;
+}
+interface WorkspaceInstructionsRequest {
+  readonly workspaceRoot: WorkspaceRootHandle;
+  readonly workingDirectory: string;
+  readonly targetPath?: string;
+  readonly maxBytes: number;
+  readonly operation?: "read" | "mutate";
+  readonly presentedDigests?: ReadonlyArray<string>;
+}
+interface WorkspaceInstructionsView {
+  readonly sources: ReadonlyArray<WorkspaceInstructionSource>;
+  readonly content: string;
+  readonly digest: string;
+  readonly truncated: boolean;
+  readonly refreshRequired: boolean;
+  readonly diagnostics: ReadonlyArray<WorkspaceInstructionsDiagnostic>;
+}
+declare class InvalidWorkspaceRoot extends Error {
+  readonly name = "InvalidWorkspaceRoot";
+}
+declare class WorkspaceInstructionsSourceError extends Error {
+  readonly relativePath: string;
+  readonly reason: string;
+  readonly name = "WorkspaceInstructionsSourceError";
+  constructor(relativePath: string, reason: string);
+}
+//#endregion
+//#region src/modules/project-space/domain/space/project-space.d.ts
+interface RivusProjectSpaceDeployment {
+  readonly id: string;
+  readonly root: string;
+  readonly workingDirectory: string;
+  readonly skills: {
+    readonly sources: ReadonlyArray<string>;
+  };
+}
+interface ResolvedRivusProjectSpace {
+  readonly id: string;
+  readonly root: string;
+  readonly workingDirectory: string;
+  readonly skillPaths: ReadonlyArray<string>;
+  readonly revision: string;
+}
+declare class InvalidRivusProjectSpace extends Error {
+  readonly name = "InvalidRivusProjectSpace";
+}
+//#endregion
+//#region src/modules/project-space/application/catalog/project-skill-catalog.d.ts
+interface ProjectSkillCatalogEntry {
+  readonly name: string;
+}
+interface ProjectSkillCatalogDiagnostic {
+  readonly message: string;
+  readonly path?: string;
+  readonly type: "warning" | "error" | "collision";
+}
+declare class InvalidProjectSkillCatalog extends Error {
+  readonly name = "InvalidProjectSkillCatalog";
+}
+declare function validateProjectSkillCatalog(input: {
+  readonly diagnostics: ReadonlyArray<ProjectSkillCatalogDiagnostic>;
+  readonly skills: ReadonlyArray<ProjectSkillCatalogEntry>;
+}): ReadonlySet<string>;
+declare function validateProjectSkillCommand(text: string, skillNames: ReadonlySet<string>): void;
+//#endregion
+//#region src/modules/deployment-control/domain/manifest/deployment-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?: ConversationProgressDisplay;
+  readonly required: boolean;
+  readonly sessionNamespace: string;
+  readonly streamMinIntervalMs: number;
+}
+interface RivusEndpointExperimentalFeatures {
+  readonly cotMessages: boolean;
+}
+declare function validateRivusDeploymentManifest(manifest: RivusDeploymentManifest): void;
+//#endregion
+//#region src/modules/deployment-control/application/resolution/deployment-resolution-ports.d.ts
+interface RivusPluginModuleLoadRequest {
+  readonly deploymentRoot: string;
+  readonly module: string;
+  readonly pluginId: string;
+}
+//#endregion
+//#region src/modules/deployment-control/application/resolution/deployment-resolution.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 LoadedRivusDeployment {
+  readonly agents: ReadonlyArray<RivusAgentDeploymentStatus>;
+  readonly automationDefinitions: ReadonlyArray<ResolvedRivusAutomationDefinition>;
+  readonly catalog: RivusPluginCatalog;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly manifest: RivusDeploymentManifest;
+  readonly plugins: ReadonlyArray<RivusPluginLoadStatus>;
+}
+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/modules/deployment-control/application/lifecycle/deployment-control-ports.d.ts
+interface RivusDeploymentBackgroundSessionCancellation {
+  readonly agentId: string;
+  readonly reason?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+}
+//#endregion
+//#region src/modules/deployment-control/domain/lifecycle/deployment-lifecycle.d.ts
+type RivusDeploymentComponentLifecycle = "disabled" | "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+type RivusDeploymentControlLifecycle = "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+//#endregion
+//#region src/modules/deployment-control/application/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 RivusDeploymentDaemonLifecycleError extends Error {
+  readonly name = "RivusDeploymentDaemonLifecycleError";
+}
+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/adapters/deployment/bootstrap/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/composition/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;
+  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/composition/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/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/composition/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$1) => Effect.Effect<void>;
+  readonly inboxRepository?: FeishuInboxRepository;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly loop: AgentLoop;
+  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 FeishuPeriodicFlushSupervisor {
+  withPeriodicFlush<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, unknown, R>;
+}
+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/modules/agent-execution/infrastructure/persistence/event-log/jsonl-agent-event-log.d.ts
+type AgentEventLogOperation = "append" | "read";
+declare class AgentEventLogStoreError {
+  readonly operation: AgentEventLogOperation;
+  readonly cause: unknown;
+  readonly _tag = "AgentEventLogStoreError";
+  constructor(operation: AgentEventLogOperation, cause: unknown);
+}
+interface AgentEventLog extends AgentDomainEventSink {
+  append(event: AgentDomainEvent): Effect.Effect<void, AgentEventLogStoreError>;
+  readAll(): Effect.Effect<ReadonlyArray<AgentDomainEvent>, AgentEventLogStoreError>;
+  readRun(runId: AgentRunId$1): Effect.Effect<ReadonlyArray<AgentDomainEvent>, AgentEventLogStoreError>;
+}
+interface JsonlAgentEventLogOptions {
+  readonly filePath: string;
+}
+declare function createJsonlAgentEventLog(options: JsonlAgentEventLogOptions): AgentEventLog;
+//#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$1;
+  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$1) => 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$1;
+  readonly _tag = "FeishuCardTargetNotFound";
+  constructor(runId: AgentRunId$1);
+}
+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$1): 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/composition/feishu-card-rollover-runtime.d.ts
+interface ConfiguredFeishuCardRolloverRuntimeOptions {
+  readonly agentName?: string;
+  readonly cardTargets: FeishuCardTargetRegistry;
+  /** Whether running cards should include Feishu HTTP callback cancel buttons. */
+  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/composition/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: AgentLoop;
+  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/observability/agent/langfuse-agent-telemetry.d.ts
+type LangfuseTelemetryEnv = Readonly<Record<string, string | undefined>>;
+type LangfuseTelemetryContentMode = "metadata-only" | "redacted";
+interface LangfuseTelemetryConfig {
+  readonly contentMode?: LangfuseTelemetryContentMode;
+  readonly endpoint: string;
+  readonly environment: string;
+  readonly publicKey: string;
+  readonly secretKey: string;
+  readonly serviceName: string;
+}
+interface LangfuseAgentTelemetry {
+  readonly modelContentObserver: AgentModelContentObserver;
+  readonly sink: AgentDomainEventSink;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+declare class LangfuseTelemetryConfigError extends Error {
+  constructor(message: string);
+}
+declare function resolveLangfuseTelemetryConfig(env: LangfuseTelemetryEnv): LangfuseTelemetryConfig | undefined;
+declare function createLangfuseAgentTelemetry(config: LangfuseTelemetryConfig): LangfuseAgentTelemetry;
+//#endregion
+//#region src/adapters/observability/content/telemetry-content-redactor.d.ts
+interface TelemetryContentRedactorOptions {
+  readonly maxArrayItems?: number;
+  readonly maxDepth?: number;
+  readonly maxObjectKeys?: number;
+  readonly maxSerializedLength?: number;
+  readonly maxStringLength?: number;
+}
+type TelemetryContentRedactor = (value: unknown) => string;
+declare function createTelemetryContentRedactor(options?: TelemetryContentRedactorOptions): TelemetryContentRedactor;
+//#endregion
+//#region src/adapters/observability/agent/open-telemetry-agent-event-sink.d.ts
+interface OpenTelemetryAgentEventSinkOptions {
+  readonly captureContent?: boolean;
+  readonly onProjectionError?: (error: unknown, event: AgentDomainEvent) => Promise<void> | void;
+  readonly redactContent?: TelemetryContentRedactor;
+  readonly tracer: Tracer;
+}
+interface OpenTelemetryAgentTelemetry {
+  readonly modelContentObserver: AgentModelContentObserver;
+  readonly sink: AgentDomainEventSink;
+}
+declare function createOpenTelemetryAgentEventSink(options: OpenTelemetryAgentEventSinkOptions): AgentDomainEventSink;
+declare function createOpenTelemetryAgentTelemetry(options: OpenTelemetryAgentEventSinkOptions): OpenTelemetryAgentTelemetry;
+//#endregion
+//#region src/adapters/pi/execution/pi-agent-loop.d.ts
+type PiAgentSessionEvent = PiMessageStartEvent | PiMessageUpdateEvent | PiMessageEndEvent | PiToolExecutionStartEvent | PiToolExecutionUpdateEvent | PiToolExecutionEndEvent | {
+  readonly type: string;
+  readonly [key: string]: unknown;
+};
+interface PiMessageUpdateEvent {
+  readonly type: "message_update";
+  readonly message: unknown;
+  readonly assistantMessageEvent: {
+    readonly type: "text_delta";
+    readonly contentIndex: number;
+    readonly delta: string;
+    readonly partial: unknown;
+  } | {
+    readonly type: "thinking_delta";
+    readonly contentIndex: number;
+    readonly delta: string;
+    readonly partial: unknown;
+  } | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+  };
+}
+interface PiMessageStartEvent {
+  readonly type: "message_start";
+  readonly message: unknown;
+}
+interface PiMessageEndEvent {
+  readonly type: "message_end";
+  readonly message: unknown;
+}
+interface PiToolExecutionStartEvent {
+  readonly type: "tool_execution_start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args?: unknown;
+  readonly input?: unknown;
+}
+interface PiToolExecutionUpdateEvent {
+  readonly type: "tool_execution_update";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args?: unknown;
+  readonly input?: unknown;
+  readonly partialResult: unknown;
+}
+interface PiToolExecutionEndEvent {
+  readonly type: "tool_execution_end";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+}
+interface PiAgentSession {
+  abort?: () => Promise<void> | void;
+  prompt(text: string): Promise<void>;
+  readonly state?: unknown;
+  subscribe(listener: (event: PiAgentSessionEvent) => void): () => void;
+  dispose?: () => Promise<void> | void;
+}
+interface PiCreateAgentSessionResult {
+  readonly session: PiAgentSession;
+}
+interface PiSdkAgentLoopOptions<TSessionOptions = unknown> {
+  readonly createAgentSession: (options: TSessionOptions | undefined) => Promise<PiCreateAgentSessionResult> | PiCreateAgentSessionResult;
+  readonly sessionOptions?: TSessionOptions;
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-agent-loop.d.ts
+interface PiAgentSessionHandle {
+  readonly session: PiAgentSession;
+  readonly resolveToolName?: (toolName: string) => string;
+  readonly preparePrompt?: (input: AgentLoopInput) => Promise<string> | string;
+  readonly dispose?: () => Promise<void> | void;
+  readonly activate?: (input: AgentLoopInput) => Promise<void> | void;
+}
+interface PiAgentLoopOptions {
+  readonly resolveSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+  readonly modelContentObserver?: AgentModelContentObserver;
+  readonly disposeSessionAfterRun?: boolean;
+}
+declare function createPiAgentLoop(options: PiAgentLoopOptions): AgentLoop;
+declare function createPiSdkAgentLoop<TSessionOptions = unknown>(options: PiSdkAgentLoopOptions<TSessionOptions>): AgentLoop;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-session-registry.d.ts
+interface PiSessionRegistryOptions {
+  readonly createSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+}
+interface PiSessionRegistry {
+  disposeAll(): Promise<void>;
+  dispose(sessionKey: SessionKey): Promise<void>;
+  size(): number;
+  resolve(input: AgentLoopInput): Promise<PiAgentSessionHandle>;
+}
+declare function createPiSessionRegistry(options: PiSessionRegistryOptions): PiSessionRegistry;
+//#endregion
+//#region src/adapters/compatibility/run-presentation/run-presentation-projector.d.ts
+interface RunPresentationProjector {
+  apply(event: AgentDomainEvent, canonicalText?: string): RunPresentation | undefined;
+  snapshot(runId: AgentRunId$1): 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$1): 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$1) => 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/testing/fakes.d.ts
+declare function createFixedClock(now: Date): AgentClock;
+declare function createTestClock(initial: Date): AgentClock & {
+  advance(ms: number): void;
+};
+declare function createSequenceRunIds(runIds: ReadonlyArray<AgentRunId$1>): RunIdGenerator;
+//#endregion
+//#region src/adapters/compatibility/agent-catalog/rivus-agent-catalog.d.ts
+declare function resolveRivusAgentDefinition(catalog: RivusPluginCatalog, deployment: RivusAgentDeployment, options?: {
+  readonly backgroundSessions?: boolean;
+}): ResolvedRivusAgentDefinition;
+//#endregion
+//#region src/modules/project-space/infrastructure/space/node-project-space-resolver.d.ts
+declare function resolveRivusProjectSpace(input: {
+  readonly declaration: RivusProjectSpaceDeployment;
+  readonly deploymentRoot: string;
+}): Promise<ResolvedRivusProjectSpace>;
+//#endregion
+//#region src/modules/project-space/infrastructure/workspace/node-workspace-root-registry.d.ts
+declare function createWorkspaceRootHandle(rootPath: string): Promise<WorkspaceRootHandle>;
+//#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 AuthorizationPolicyProvider {
+  current(): Promise<AuthorizationPolicyState>;
+}
+interface ToolApprovalService {
+  consume(request: ToolApprovalRequest): Promise<boolean>;
+}
+interface ToolBrokerOptions {
+  readonly approvals: ToolApprovalService;
+  readonly catalog: RivusPluginCatalog;
+  readonly hostTools?: ReadonlyArray<RivusHostToolDescriptor>;
+  readonly policy: AuthorizationPolicyProvider;
+  readonly operations?: ToolOperationLedger;
+}
+interface ToolExecutionRequest {
+  readonly authority: InvocationAuthorityRef;
+  readonly callId: string;
+  readonly toolId: string;
+  readonly version: string;
+  readonly input: unknown;
+  readonly operationId?: string;
+  readonly approvalId?: string;
+}
+interface ToolBroker {
+  execute(request: ToolExecutionRequest): Promise<unknown>;
+}
+declare function createToolBroker(options: ToolBrokerOptions): ToolBroker;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/jsonl-tool-operation-ledger.d.ts
+declare function openJsonlToolOperationLedger(options: {
+  readonly filePath: string;
+}): Promise<ToolOperationLedger>;
+//#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/composition/agent-harness-pooled-runtime.d.ts
+declare function createAgentHarnessPooledRuntime(harness: AgentHarness): PooledAgentRuntime;
+//#endregion
+//#region src/composition/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/composition/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/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/memory/agent-memory-access.d.ts
+/** Promise-based Memory access required at the host-tool adapter boundary. */
+interface AgentMemoryHandle {
+  readonly namespace: string;
+  readonly scope: MemoryScope;
+  confirm(input: {
+    readonly id: string;
+    readonly expectedRevision: number;
+    readonly conversationSafe?: boolean;
+  }): Promise<MemoryRecord>;
+  forgetRequest(input: {
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly reason?: string;
+  }): Promise<MemoryRecord>;
+  inspect(id: string): Promise<MemoryRecord | undefined>;
+  propose(input: {
+    readonly content: string;
+  }): Promise<MemoryRecord>;
+  read(id: string): Promise<MemoryRecord | undefined>;
+  search(query: MemorySearchQuery): Promise<ReadonlyArray<MemoryRecord>>;
+}
+/** Consumer-owned port implemented by Memory compatibility adapters. */
+interface AgentMemoryService {
+  bind(binding: MemoryBinding): AgentMemoryHandle;
+}
+//#endregion
+//#region src/adapters/compatibility/memory/service/agent-memory-service.d.ts
+interface AgentMemoryServiceOptions {
+  readonly ids?: {
+    readonly next: () => string;
+  };
+  readonly initial?: ReadonlyArray<AgentMemorySnapshot>;
+  readonly persist?: (snapshot: AgentMemorySnapshot) => Promise<void>;
+}
+declare function createAgentMemoryService(options?: AgentMemoryServiceOptions): AgentMemoryService;
+//#endregion
+//#region src/modules/background-session/infrastructure/persistence/session/in-memory-background-session-repository.d.ts
+interface CreateBackgroundSessionRepositoryOptions {
+  readonly initial?: ReadonlyArray<BackgroundSessionState>;
+  readonly persist?: (state: BackgroundSessionState) => Promise<void>;
+}
+declare function createBackgroundSessionRepository(options?: CreateBackgroundSessionRepositoryOptions): BackgroundSessionRepository;
+//#endregion
+//#region src/modules/background-session/infrastructure/persistence/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/agent/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/modules/background-session/infrastructure/persistence/session/jsonl-background-session-repository.d.ts
+declare const BACKGROUND_SESSION_JSONL_VERSION = 1;
+interface OpenJsonlBackgroundSessionRepositoryOptions {
+  readonly filePath: string;
+  readonly compactThreshold?: number;
+}
+declare function openJsonlBackgroundSessionRepository(options: OpenJsonlBackgroundSessionRepositoryOptions): Promise<BackgroundSessionRepository>;
+declare function isBackgroundSessionState(value: unknown): value is BackgroundSessionState;
+//#endregion
+//#region src/modules/background-session/infrastructure/persistence/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/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/adapters/agent/memory/rivus-memory-tool.d.ts
+interface RivusMemoryTool {
+  execute(command: {
+    readonly command: "forget_request";
+    readonly id: string;
+    readonly reason?: string;
+  }): Promise<MemoryTombstoneReceipt>;
+  execute(command: {
+    readonly command: "propose";
+    readonly input: {
+      readonly content: string;
+    };
+    readonly scope?: Exclude<MemoryScope, "shared-user-profile">;
+  }): Promise<MemoryRecord>;
+  execute(command: {
+    readonly command: "read";
+    readonly id: string;
+  }): Promise<MemoryRecord | undefined>;
+  execute(command: {
+    readonly command: "search";
+    readonly query: MemorySearchQuery;
+    readonly scope?: MemoryScope;
+  }): Promise<ReadonlyArray<MemoryRecord>>;
+  replayCompleted(command: unknown, completedResult: unknown): Promise<unknown>;
+}
+interface MemoryTombstoneReceipt {
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope;
+  readonly state: "tombstoned";
+}
+declare function createRivusMemoryTool(memory: AgentMemoryHandle | ReadonlyArray<AgentMemoryHandle>): RivusMemoryTool;
+declare function createRivusMemoryToolDescriptor(options: {
+  readonly memory: AgentMemoryService;
+}): RivusHostToolDescriptor;
+//#endregion
+//#region src/adapters/agent/memory/rivus-memory-tool-contract.d.ts
+declare const RIVUS_MEMORY_TOOL_ID = "memory";
+declare const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
+declare const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
+declare function createRivusMemoryToolContract(scopes: ReadonlyArray<MemoryScope>): Readonly<{
+  description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.";
+  digest: "sha256:rivus-memory-v3";
+  id: "memory";
+  idempotency: "required";
+  inputSchema: Readonly<{
+    additionalProperties: false;
+    properties: {
+      scope?: {
+        description: string;
+        enum: ("conversation" | "agent-private" | "project" | "shared-user-profile")[];
+        type: string;
+      };
+      command: {
+        description: string;
+        enum: string[];
+        type: string;
+      };
+      id: {
+        description: string;
+        minLength: number;
+        type: string;
+      };
+      input: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          content: {
+            minLength: number;
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      query: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          query: {
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      reason: {
+        description: string;
+        type: string;
+      };
+    };
+    required: string[];
+    type: "object";
+  }>;
+  risk: "mutate";
+  version: "1.0.0";
+}>;
+//#endregion
+//#region src/adapters/agent/memory/project-memory-prompt-preparer.d.ts
+interface ProjectMemoryRecallOptions {
+  readonly agentId: string;
+  readonly memory: AgentMemoryService;
+  readonly projectId: string;
+  readonly maxBytes?: number;
+  readonly maxRecords?: number;
+  readonly identity?: ProjectMemoryRecallIdentity;
+}
+interface ProjectMemoryRecallIdentity {
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface ProjectMemoryPromptInput {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly text: string;
+}
+declare function createProjectMemoryPromptPreparer(options: ProjectMemoryRecallOptions): (input: ProjectMemoryPromptInput) => Promise<string>;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/loop/agent-loop-prompt-transformer.d.ts
+declare function createAgentLoopPromptTransformer(options: {
+  readonly loop: AgentLoop;
+  readonly transform: (input: AgentLoopInput) => Promise<string> | string;
+}): AgentLoop;
+//#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/memory/compaction/compaction-service.d.ts
+interface CompactorPort {
+  compact(input: CompactionInput): Promise<string>;
+}
+interface CompactionService {
+  createCandidate(input: CompactionInput): Promise<CompactionSnapshot>;
+  commit(candidateId: string): CompactionSnapshot;
+  current(instanceId: string, conversationId: string): CompactionSnapshot | undefined;
+}
+declare function createCompactionService(options: {
+  readonly compactor: CompactorPort;
+}): CompactionService;
+//#endregion
+//#region src/adapters/compatibility/automation/automation-mandate-store.d.ts
+declare function createAutomationMandateStore(): AutomationMandateStore;
+//#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/modules/automation/infrastructure/persistence/tick/json-automation-tick-repository.d.ts
+interface OpenJsonAutomationTickRepositoryOptions {
+  readonly filePath: string;
+}
+//#endregion
+//#region src/adapters/compatibility/automation/json-automation-tick-repository.d.ts
+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/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
+//#region src/modules/delegation/domain/grant/peer-delegation.d.ts
+interface DelegationEdge {
+  readonly fromAgentId: string;
+  readonly toAgentId: string;
+  readonly toolIds: ReadonlyArray<string>;
+  readonly maxHops: number;
+  readonly maxBudget: number;
+}
+declare class DelegationDenied extends Error {
+  readonly name = "DelegationDenied";
+}
+//#endregion
+//#region src/modules/delegation/application/grant/delegation-service.d.ts
+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/modules/delegation/domain/subagent/subagent-record.d.ts
+interface ChildDelegationRecord {
+  readonly id: string;
+  readonly parentRunId: string;
+  readonly childAgentId: string;
+  readonly status: "active" | "cancelled";
+}
+//#endregion
+//#region src/modules/delegation/application/subagent/subagent-contracts.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 extends ChildDelegationRecord {
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly authority: InvocationAuthorityRef;
+  readonly capabilities: SubagentCapabilities;
+}
+//#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/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/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>;
+  /** Optional control-plane steering; endpoints that do not support it remain prompt-only. */
+  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>;
+}
+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/adapters/compatibility/deployment-control/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/composition/human-interaction-tool-approval-gateway.d.ts
+interface HumanInteractionEndpointRegistry {
+  register(endpointId: string, service: HumanInteractionService): void;
+  resolve(endpointId: string): HumanInteractionService | undefined;
+  services(): ReadonlyArray<HumanInteractionService>;
+}
+declare function createHumanInteractionEndpointRegistry(): HumanInteractionEndpointRegistry;
+declare function createHumanInteractionToolApprovalGateway(options: {
+  readonly clock?: {
+    readonly now: () => string;
+  };
+  readonly expiresAfterMs?: number;
+  readonly registry: HumanInteractionEndpointRegistry;
+}): PiToolApprovalGateway;
+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/modules/human-interaction/infrastructure/persistence/interaction/in-memory-human-interaction-repository.d.ts
+declare function createInMemoryHumanInteractionRepository(): HumanInteractionRepository;
+//#endregion
+//#region src/modules/human-interaction/infrastructure/persistence/interaction/jsonl-human-interaction-repository.d.ts
+interface JsonlHumanInteractionRepositoryOptions {
+  readonly filePath: string;
+}
+declare function createJsonlHumanInteractionRepository(options: JsonlHumanInteractionRepositoryOptions): HumanInteractionRepository;
+//#endregion
+//#region src/adapters/feishu/interaction/human-interaction-card.d.ts
+declare function createFeishuHumanInteractionCard(interaction: HumanInteraction): FeishuRawCardJson;
+//#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/feishu/interaction/human-interaction-presenter.d.ts
+interface FeishuHumanInteractionPresenterOptions {
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+}
+declare function createFeishuHumanInteractionPresenter(options: FeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+//#endregion
+//#region src/adapters/feishu/interaction/configured-human-interaction-presenter.d.ts
+interface ConfiguredFeishuHumanInteractionPresenterOptions {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}
+declare function createConfiguredFeishuHumanInteractionPresenter(options: ConfiguredFeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+//#endregion
+export { DelegationEdge as $, WorkspaceRootHandle as $a, createRecoveryControl as $c, RivusDaemonCliWriter as $i, FeishuMessageIntakeSummary as $l, FeishuCardKitOpenApiClientOptions as $n, FeishuWorkerLoopOptions as $o, createFeishuTenantAccessTokenProvider as $r, createDefaultAgentHarnessClientFromTextCallback as $s, RivusAgentHost as $t, JsonlFeishuCardDeliveryLedgerOptions as $u, CreateRivusDeploymentBackgroundSessionInput as A, RivusAutomationDeliveryTargetType as Aa, SessionSchedulerDisposed as Ac, AgentEventLogStoreError as Ai, FeishuAgentExecution as Al, createConfiguredFeishuCardKitPublisher as An, FeishuCardRolloverEventType as Ao, resolveLangfuseTelemetryConfig as Ar, resolveFeishuEndpointCredentials as As, RivusMemoryTool as At, HumanInteractionRepositoryError as Au, LoadRivusDeploymentOptions as B, ProjectSkillCatalogEntry as Ba, createAgentRuntimePool as Bc, FeishuEventHandlersOptions as Bi, FeishuCardActionCommand as Bl, FeishuCardTargetCreator as Bn, CardPresentationStatus as Bo, ConfiguredFeishuOpenApiRequest as Br, DefaultAgentHarnessClientFromTextCallbackOptions as Bs, openJsonlBackgroundSessionDeliveryStore as Bt, HumanInteractionFact as Bu, createRoutedHumanInteractionToolApprovalService as C, LoadedRivusDeployment as Ca, FetchLikeResponse as Cc, hasInspectableRunProgress as Cd, FeishuWebSocketDaemonOptions as Ci, FeishuAgentDaemonHandleResult as Cl, createFixedClock as Cn, RivusDaemonStatus as Co, createTelemetryContentRedactor as Cr, OpenClawEnvImportOptions as Cs, ProjectMemoryRecallOptions as Ct, ConsumeToolApprovalInput as Cu, LoadRivusDeploymentManifestOptions as D, RivusPluginLoadStatus as Da, createJsonFetchRequest as Dc, createLazyFeishuWebSocketEventDispatcher as Di, FeishuAgentDaemonSessionResetResult as Dl, FeishuPeriodicFlushOptions as Dn, FeishuCardRollover as Do, LangfuseTelemetryContentMode as Dr, formatRivusEnvFile as Ds, RIVUS_MEMORY_TOOL_VERSION as Dt, ResolveHumanInteractionInput as Du, loadRivusDeploymentManifest as E, RivusPluginLoadError as Ea, JsonHttpResponse as Ec, createPresentedValue as Ed, createFeishuWebSocketDaemon as Ei, FeishuAgentDaemonRunResult as El, FeishuPeriodicFlush as En, createRivusDaemonStatusReporter as Eo, LangfuseTelemetryConfigError as Er, createRivusEnvFromOpenClawConfig as Es, RIVUS_MEMORY_TOOL_PLUGIN_ID as Et, HumanInteractionServiceOptions as Eu, RivusDeploymentBackgroundSession as F, RivusEndpointExperimentalFeatures as Fa, AgentRuntimeInput as Fc, FeishuPeriodicFlushSupervisor as Fi, createFeishuAgentDaemon as Fl, RateLimitedFeishuPublisherOptions as Fn, FeishuCardPresentationHandoffStart as Fo, createConfiguredRivusDaemonBootstrap as Fr, RivusTextFileReader as Fs, FeishuBackgroundSessionDeliveryKind as Ft, CancelledHumanInteractionState as Fu, DelegationService as G, RivusProjectSpaceDeployment as Ga, AgentInstanceRegistryOptions as Gc, FeishuCardActionToast as Gi, UnsupportedFeishuCardAction as Gl, FeishuCotProtocolError as Gn, CompositeRivusDaemonTransportOptions as Go, FeishuOpenApiResponse as Gr, DefaultAgentRuntimeFromCallbackOptions as Gs, createBackgroundSessionHostTools as Gt, RejectedHumanInteractionState as Gu, loadRivusDeployment as H, validateProjectSkillCommand as Ha, createAgentInstanceRegistry as Hc, FeishuSdkReceiveMessagePayload as Hi, FeishuCardActionTriggerPayload as Hl, createConfiguredFeishuCardKitTargetCreator as Hn, acceptsCardPresentationProgress as Ho, FeishuOpenApiClient as Hr, DefaultAgentHarnessFromCallbackOptions as Hs, isBackgroundSessionState as Ht, HumanInteractionResolutionAction as Hu, RivusDeploymentDaemon as I, RivusPluginDeclaration as Ia, AgentRuntimePool as Ic, createFeishuAgentRuntime as Ii, FeishuPromptContextInput as Il, createRateLimitedFeishuPublisher as In, FeishuCardPresentationStore as Io, restoreConfiguredRivusDaemonBootstrap as Ir, RivusThinkingLevel as Is, createBackgroundSessionCard as It, ExpiredHumanInteractionState as Iu, SpawnSubagentRequest as J, WorkspaceInstructionsDiagnostic as Ja, OpenJsonFeishuSessionStoreOptions as Jc, FeishuRawCardJson as Ji, FeishuCancelMessageIntakeSummary as Jl, FeishuCotRunPreparation as Jn, RivusDaemonProcessOptions as Jo, FeishuTenantAccessTokenError as Jr, DefaultAgentRuntimeSessionOptions as Js, AgentMemoryServiceOptions as Jt, ToolApprovalInteraction as Ju, createDelegationService as K, InvalidWorkspaceRoot as Ka, AgentInstanceConflict as Kc, createFeishuCardActionCallbackResponse as Ki, createAgentCommandFromFeishuCardAction as Kl, FeishuCotPublisher as Kn, createCompositeRivusDaemonTransport as Ko, createConfiguredFeishuOpenApiClient as Kr, DefaultAgentRuntimeFromTextCallbackOptions as Ks, createBackgroundSessionDeliveryStore as Kt, SelectedHumanInteractionState as Ku, RivusDeploymentEndpoint as L, validateRivusDeploymentManifest as La, AgentRuntimePoolOptions as Lc, FeishuEventHandlerCardActions as Li, FeishuPromptContextResolver as Ll, FeishuCardKitOpenApiTargetCreatorOptions as Ln, DEFAULT_CARD_STREAM_LEASE_MS as Lo, ConfiguredFeishuCardRolloverRuntime as Lr, loadRivusDaemonConfig as Ls, createConfiguredFeishuBackgroundSessionDelivery as Lt, HumanInteraction as Lu, CreateRivusDeploymentEndpointInput as M, RivusBackgroundSessionsDeployment as Ma, SessionSchedulerStatus as Mc, createJsonlAgentEventLog as Mi, FeishuAgentMessageSideEffects as Ml, FeishuCoalescingPublisherOptions as Mn, FeishuCardRolloverOptions as Mo, ConfiguredRivusDaemonBootstrapOptions as Mr, RivusDaemonConfigError as Ms, createRivusMemoryToolDescriptor as Mt, RequestToolApprovalInput as Mu, CreateRivusDeploymentRuntimeInput as N, RivusDeploymentManifest as Na, createSessionScheduler as Nc, FeishuAgentRuntime as Ni, FeishuAgentPreparedControl as Nl, createCoalescingFeishuPublisher as Nn, FeishuCardRolloverStatus as No, ConfiguredRivusDaemonBootstrapRequest as Nr, RivusDaemonConfigLoaderOptions as Ns, FeishuBackgroundSessionDelivery as Nt, RequestUserDecisionInput as Nu, RivusDeploymentManifestError as O, RivusPluginModuleLoadRequest as Oa, SessionScheduler as Oc, AgentEventLog as Oi, FeishuAgentDaemonSkippedResult as Ol, createFeishuPeriodicFlush as On, FeishuCardRolloverCounters as Oo, LangfuseTelemetryEnv as Or, FeishuEndpointCredentialError as Os, createRivusMemoryToolContract as Ot, createHumanInteractionService as Ou, RivusDeploymentAutomation as P, RivusEndpointDeployment as Pa, AgentRuntimeCancellation as Pc, FeishuAgentRuntimeOptions as Pi, FeishuHumanInteractionActions as Pl, FeishuStreamActionPublisher as Pn, createFeishuCardRollover as Po, ConfiguredRivusDaemonBootstrapResponse as Pr, RivusDaemonEnv as Ps, FeishuBackgroundSessionDeliveryInput as Pt, ApprovedHumanInteractionState as Pu, DelegationDenied as Q, WorkspaceInstructionsView as Qa, RecoveryControlOptions as Qc, RivusDaemonCliOptions as Qi, FeishuMessageIntakeOptions as Ql, createFeishuTopicContextResolver as Qn, FeishuWorkerLoop as Qo, FeishuTenantAccessTokenResponse as Qr, createDefaultAgentHarnessClientFromCallback as Qs, InvalidRivusEndpointBinding as Qt, UserDecisionOption as Qu, createRivusDeploymentDaemon as R, InvalidProjectSkillCatalog as Ra, AgentRuntimeSteering as Rc, FeishuEventHandlerQueue as Ri, composeFeishuTopicPrompt as Rl, FeishuCardPresentationBinder as Rn, CardPresentation as Ro, ConfiguredFeishuCardRolloverRuntimeOptions as Rr, AgentRuntime as Rs, resolveFeishuDeliveryChatId as Rt, HumanInteractionActor as Ru, createHumanInteractionToolApprovalGateway as S, RivusDeploymentComponentLifecycle as Sa, FetchLike as Sc, ToolPresentationStep as Sd, FeishuWebSocketDaemon as Si, FeishuAgentDaemonHandleMessageOptions as Sl, resolveRivusAgentDefinition as Sn, createRivusDaemonStatusHttpServer as So, TelemetryContentRedactorOptions as Sr, OpenClawEnvImportError as Ss, ProjectMemoryRecallIdentity as St, transitionHumanInteraction as Su, createConfiguredRivusDeploymentDaemon as T, RivusAgentDeploymentStatus as Ta, JsonHttpRequest as Tc, PresentedValueOptions as Td, FeishuWebSocketRuntime as Ti, FeishuAgentDaemonOptions as Tl, createTestClock as Tn, RivusDaemonStatusReporterOptions as To, LangfuseTelemetryConfig as Tr, RivusEnvFileVariables as Ts, RIVUS_MEMORY_TOOL_ID as Tt, HumanInteractionService as Tu, SubagentCoordinator as U, InvalidRivusProjectSpace as Ua, AgentInstanceBusy as Uc, createFeishuEventHandlers as Ui, FeishuResolveInteractionCommand as Ul, createFeishuCardKitOpenApiTargetCreator as Un, activeCardPresentation as Uo, FeishuOpenApiError as Ur, DefaultAgentHarnessFromTextCallbackOptions as Us, openJsonlBackgroundSessionRepository as Ut, HumanInteractionTransition as Uu, RivusPluginModule as V, validateProjectSkillCatalog as Va, AgentInstanceRegistry as Vc, FeishuReceiveMessageHandlerPayload as Vi, FeishuCardActionIntakeError as Vl, FeishuCardTargetPreparationOptions as Vn, CardPresentationTransitionDenied as Vo, ConfiguredFeishuOpenApiResponse as Vr, DefaultAgentHarnessClientOptions as Vs, BACKGROUND_SESSION_JSONL_VERSION as Vt, HumanInteractionId as Vu, createSubagentCoordinator as W, ResolvedRivusProjectSpace as Wa, AgentRuntimeDisposed as Wc, FeishuCardActionCallbackResponse as Wi, InvalidFeishuCardAction as Wl, createFeishuCardTargetPreparation as Wn, isCardPresentationHandoffDue as Wo, FeishuOpenApiRequest as Wr, DefaultAgentHarnessOptions as Ws, CreateBackgroundSessionHostToolsOptions as Wt, PendingHumanInteractionState as Wu, DelegationGrant as X, WorkspaceInstructionsRequest as Xa, JsonlFeishuInboxRepositoryOptions as Xc, RivusDaemonBootstrapFactory as Xi, FeishuMessageIntakeBaseSummary as Xl, FeishuTopicContextResolverOptions as Xn, RivusDaemonWorkerLoop as Xo, FeishuTenantAccessTokenProviderOptions as Xr, createDefaultAgentHarness as Xs, AgentMemoryHandle as Xt, UserDecisionInteraction as Xu, SubagentRecord as Y, WorkspaceInstructionsDiagnosticCode as Ya, openJsonFeishuSessionStore as Yc, RivusDaemonBootstrapContext as Yi, FeishuCancelRunCommand as Yl, createFeishuCotPublisher as Yn, RivusDaemonTransport as Yo, FeishuTenantAccessTokenProvider as Yr, createAgentRuntime as Ys, createAgentMemoryService as Yt, ToolApprovalInteractionState as Yu, DelegationRequest as Z, WorkspaceInstructionsSourceError as Za, openJsonlFeishuInboxRepository as Zc, RivusDaemonBootstrapModule as Zi, FeishuMessageIntakeError as Zl, InvalidFeishuTopicContext as Zn, createRivusDaemonProcess as Zo, FeishuTenantAccessTokenRequest as Zr, createDefaultAgentHarnessClient as Zs, AgentMemoryService as Zt, UserDecisionInteractionState as Zu, createConfiguredFeishuMessageReactionSender as _, RivusDeploymentDaemonLifecycleError as _a, createAgentDomainEventHandler as _c, RUN_PRESENTATION_SCHEMA_VERSION as _d, FeishuCardKitTextUpdate as _i, InvalidRecoveryAction as _l, createToolBroker as _n, RivusDaemonShutdownSignal as _o, OpenTelemetryAgentEventSinkOptions as _r, FeishuMessageQueueOptions as _s, CompactorPort as _t, InvalidFeishuSessionReference as _u, FEISHU_AGENT_CARD_ELEMENT_ID as a, RivusDeploymentBootstrapContext as aa, createSystemClock as ac, FeishuCardDeliveryRecord as ad, FeishuCardTargetRegistryOperation as ai, FeishuInboxDeliveryState as al, createFeishuPresentationPreparation as an, failBackgroundSessionStep as ao, createRunPresentationProjector as ar, FeishuMessageWorkerDrainAvailableResult as as, PluginStateConflict as at, describeFeishuMessageIntake as au, HumanInteractionEndpointRegistry as b, RivusDeploymentEndpointStatus as ba, AgentHarnessOptions as bc, RunPresentationPhase as bd, FeishuWebSocketClient as bi, FeishuAgentDaemon as bl, createWorkspaceRootHandle as bn, RivusDaemonStatusHttpServer as bo, createOpenTelemetryAgentTelemetry as br, MergePiProviderBaseUrlOverrideOptions as bs, createAgentLoopPromptTransformer as bt, FeishuReceiveMessagePayload as bu, createFeishuAgentRunCard as c, createRivusDeploymentCliProcess as ca, AgentClientFailure as cc, FeishuStreamAction as cd, createInMemoryFeishuCardTargetRegistry as ci, FeishuInboxRepository as cl, createAgentHarnessPooledRuntime as cn, parkBackgroundSessionForReconciliation as co, createPiSessionRegistry as cr, FeishuReceiveMessageReplayOptions as cs, openJsonAutomationTickRepository as ct, UnsupportedFeishuMessage as cu, createJsonlHumanInteractionRepository as d, RivusDeploymentAutomationReadinessError as da, AgentSessionClient as dc, ConversationProgressDisplay as dd, FeishuCardKitClient as di, DeadLetterRecoveryItem as dl, openJsonlToolOperationLedger as dn, requestBackgroundSessionStop as do, createPiAgentLoop as dr, FeishuReceiveRuntimeStatus as ds, ScheduledAutomation as dt, FeishuSessionResetResult as du, RivusDaemonFeishuReplayRunner as ea, createDefaultAgentHarnessFromCallback as ec, openJsonlFeishuCardDeliveryLedger as ed, FeishuCardRolloverSupervisor as ei, ToolOperationLedger as el, RivusAgentHostOptions as en, appendBackgroundSessionInput as eo, createFeishuCardKitOpenApiClient as er, createFeishuWorkerLoop as es, CommitAutomationOutcomeInput as et, FeishuNewSessionCommand as eu, createInMemoryHumanInteractionRepository as f, RivusDeploymentAutomationStatus as fa, AgentTextDeltaCallback as fc, DEFAULT_CONVERSATION_PROGRESS_DISPLAY as fd, FeishuCardKitFail as fi, DeadLetterRequeueResult as fl, AuthorizationPolicyProvider as fn, requeueInterruptedBackgroundSessionStep as fo, createPiSdkAgentLoop as fr, FeishuEndpointGroupPolicy as fs, ScheduledAutomationClock as ft, FeishuSessionStore as fu, FeishuMessageReactionSender as g, RivusDeploymentDaemonLifecycle as ga, AgentRunUpdateCallback as gc, PresentationStepStatus as gd, FeishuCardKitPublisherOptions as gi, ToolOperationResolutionResult as gl, ToolExecutionRequest as gn, RivusDaemonShutdownControllerOptions as go, PiSdkAgentLoopOptions as gr, FeishuMessageQueue as gs, CompactionService as gt, FeishuSessionReference as gu, createConfiguredFeishuAutomationCardSender as h, RivusDeploymentBackgroundSessionStatus as ha, AgentDomainEventSinkCallback as hc, PresentationStep as hd, FeishuCardKitPublisher as hi, ToolOperationRecoveryItem as hl, ToolBrokerOptions as hn, RivusDaemonShutdownController as ho, PiCreateAgentSessionResult as hr, FeishuMessagePreparedControl as hs, createAutomationMandateStore as ht, FeishuConversationReference as hu, createFeishuHumanInteractionPresenter as i, RivusDeploymentBootstrapAdapters as ia, createDefaultAgentRuntimeFromTextCallback as ic, FeishuCardDeliveryReconcilerOptions as id, FeishuCardTargetRegistry as ii, FeishuInboxDelivery as il, FeishuPresentationPreparationOptions as in, createBackgroundSession as io, RunPresentationProjector as ir, createFeishuMessageWorker as is, createDeliveryOutbox as it, createAgentCommandFromFeishuMessage as iu, CreateRivusDeploymentDaemonOptions as j, RivusAutomationDeployment as ja, SessionSchedulerOptions as jc, JsonlAgentEventLogOptions as ji, FeishuAgentExecutionResult as jl, FeishuCoalescingPublisher as jn, FeishuCardRolloverHandoffResult as jo, ConfiguredRivusDaemonBootstrap as jr, RivusDaemonConfig as js, createRivusMemoryTool as jt, HumanInteractionPresenter as ju, CreateRivusDeploymentAutomationInput as k, RivusAutomationDelivery as ka, SessionSchedulerCapacityExceeded as kc, AgentEventLogOperation as ki, FeishuAgentDaemonSteeredResult as kl, ConfiguredFeishuCardKitPublisherOptions as kn, FeishuCardRolloverEvent as ko, createLangfuseAgentTelemetry as kr, FeishuEndpointCredentials as ks, MemoryTombstoneReceipt as kt, HumanInteractionRepository as ku, createFeishuHumanInteractionCard as l, ProcessDeploymentEndpoint as la, AgentClientSuccess as lc, FeishuStreamProjector as ld, createJsonFileFeishuCardTargetRegistry as li, FeishuInboxRepositoryStateOptions as ll, JsonlRecoveryControlOptions as ln, releaseBackgroundSessionLease as lo, PiAgentLoopOptions as lr, FeishuReceiveMessageReplayResult as ls, OpenJsonAutomationTickRepositoryOptions as lt, readFeishuMessageContent as lu, FeishuAutomationCardSender as m, RivusDeploymentBackgroundSessionReadinessError as ma, AgentDomainEventCallback as mc, ModelPresentationStep as md, FeishuCardKitPresentationUpdate as mi, RecoverySnapshot as ml, ToolBroker as mn, suspendBackgroundSession as mo, PiAgentSessionEvent as mr, FeishuMessageDrainResult as ms, createScheduledAutomation as mt, createFeishuSessionStore as mu, createConfiguredFeishuHumanInteractionPresenter as n, RivusDaemonRecoveryRunner as na, createDefaultAgentRuntime as nc, FeishuCardDeliveryLedgerStateOptions as nd, createFeishuCardRolloverSupervisor as ni, FeishuInboxCompletedState as nl, RivusEndpointInput$1 as nn, completeBackgroundSessionStep as no, FeishuCardPresentationStoreOptions as nr, FeishuMessageWorkerOptions as ns, DeliveryOutbox as nt, FeishuPromptAgentCommand as nu, FEISHU_AGENT_CARD_PROGRESS_ELEMENT_ID as o, RivusDeploymentBootstrapFactory as oa, createUuidRunIds as oc, createFeishuCardDeliveryLedger as od, FeishuCardTargetRegistryStoreError as oi, FeishuInboxLeasedState as ol, FeishuDeploymentEndpointOptions as on, isBackgroundSessionDue as oo, PiSessionRegistry as or, FeishuReceiveAcceptedObservation as os, PluginStateStore as ot, FeishuMessageContentInput as ou, FeishuAutomationCardInput as p, RivusDeploymentBackgroundSessionLifecycle as pa, createAgentHarnessClient as pc, AssistantPresentationStep as pd, FeishuCardKitFinish as pi, RecoveryControl as pl, ToolApprovalService as pn, resolveBackgroundSessionReconciliation as po, PiAgentSession as pr, shouldAcceptFeishuEndpointMessage as ps, ScheduledAutomationOptions as pt, FeishuSessionStoreOptions as pu, intersectToolIds as q, WorkspaceInstructionSource as qa, AgentInstanceRecord as qc, createFeishuCardActionErrorResponse as qi, FeishuAgentCommand as ql, FeishuCotPublisherOptions as qn, RivusDaemonProcess as qo, createFeishuOpenApiClient as qr, DefaultAgentRuntimeOptions as qs, createBackgroundSessionRepository as qt, ToolApprovalBinding as qu, FeishuHumanInteractionPresenterOptions as r, runRivusDaemonCli as ra, createDefaultAgentRuntimeFromCallback as rc, FeishuCardDeliveryReconciler as rd, FeishuCardTargetNotFound as ri, FeishuInboxDeadState as rl, createRivusAgentHost as rn, completeBackgroundSessionStop as ro, createFeishuCardPresentationStore as rr, FeishuMessageWorkerQueue as rs, DeliveryOutboxError as rt, FeishuPromptMessageIntakeSummary as ru, FeishuAgentRunCardInput as s, RivusDeploymentCliProcess as sa, AgentClientAttempt as sc, createFeishuCardDeliveryReconciler as sd, JsonFileFeishuCardTargetRegistryOptions as si, FeishuInboxPendingState as sl, createFeishuDeploymentEndpoint as sn, isBackgroundSessionLeaseExpired as so, PiSessionRegistryOptions as sr, FeishuReceiveHandledObservation as ss, createPluginStateStore as st, InvalidFeishuMessageContent as su, ConfiguredFeishuHumanInteractionPresenterOptions as t, RivusDaemonPromptRunner as ta, createDefaultAgentHarnessFromTextCallback as tc, FeishuCardDeliveryLedger as td, FeishuCardRolloverSupervisorOptions as ti, createToolOperationLedger as tl, RivusEndpointDefinition as tn, claimBackgroundSession as to, FeishuCardPresentationNotFound as tr, FeishuMessageWorker as ts, commitAutomationOutcome as tt, FeishuNewSessionMessageIntakeSummary as tu, JsonlHumanInteractionRepositoryOptions as u, RivusDeploymentAutomationLifecycle as ua, AgentHarnessClient as uc, createFeishuStreamProjector as ud, FeishuCardKitCancel as ui, createFeishuInboxRepository as ul, openJsonlRecoveryControl as un, renewBackgroundSessionLease as uo, PiAgentSessionHandle as ur, FeishuReceiveMessageSummary as us, AutomationTickRepositoryCompatibility as ut, FeishuSessionEpochRecord as uu, FeishuTextReplySender as v, RivusDeploymentDaemonStatus as va, createAgentDomainEventSinkFromCallback as vc, ResponsePresentationStep as vd, FeishuCardTarget as vi, RecoveryAction as vl, WorkspaceInstructionsProvider as vn, RivusDaemonSignalSource as vo, OpenTelemetryAgentTelemetry as vr, createFeishuMessageQueue as vs, createCompactionService as vt, createFeishuConversationId as vu, CreateConfiguredRivusDeploymentDaemonOptions as w, ResolvedRivusAutomationDefinition as wa, JsonFetchRequestOptions as wc, PresentedValue as wd, FeishuWebSocketEventDispatcher as wi, FeishuAgentDaemonInteractionResult as wl, createSequenceRunIds as wn, RivusDaemonStatusReporter as wo, LangfuseAgentTelemetry as wr, OpenClawEnvImportResult as ws, createProjectMemoryPromptPreparer as wt, HumanInteractionClock as wu, createHumanInteractionEndpointRegistry as x, RivusDeploymentReadinessError as xa, createAgentHarness as xc, SkillPresentationStep as xd, FeishuWebSocketClientStartOptions as xi, FeishuAgentDaemonCancelResult as xl, resolveRivusProjectSpace as xn, RivusDaemonStatusHttpServerOptions as xo, TelemetryContentRedactor as xr, mergePiProviderBaseUrlOverride as xs, ProjectMemoryPromptInput as xt, HumanInteractionTransitionDenied as xu, createConfiguredFeishuTextReplySender as y, RivusDeploymentEndpointLifecycle as ya, createAgentRunUpdateHandler as yc, RunPresentation as yd, createFeishuCardKitPublisher as yi, createRecoveryAction as yl, createAgentsMdInstructionsProvider as yn, createRivusDaemonShutdownController as yo, createOpenTelemetryAgentEventSink as yr, FeishuMessageAcceptResult as ys, openJsonlAgentMemoryService as yt, createFeishuSessionKey as yu, loadNodeRivusPluginModule as z, ProjectSkillCatalogDiagnostic as za, PooledAgentRuntime as zc, FeishuEventHandlers as zi, FeishuAgentRunPreparation as zl, FeishuCardTargetCreateOptions as zn, CardPresentationChain as zo, createConfiguredFeishuCardRolloverRuntime as zr, DefaultAgentHarnessClientFromCallbackOptions as zs, BACKGROUND_SESSION_DELIVERY_JSONL_VERSION as zt, HumanInteractionBase as zu };