@rivus/agent 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3423 @@
+import { A as RivusToolExecutionContext, B as AgentMemorySnapshot, C as RivusPluginCatalogSnapshot, D as RivusSkillDescriptor, E as RivusResolvedToolDescriptor, F as RivusToolInputRejected, G as MemoryScope, H as MemoryBinding, I as RivusToolRisk, J as RIVUS_MEMORY_TOOL_PLUGIN_ID, K as MemoryState, L as requiresToolApproval, M as RivusToolFactoryContext, N as RivusToolGrantSet, O as RivusSkillGrantSet, P as RivusToolIdempotency, Q as restrictMemoryScopesForAudience, R as AgentMemoryAuthority, S as RivusPluginCatalog, T as RivusPluginRegistry, U as MemoryInvocationAudience, V as MEMORY_SCOPES, W as MemoryRecord, X as createMemoryNamespace, Y as RIVUS_MEMORY_TOOL_VERSION, Z as createRivusMemoryToolContract, _ as RivusAutomationInput, a as assertRivusPluginConforms, b as RivusHostToolDescriptor, c as RIVUS_PLUGIN_API_VERSION, d as RegisteredRivusPlugin, f as RegisteredRivusSkill, g as RivusAgentProfile, h as RivusAgentDeployment, i as RivusPluginLifecycleProbe, j as RivusToolExecutor, k as RivusToolDescriptor, l as RegisteredRivusAgentProfile, m as ResolvedRivusAgentDefinition, n as RivusPluginConformanceInput, o as createFakeRivusPlugin, p as RegisteredRivusTool, q as RIVUS_MEMORY_TOOL_ID, r as RivusPluginConformanceReport, s as InvalidRivusPlugin, t as RivusPluginConformanceError, u as RegisteredRivusAutomation, v as RivusAutomationTemplate, w as RivusPluginManifest, x as RivusPlugin, y as RivusAutomationTickContext, z as AgentMemoryIdentity } from "./rivus-plugin-testkit.js";
+import { Effect, Stream } from "effect";
+import { Tracer } from "@opentelemetry/api";
+import { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+//#region src/domain/agent-invocation.d.ts
+type AgentMemoryInvocationIdentity = AgentMemoryIdentity;
+interface FeishuAgentInvocationOrigin {
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly endpointId: string;
+  readonly kind: "feishu";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+}
+interface LocalCliAgentInvocationOrigin {
+  readonly allowedActorOpenIds: readonly [];
+  readonly endpointId: string;
+  readonly kind: "local-cli";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: "local";
+}
+interface AutomationAgentInvocationOrigin {
+  readonly allowedActorOpenIds: readonly [];
+  readonly automationId: string;
+  readonly endpointId: string;
+  readonly kind: "automation";
+  readonly memory?: AgentMemoryInvocationIdentity;
+  readonly sourceMessageId: string;
+  readonly tenantKey: "automation";
+  readonly tickId: string;
+}
+type AgentInvocationOrigin = FeishuAgentInvocationOrigin | LocalCliAgentInvocationOrigin | AutomationAgentInvocationOrigin;
+//#endregion
+//#region src/domain/agent-events.d.ts
+type AgentRunId = string;
+type SessionKey = string;
+interface AgentRunAccepted {
+  readonly type: "agent_run_accepted";
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly prompt: string;
+  readonly occurredAt: Date;
+}
+interface AgentTurnStarted {
+  readonly type: "agent_turn_started";
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly occurredAt: Date;
+}
+interface AssistantTextDelta {
+  readonly type: "assistant_text_delta";
+  readonly runId: AgentRunId;
+  readonly delta: string;
+  readonly occurredAt: Date;
+}
+interface AssistantThinkingDelta {
+  readonly type: "assistant_thinking_delta";
+  readonly runId: AgentRunId;
+  readonly delta: string;
+  readonly occurredAt: Date;
+}
+interface AgentModelExecutionStarted {
+  readonly type: "agent_model_execution_started";
+  readonly api: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly occurredAt: Date;
+  readonly provider: string;
+  readonly runId: AgentRunId;
+}
+interface AgentModelUsage {
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly cost: number;
+  readonly input: number;
+  readonly output: number;
+  readonly reasoning?: number;
+  readonly total: number;
+}
+interface AgentModelExecutionEnded {
+  readonly type: "agent_model_execution_ended";
+  readonly api: string;
+  readonly errorMessage?: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly occurredAt: Date;
+  readonly provider: string;
+  readonly responseModel?: string;
+  readonly runId: AgentRunId;
+  readonly stopReason: string;
+  readonly usage: AgentModelUsage;
+}
+interface AgentSkillExecutionStarted {
+  readonly type: "agent_skill_execution_started";
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+interface AgentSkillExecutionSucceeded {
+  readonly type: "agent_skill_execution_ended";
+  readonly contentLength: number;
+  readonly digest: string;
+  readonly isError: false;
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly title: string;
+  readonly version: string;
+}
+interface AgentSkillExecutionFailed {
+  readonly type: "agent_skill_execution_ended";
+  readonly isError: true;
+  readonly occurredAt: Date;
+  readonly runId: AgentRunId;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+type AgentSkillExecutionEnded = AgentSkillExecutionSucceeded | AgentSkillExecutionFailed;
+interface AgentToolExecutionStarted {
+  readonly type: "agent_tool_execution_started";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly occurredAt: Date;
+}
+interface AgentToolExecutionUpdated {
+  readonly type: "agent_tool_execution_updated";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult: unknown;
+  readonly occurredAt: Date;
+}
+interface AgentToolExecutionEnded {
+  readonly type: "agent_tool_execution_ended";
+  readonly runId: AgentRunId;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+  readonly occurredAt: Date;
+}
+interface AgentTurnCompleted {
+  readonly type: "agent_turn_completed";
+  readonly runId: AgentRunId;
+  readonly finalText: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunCompleted {
+  readonly type: "agent_run_completed";
+  readonly runId: AgentRunId;
+  readonly finalText: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunFailed {
+  readonly type: "agent_run_failed";
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+  readonly occurredAt: Date;
+}
+interface AgentRunCancelled$1 {
+  readonly type: "agent_run_cancelled";
+  readonly runId: AgentRunId;
+  readonly reason?: string;
+  readonly occurredAt: Date;
+}
+type AgentDomainEvent = AgentRunAccepted | AgentTurnStarted | AssistantTextDelta | AssistantThinkingDelta | AgentModelExecutionStarted | AgentModelExecutionEnded | AgentSkillExecutionStarted | AgentSkillExecutionEnded | AgentToolExecutionStarted | AgentToolExecutionUpdated | AgentToolExecutionEnded | AgentTurnCompleted | AgentRunCompleted | AgentRunFailed | AgentRunCancelled$1;
+type AgentToolExecutionEvent = AgentToolExecutionStarted | AgentToolExecutionUpdated | AgentToolExecutionEnded;
+type AgentModelExecutionEvent = AgentModelExecutionStarted | AgentModelExecutionEnded;
+type TerminalAgentDomainEvent = AgentRunCompleted | AgentRunFailed | AgentRunCancelled$1;
+declare function isAssistantTextDeltaEvent(event: AgentDomainEvent): event is AssistantTextDelta;
+declare function isAssistantThinkingDeltaEvent(event: AgentDomainEvent): event is AssistantThinkingDelta;
+declare function isAgentToolExecutionEvent(event: AgentDomainEvent): event is AgentToolExecutionEvent;
+declare function isTerminalAgentDomainEvent(event: AgentDomainEvent): event is TerminalAgentDomainEvent;
+//#endregion
+//#region src/domain/agent-run-state.d.ts
+type AgentRunPhase = "idle" | "accepted" | "running" | "completed" | "failed" | "cancelled";
+interface AgentRunState {
+  readonly phase: AgentRunPhase;
+  readonly runId?: AgentRunId;
+  readonly sessionKey?: SessionKey;
+  readonly prompt?: string;
+  readonly finalText: string;
+  readonly errorMessage?: string;
+  readonly cancellationReason?: string;
+  readonly thinkingText?: string;
+  readonly skillExecutions: Readonly<Record<string, AgentSkillExecutionState>>;
+  readonly toolExecutions: Readonly<Record<string, AgentToolExecutionState>>;
+}
+interface AgentSkillExecutionState {
+  readonly contentLength?: number;
+  readonly digest?: string;
+  readonly isError?: boolean;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly status: "running" | "completed";
+  readonly title?: string;
+  readonly version?: string;
+}
+interface AgentToolExecutionState {
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult?: unknown;
+  readonly result?: unknown;
+  readonly isError?: boolean;
+  readonly status: "running" | "completed";
+}
+declare const initialAgentRunState: AgentRunState;
+declare function isTerminalAgentRunPhase(phase: AgentRunPhase): boolean;
+declare function evolveAgentRun(state: AgentRunState, event: AgentDomainEvent): AgentRunState;
+//#endregion
+//#region src/domain/agent-history.d.ts
+interface AgentRunSummary {
+  readonly acceptedAt?: Date;
+  readonly cancellationReason?: string;
+  readonly cancelledAt?: Date;
+  readonly completedAt?: Date;
+  readonly errorMessage?: string;
+  readonly eventCount: number;
+  readonly failedToolExecutionCount: number;
+  readonly failedSkillExecutionCount: number;
+  readonly failedAt?: Date;
+  readonly finalText: string;
+  readonly phase: AgentRunPhase;
+  readonly prompt?: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey?: SessionKey;
+  readonly startedAt?: Date;
+  readonly state: AgentRunState;
+  readonly thinkingText: string;
+  readonly skillExecutionCount: number;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+}
+interface AgentSessionSummary {
+  readonly failedToolExecutionCount: number;
+  readonly failedSkillExecutionCount: number;
+  readonly finalText: string;
+  readonly latestPhase: AgentRunPhase;
+  readonly latestRunId: AgentRunId;
+  readonly runCount: number;
+  readonly runIds: ReadonlyArray<AgentRunId>;
+  readonly sessionKey: SessionKey;
+  readonly thinkingText: string;
+  readonly skillExecutionCount: number;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+}
+interface AgentHistory {
+  readonly runs: ReadonlyArray<AgentRunSummary>;
+  readonly sessions: ReadonlyArray<AgentSessionSummary>;
+  readonly totalEvents: number;
+}
+declare function replayAgentHistory(events: ReadonlyArray<AgentDomainEvent>): AgentHistory;
+//#endregion
+//#region src/domain/agent-transcript.d.ts
+interface AgentTranscript {
+  readonly latestTurn?: AgentTranscriptTurn;
+  readonly sessionKey: SessionKey;
+  readonly turnCount: number;
+  readonly turns: ReadonlyArray<AgentTranscriptTurn>;
+}
+interface AgentTranscriptTurn {
+  readonly acceptedAt?: Date;
+  readonly assistantText: string;
+  readonly cancellationReason?: string;
+  readonly cancelledAt?: Date;
+  readonly completedAt?: Date;
+  readonly errorMessage?: string;
+  readonly failedAt?: Date;
+  readonly failedToolExecutionCount: number;
+  readonly phase: AgentRunPhase;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly thinkingText: string;
+  readonly toolExecutionCount: number;
+  readonly updatedAt: Date;
+  readonly userText: string;
+}
+type AgentTranscriptMessageRole = "assistant" | "user";
+interface AgentTranscriptMessage {
+  readonly content: string;
+  readonly role: AgentTranscriptMessageRole;
+}
+interface AgentConversationMessagesOptions {
+  readonly text: string;
+  readonly transcript?: AgentTranscript;
+}
+declare function replayAgentTranscript(events: ReadonlyArray<AgentDomainEvent>, sessionKey: SessionKey): AgentTranscript;
+declare function createAgentTranscriptTurn(summary: AgentRunSummary & {
+  readonly sessionKey: SessionKey;
+}): AgentTranscriptTurn;
+declare function createAgentTranscriptMessages(transcript: AgentTranscript): ReadonlyArray<AgentTranscriptMessage>;
+declare function createAgentConversationMessages(options: AgentConversationMessagesOptions): ReadonlyArray<AgentTranscriptMessage>;
+//#endregion
+//#region src/application/agent/agent-loop.d.ts
+interface AgentLoopInput {
+  readonly abortSignal: AbortSignal;
+  readonly invocation?: AgentInvocationOrigin;
+  readonly messages?: ReadonlyArray<AgentTranscriptMessage>;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+  readonly previousSessionState?: AgentRunState;
+  readonly previousSessionTranscript?: AgentTranscript;
+}
+type AgentLoopEvent = AgentLoopTextDelta | AgentLoopThinkingDelta | AgentLoopModelExecutionStart | AgentLoopModelExecutionEnd | AgentLoopSkillExecutionStart | AgentLoopSkillExecutionEnd | AgentLoopToolExecutionStart | AgentLoopToolExecutionUpdate | AgentLoopToolExecutionEnd;
+type AgentLoopEventLike = AgentLoopEvent | string;
+interface AgentLoopTextDelta {
+  readonly type: "assistant_text_delta";
+  readonly delta: string;
+}
+interface AgentLoopThinkingDelta {
+  readonly type: "assistant_thinking_delta";
+  readonly delta: string;
+}
+interface AgentLoopModelExecutionStart {
+  readonly type: "model_execution_start";
+  readonly api: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly provider: string;
+}
+interface AgentLoopModelExecutionEnd {
+  readonly type: "model_execution_end";
+  readonly api: string;
+  readonly errorMessage?: string;
+  readonly model: string;
+  readonly modelCallId: string;
+  readonly provider: string;
+  readonly responseModel?: string;
+  readonly stopReason: string;
+  readonly usage: AgentModelUsage;
+}
+interface AgentLoopSkillExecutionStart {
+  readonly type: "skill_execution_start";
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+interface AgentLoopSkillExecutionSucceeded {
+  readonly type: "skill_execution_end";
+  readonly contentLength: number;
+  readonly digest: string;
+  readonly isError: false;
+  readonly skillCallId: string;
+  readonly skillId: string;
+  readonly title: string;
+  readonly version: string;
+}
+interface AgentLoopSkillExecutionFailed {
+  readonly type: "skill_execution_end";
+  readonly isError: true;
+  readonly skillCallId: string;
+  readonly skillId: string;
+}
+type AgentLoopSkillExecutionEnd = AgentLoopSkillExecutionSucceeded | AgentLoopSkillExecutionFailed;
+interface AgentLoopToolExecutionStart {
+  readonly type: "tool_execution_start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+}
+interface AgentLoopToolExecutionUpdate {
+  readonly type: "tool_execution_update";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly partialResult: unknown;
+}
+interface AgentLoopToolExecutionEnd {
+  readonly type: "tool_execution_end";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+}
+interface AgentLoop {
+  run(input: AgentLoopInput): Stream.Stream<AgentLoopEvent, unknown>;
+}
+type AgentLoopCallbackOutput = Iterable<AgentLoopEventLike> | AsyncIterable<AgentLoopEventLike> | Stream.Stream<AgentLoopEventLike, unknown>;
+type AgentLoopCallbackResult = AgentLoopCallbackOutput | PromiseLike<AgentLoopCallbackOutput> | Effect.Effect<AgentLoopCallbackOutput, unknown>;
+type AgentLoopCallback = (input: AgentLoopInput) => AgentLoopCallbackResult;
+interface AsyncIterableAgentLoopOptions {
+  readonly run: (input: AgentLoopInput) => AsyncIterable<AgentLoopEventLike>;
+}
+interface EventAgentLoopOptions {
+  readonly events: ReadonlyArray<AgentLoopEventLike> | ((input: AgentLoopInput) => ReadonlyArray<AgentLoopEventLike> | Promise<ReadonlyArray<AgentLoopEventLike>>);
+}
+interface TextAgentLoopOptions {
+  readonly generate: (input: AgentLoopInput) => Effect.Effect<string, unknown>;
+}
+type TextAgentLoopCallback = (input: AgentLoopInput) => string | Promise<string>;
+type AgentLoopToolExecutionStartOptions = Omit<AgentLoopToolExecutionStart, "type">;
+type AgentLoopToolExecutionUpdateOptions = Omit<AgentLoopToolExecutionUpdate, "type">;
+type AgentLoopToolExecutionEndOptions = Omit<AgentLoopToolExecutionEnd, "type">;
+type AgentLoopModelExecutionStartOptions = Omit<AgentLoopModelExecutionStart, "type">;
+type AgentLoopModelExecutionEndOptions = Omit<AgentLoopModelExecutionEnd, "type">;
+type AgentLoopSkillExecutionStartOptions = Omit<AgentLoopSkillExecutionStart, "type">;
+type AgentLoopSkillExecutionEndOptions = Omit<AgentLoopSkillExecutionSucceeded, "type"> | Omit<AgentLoopSkillExecutionFailed, "type">;
+declare function createAgentLoopTextDelta(delta: string): AgentLoopTextDelta;
+declare function createAgentLoopThinkingDelta(delta: string): AgentLoopThinkingDelta;
+declare function createAgentLoopModelExecutionStart(options: AgentLoopModelExecutionStartOptions): AgentLoopModelExecutionStart;
+declare function createAgentLoopModelExecutionEnd(options: AgentLoopModelExecutionEndOptions): AgentLoopModelExecutionEnd;
+declare function createAgentLoopSkillExecutionStart(options: AgentLoopSkillExecutionStartOptions): AgentLoopSkillExecutionStart;
+declare function createAgentLoopSkillExecutionEnd(options: AgentLoopSkillExecutionEndOptions): AgentLoopSkillExecutionEnd;
+declare function createAgentLoopToolExecutionStart(options: AgentLoopToolExecutionStartOptions): AgentLoopToolExecutionStart;
+declare function createAgentLoopToolExecutionUpdate(options: AgentLoopToolExecutionUpdateOptions): AgentLoopToolExecutionUpdate;
+declare function createAgentLoopToolExecutionEnd(options: AgentLoopToolExecutionEndOptions): AgentLoopToolExecutionEnd;
+declare function createEventAgentLoop(options: EventAgentLoopOptions): AgentLoop;
+declare function createAsyncIterableAgentLoop(options: AsyncIterableAgentLoopOptions): AgentLoop;
+declare function createAgentLoopFromCallback(run: AgentLoopCallback): AgentLoop;
+declare function createTextAgentLoop(options: TextAgentLoopOptions): AgentLoop;
+declare function createTextAgentLoopFromCallback(generate: TextAgentLoopCallback): AgentLoop;
+//#endregion
+//#region src/application/agent/agent-harness.d.ts
+interface AgentClock {
+  readonly now: Effect.Effect<Date>;
+}
+interface RunIdGenerator {
+  readonly next: Effect.Effect<AgentRunId>;
+}
+interface AgentHarnessOptions {
+  readonly clock: AgentClock;
+  readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly loop: AgentLoop;
+  readonly runIds: RunIdGenerator;
+}
+interface PromptCommand {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly sessionKey: SessionKey;
+  readonly text: string;
+}
+interface AgentPromptResult {
+  readonly runId: AgentRunId;
+  readonly events: ReadonlyArray<AgentDomainEvent>;
+  readonly finalText: string;
+  readonly runSnapshot: AgentRunSnapshot;
+  readonly snapshot: AgentSessionSnapshot;
+  readonly state: AgentRunState;
+  readonly turn: AgentTranscriptTurn;
+  readonly updates: ReadonlyArray<AgentRunUpdate>;
+}
+interface AgentRunUpdate {
+  readonly event: AgentDomainEvent;
+  readonly previousState?: AgentRunState;
+  readonly state: AgentRunState;
+}
+interface AgentRunSnapshot {
+  readonly events: ReadonlyArray<AgentDomainEvent>;
+  readonly runId: AgentRunId;
+  readonly state?: AgentRunState;
+  readonly summary: AgentRunSummary;
+  readonly updates: ReadonlyArray<AgentRunUpdate>;
+}
+interface ActiveAgentRun {
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+type AgentHarnessAvailability = AgentHarnessIdleAvailability | AgentHarnessBusyAvailability;
+type AgentSessionAvailability = AgentHarnessIdleAvailability | AgentSessionBusyAvailability;
+interface AgentHarnessIdleAvailability {
+  readonly busy: false;
+}
+interface AgentHarnessBusyAvailability {
+  readonly activeRun: ActiveAgentRun;
+  readonly activeRunId: AgentRunId;
+  readonly activeSessionKey: SessionKey;
+  readonly activeState?: AgentRunState;
+  readonly busy: true;
+}
+type AgentSessionBusyAvailability = AgentSessionOwnedBusyAvailability | AgentSessionOtherBusyAvailability;
+interface AgentSessionOwnedBusyAvailability {
+  readonly activeInSession: true;
+  readonly activeRun: ActiveAgentRun;
+  readonly activeRunId: AgentRunId;
+  readonly activeState?: AgentRunState;
+  readonly busy: true;
+}
+interface AgentSessionOtherBusyAvailability {
+  readonly activeInSession: false;
+  readonly busy: true;
+}
+interface AgentSessionSnapshot {
+  readonly availability: AgentSessionAvailability;
+  readonly latestRunSummary?: AgentRunSummary;
+  readonly runs: ReadonlyArray<AgentRunSummary>;
+  readonly sessionKey: SessionKey;
+  readonly state?: AgentRunState;
+  readonly summary?: AgentSessionSummary;
+  readonly transcript: AgentTranscript;
+}
+declare class AgentHarnessBusy {
+  readonly activeRun: ActiveAgentRun;
+  readonly activeState?: AgentRunState | undefined;
+  readonly _tag = "AgentHarnessBusy";
+  readonly activeRunId: AgentRunId;
+  readonly activeSessionKey: SessionKey;
+  constructor(activeRun: ActiveAgentRun, activeState?: AgentRunState | undefined);
+}
+declare class AgentLoopFailed {
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+  readonly cause: unknown;
+  readonly state?: AgentRunState | undefined;
+  readonly _tag = "AgentLoopFailed";
+  constructor(runId: AgentRunId, errorMessage: string, cause: unknown, state?: AgentRunState | undefined);
+}
+declare class AgentEventSinkFailed {
+  readonly runId: AgentRunId;
+  readonly eventType: AgentDomainEvent["type"];
+  readonly cause: unknown;
+  readonly _tag = "AgentEventSinkFailed";
+  constructor(runId: AgentRunId, eventType: AgentDomainEvent["type"], cause: unknown);
+}
+declare class AgentEventHandlerFailed {
+  readonly runId: AgentRunId;
+  readonly eventType: AgentDomainEvent["type"];
+  readonly cause: unknown;
+  readonly state?: AgentRunState | undefined;
+  readonly _tag = "AgentEventHandlerFailed";
+  constructor(runId: AgentRunId, eventType: AgentDomainEvent["type"], cause: unknown, state?: AgentRunState | undefined);
+}
+declare class AgentRunCancelled {
+  readonly runId: AgentRunId;
+  readonly reason: string | undefined;
+  readonly state: AgentRunState;
+  readonly _tag = "AgentRunCancelled";
+  constructor(runId: AgentRunId, reason: string | undefined, state: AgentRunState);
+}
+type AgentHarnessError = AgentHarnessBusy | AgentLoopFailed | AgentEventSinkFailed | AgentEventHandlerFailed | AgentRunCancelled;
+interface AgentHarness {
+  cancelActiveRun(reason?: string): Effect.Effect<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Effect.Effect<boolean>;
+  forSession(sessionKey: SessionKey): AgentSessionHandle;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunId(): AgentRunId | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentHarnessAvailability;
+  getHistory(): AgentHistory;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getSessionHistory(sessionKey: SessionKey): AgentHistory;
+  getSessionLatestRunSnapshot(sessionKey: SessionKey): AgentRunSnapshot | undefined;
+  getSessionLatestRunSummary(sessionKey: SessionKey): AgentRunSummary | undefined;
+  getSessionRuns(sessionKey: SessionKey): ReadonlyArray<AgentRunSummary>;
+  getSessionSnapshot(sessionKey: SessionKey): AgentSessionSnapshot;
+  getSessionSummary(sessionKey: SessionKey): AgentSessionSummary | undefined;
+  getSessionTranscript(sessionKey: SessionKey): AgentTranscript;
+  getSessionState(sessionKey: SessionKey): AgentRunState | undefined;
+  getState(): AgentRunState;
+  prompt(command: PromptCommand): Effect.Effect<AgentPromptResult, AgentHarnessError>;
+  promptRunSnapshot(command: PromptCommand): Effect.Effect<AgentRunSnapshot, AgentHarnessError>;
+  promptSnapshot(command: PromptCommand): Effect.Effect<AgentSessionSnapshot, AgentHarnessError>;
+  promptText(command: PromptCommand): Effect.Effect<string, AgentHarnessError>;
+  promptTurn(command: PromptCommand): Effect.Effect<AgentTranscriptTurn, AgentHarnessError>;
+  promptWithEvents<R>(command: PromptCommand, onEvent: AgentDomainEventHandler<R>): Effect.Effect<AgentPromptResult, AgentHarnessError, R>;
+  promptWithUpdates<R>(command: PromptCommand, onUpdate: AgentRunUpdateHandler<R>): Effect.Effect<AgentPromptResult, AgentHarnessError, R>;
+  stream(command: PromptCommand): Stream.Stream<AgentDomainEvent, AgentHarnessError>;
+  streamText(command: PromptCommand): Stream.Stream<string, AgentHarnessError>;
+  streamUpdates(command: PromptCommand): Stream.Stream<AgentRunUpdate, AgentHarnessError>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+}
+interface AgentSessionHandle {
+  readonly sessionKey: SessionKey;
+  cancelActiveRun(reason?: string): Effect.Effect<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Effect.Effect<boolean>;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentSessionAvailability;
+  getHistory(): AgentHistory;
+  getLatestRunSnapshot(): AgentRunSnapshot | undefined;
+  getLatestRunSummary(): AgentRunSummary | undefined;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRuns(): ReadonlyArray<AgentRunSummary>;
+  getSnapshot(): AgentSessionSnapshot;
+  getSummary(): AgentSessionSummary | undefined;
+  getTranscript(): AgentTranscript;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getState(): AgentRunState | undefined;
+  prompt(text: string): Effect.Effect<AgentPromptResult, AgentHarnessError>;
+  promptRunSnapshot(text: string): Effect.Effect<AgentRunSnapshot, AgentHarnessError>;
+  promptSnapshot(text: string): Effect.Effect<AgentSessionSnapshot, AgentHarnessError>;
+  promptText(text: string): Effect.Effect<string, AgentHarnessError>;
+  promptTurn(text: string): Effect.Effect<AgentTranscriptTurn, AgentHarnessError>;
+  promptWithEvents<R>(text: string, onEvent: AgentDomainEventHandler<R>): Effect.Effect<AgentPromptResult, AgentHarnessError, R>;
+  promptWithUpdates<R>(text: string, onUpdate: AgentRunUpdateHandler<R>): Effect.Effect<AgentPromptResult, AgentHarnessError, R>;
+  stream(text: string): Stream.Stream<AgentDomainEvent, AgentHarnessError>;
+  streamText(text: string): Stream.Stream<string, AgentHarnessError>;
+  streamUpdates(text: string): Stream.Stream<AgentRunUpdate, AgentHarnessError>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+}
+type AgentDomainEventListener = (event: AgentDomainEvent) => void;
+type AgentRunUpdateListener = (update: AgentRunUpdate) => void;
+type AgentDomainEventCallback = (event: AgentDomainEvent) => void | Promise<void>;
+type AgentDomainEventHandler<R = never> = (event: AgentDomainEvent) => Effect.Effect<void, unknown, R>;
+type AgentRunUpdateCallback = (update: AgentRunUpdate) => void | Promise<void>;
+type AgentRunUpdateHandler<R = never> = (update: AgentRunUpdate) => Effect.Effect<void, unknown, R>;
+interface AgentDomainEventSink {
+  append(event: AgentDomainEvent): Effect.Effect<void, unknown>;
+}
+type AgentDomainEventSinkCallback = (event: AgentDomainEvent) => void | Promise<void>;
+declare function createAgentDomainEventSink(append: (event: AgentDomainEvent) => Effect.Effect<void, unknown>): AgentDomainEventSink;
+declare function createAgentDomainEventSinkFromCallback(append: AgentDomainEventSinkCallback): AgentDomainEventSink;
+declare function createAgentDomainEventHandler(handle: AgentDomainEventCallback): AgentDomainEventHandler;
+declare function createAgentRunUpdateHandler(handle: AgentRunUpdateCallback): AgentRunUpdateHandler;
+declare function createAgentHarness(options: AgentHarnessOptions): AgentHarness;
+//#endregion
+//#region src/application/feishu/feishu-stream-projector.d.ts
+type FeishuStreamAction = {
+  readonly type: "update_text";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly type: "finish";
+  readonly runId: AgentRunId;
+  readonly text: string;
+} | {
+  readonly type: "fail";
+  readonly runId: AgentRunId;
+  readonly errorMessage: string;
+} | {
+  readonly type: "cancel";
+  readonly runId: AgentRunId;
+  readonly reason?: string;
+};
+interface FeishuStreamProjector {
+  apply(event: AgentDomainEvent): ReadonlyArray<FeishuStreamAction>;
+  applyUpdate(update: AgentRunUpdate): ReadonlyArray<FeishuStreamAction>;
+}
+declare function createFeishuStreamProjector(): FeishuStreamProjector;
+//#endregion
+//#region src/application/feishu/feishu-card-delivery-ledger.d.ts
+interface FeishuCardDeliveryRecord {
+  readonly revision: number;
+  readonly runId: AgentRunId;
+  readonly sequence: number;
+  readonly terminalPublished: boolean;
+}
+interface FeishuCardDeliveryLedger {
+  isTerminalPublished(runId: AgentRunId): boolean;
+  markTerminal(runId: AgentRunId): Effect.Effect<void, unknown>;
+  reserveSequence(runId: AgentRunId): Effect.Effect<number, unknown>;
+}
+interface FeishuCardDeliveryLedgerStateOptions {
+  readonly initial?: ReadonlyArray<FeishuCardDeliveryRecord>;
+  readonly persist?: (record: FeishuCardDeliveryRecord) => Promise<void>;
+}
+interface FeishuCardDeliveryReconciler {
+  reconcile(): Effect.Effect<{
+    readonly repaired: number;
+    readonly 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/infrastructure/persistence/jsonl-feishu-card-delivery-ledger.d.ts
+interface JsonlFeishuCardDeliveryLedgerOptions {
+  readonly filePath: string;
+}
+declare function openJsonlFeishuCardDeliveryLedger(options: JsonlFeishuCardDeliveryLedgerOptions): Promise<FeishuCardDeliveryLedger>;
+//#endregion
+//#region src/domain/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/domain/human-interaction.d.ts
+type HumanInteractionId = string;
+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: RivusToolRisk;
+  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/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>;
+}
+declare function createInMemoryHumanInteractionRepository(): HumanInteractionRepository;
+//#endregion
+//#region src/application/interaction/human-interaction-service.d.ts
+interface HumanInteractionClock {
+  now(): string;
+}
+interface HumanInteractionPresenter {
+  present(interaction: HumanInteraction): Effect.Effect<void, unknown>;
+}
+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: RivusToolRisk;
+    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;
+}
+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/application/feishu/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<SessionKey, InvalidFeishuSessionReference>;
+declare function createFeishuConversationId(reference: FeishuConversationReference): Effect.Effect<string, InvalidFeishuSessionReference>;
+//#endregion
+//#region src/application/feishu/feishu-message-intake.d.ts
+interface FeishuMessageIntakeOptions {
+  readonly agentId: string;
+}
+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 message_id: string;
+      readonly chat_id: string;
+      readonly chat_type?: string;
+      readonly thread_id?: string;
+      readonly message_type: string;
+      readonly mentions?: ReadonlyArray<{
+        readonly id?: Readonly<Record<string, string>>;
+        readonly key?: string;
+        readonly name?: string;
+      }>;
+      readonly content: string;
+    };
+  };
+}
+interface FeishuPromptAgentCommand {
+  readonly conversationId: string;
+  readonly messageId: string;
+  readonly command: PromptCommand;
+  readonly type: "prompt";
+}
+interface FeishuCancelRunCommand {
+  readonly type: "cancel_run";
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+  readonly reason: string;
+  readonly sessionKey?: SessionKey;
+  readonly token?: string;
+}
+type FeishuAgentCommand = FeishuPromptAgentCommand | FeishuCancelRunCommand;
+type FeishuMessageIntakeSummary = FeishuPromptMessageIntakeSummary | FeishuCancelMessageIntakeSummary;
+interface FeishuMessageIntakeBaseSummary {
+  readonly messageId: string;
+  readonly sessionKey: SessionKey;
+  readonly sessionReference: FeishuSessionReference;
+}
+interface FeishuPromptMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "prompt";
+  readonly text: string;
+}
+interface FeishuCancelMessageIntakeSummary extends FeishuMessageIntakeBaseSummary {
+  readonly commandType: "cancel_run";
+  readonly reason: string;
+  readonly runId: AgentRunId;
+}
+declare class UnsupportedFeishuMessage {
+  readonly messageType: string;
+  readonly _tag = "UnsupportedFeishuMessage";
+  constructor(messageType: string);
+}
+declare class InvalidFeishuMessageContent {
+  readonly reason: string;
+  readonly _tag = "InvalidFeishuMessageContent";
+  constructor(reason: string);
+}
+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/application/feishu/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/application/feishu/feishu-agent-daemon.d.ts
+interface FeishuAgentDaemonBaseOptions {
+  readonly agentId: string;
+  readonly dedupe?: boolean;
+  readonly interactions?: FeishuHumanInteractionActions;
+  readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly publishRunUpdate?: AgentRunUpdateHandler;
+  readonly resolveInvocation?: (payload: FeishuReceiveMessagePayload, conversationId: string) => AgentInvocationOrigin;
+}
+type FeishuAgentDaemonOptions = FeishuAgentDaemonBaseOptions & ({
+  readonly execution: FeishuAgentExecution;
+  readonly harness?: never;
+} | {
+  readonly execution?: never;
+  readonly harness: AgentHarness;
+});
+interface FeishuAgentExecutionResult {
+  readonly finalText: string;
+  readonly runId: AgentRunId;
+}
+interface FeishuAgentExecution {
+  cancelRun(input: {
+    readonly reason: string;
+    readonly runId: AgentRunId;
+    readonly sessionKey?: SessionKey;
+  }): Effect.Effect<boolean, unknown>;
+  promptWithUpdates(command: PromptCommand, onUpdate: AgentRunUpdateHandler): Effect.Effect<FeishuAgentExecutionResult, unknown>;
+}
+interface FeishuAgentRunPreparation {
+  readonly messageId: string;
+  readonly prompt: string;
+  readonly receiveId: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+interface FeishuAgentDaemonRunResult {
+  readonly messageId: string;
+  readonly runId: string;
+  readonly finalText: string;
+}
+interface FeishuAgentDaemonSkippedResult {
+  readonly messageId: string;
+  readonly skipped: true;
+  readonly reason: "duplicate";
+}
+interface FeishuAgentDaemonCancelResult {
+  readonly cancelled: boolean;
+  readonly messageId: string;
+  readonly runId: AgentRunId;
+  readonly reason?: "not_active";
+}
+interface FeishuAgentDaemonInteractionResult {
+  readonly interaction: HumanInteraction;
+  readonly interactionId: string;
+  readonly messageId: string;
+  readonly resolved: true;
+}
+interface FeishuHumanInteractionActions {
+  resolve(input: ResolveHumanInteractionInput): Effect.Effect<HumanInteraction, unknown>;
+}
+type FeishuAgentDaemonHandleResult = FeishuAgentDaemonRunResult | FeishuAgentDaemonSkippedResult | FeishuAgentDaemonCancelResult | FeishuAgentDaemonInteractionResult;
+type FeishuAgentMessageSideEffects = "enabled" | "disabled";
+interface FeishuAgentDaemonHandleMessageOptions {
+  readonly sideEffects?: FeishuAgentMessageSideEffects;
+}
+interface FeishuAgentDaemon {
+  handleCardAction(payload: FeishuCardActionTriggerPayload): Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+  handleMessage(payload: FeishuReceiveMessagePayload, options?: FeishuAgentDaemonHandleMessageOptions): Effect.Effect<FeishuAgentDaemonHandleResult, unknown>;
+}
+declare function createFeishuAgentDaemon(options: FeishuAgentDaemonOptions): FeishuAgentDaemon;
+//#endregion
+//#region src/application/feishu/feishu-inbox-repository.d.ts
+interface FeishuInboxPendingState {
+  readonly availableAt: string;
+  readonly status: "pending";
+}
+interface FeishuInboxLeasedState {
+  readonly leaseExpiresAt: string;
+  readonly leaseId: string;
+  readonly leasedAt: string;
+  readonly status: "leased";
+}
+interface FeishuInboxCompletedState {
+  readonly completedAt: string;
+  readonly status: "completed";
+}
+interface FeishuInboxDeadState {
+  readonly failedAt: string;
+  readonly reason: string;
+  readonly status: "dead";
+}
+type FeishuInboxDeliveryState = FeishuInboxPendingState | FeishuInboxLeasedState | FeishuInboxCompletedState | FeishuInboxDeadState;
+interface FeishuInboxDelivery {
+  readonly acceptedAt: string;
+  readonly attempts: number;
+  readonly id: string;
+  readonly laneKey: string;
+  readonly options?: FeishuAgentDaemonHandleMessageOptions;
+  readonly payload: FeishuReceiveMessagePayload;
+  readonly recovery?: RecoveryAction;
+  readonly revision: number;
+  readonly state: FeishuInboxDeliveryState;
+}
+interface FeishuInboxRepository {
+  admit(delivery: FeishuInboxDelivery, maxPending: number): Effect.Effect<"created" | "duplicate" | "capacity", unknown>;
+  claim(input: {
+    readonly leaseExpiresAt: string;
+    readonly leaseId: string;
+    readonly now: string;
+  }): Effect.Effect<FeishuInboxDelivery | undefined, unknown>;
+  complete(input: {
+    readonly completedAt: string;
+    readonly id: string;
+    readonly leaseId: string;
+  }): Effect.Effect<void, unknown>;
+  create(delivery: FeishuInboxDelivery): Effect.Effect<boolean, unknown>;
+  deadLetters(): ReadonlyArray<FeishuInboxDelivery>;
+  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;
+  requeueDeadLetter(input: {
+    readonly availableAt: string;
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly recovery: RecoveryAction;
+  }): Effect.Effect<FeishuInboxDelivery, unknown>;
+}
+interface FeishuInboxRepositoryStateOptions {
+  readonly initial?: ReadonlyArray<FeishuInboxDelivery>;
+  readonly persist?: (delivery: FeishuInboxDelivery) => Promise<void>;
+}
+declare function createFeishuInboxRepository(options?: FeishuInboxRepositoryStateOptions): FeishuInboxRepository;
+//#endregion
+//#region src/application/delegation/tool-operation-ledger.d.ts
+interface ToolOperationBinding {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly sourceMessageId: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+type ToolOperationState = {
+  readonly status: "pending";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly reason: string;
+  readonly status: "reconciliation-required";
+} | {
+  readonly status: "aborted";
+};
+interface ToolOperationRecord {
+  readonly binding: ToolOperationBinding;
+  readonly operationId: string;
+  readonly reconciliation?: ToolOperationReconciliation;
+  readonly revision: number;
+  readonly state: ToolOperationState;
+}
+interface ToolOperationReconciliation extends RecoveryAction {
+  readonly outcome: "applied" | "not-applied";
+}
+type ToolOperationReconciliationOutcome = {
+  readonly result: unknown;
+  readonly status: "applied";
+} | {
+  readonly status: "not-applied";
+};
+type ToolOperationBeginResult = {
+  readonly status: "acquired";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly status: "blocked";
+  readonly reason: string;
+};
+type ToolOperationInspectResult = {
+  readonly status: "missing";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly status: "blocked";
+  readonly reason: string;
+};
+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/application/recovery/recovery-control.d.ts
+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: ToolOperationReconciliationOutcome;
+  }): Effect.Effect<ToolOperationResolutionResult, unknown>;
+}
+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/infrastructure/persistence/jsonl-feishu-inbox-repository.d.ts
+interface JsonlFeishuInboxRepositoryOptions {
+  readonly filePath: string;
+}
+declare function openJsonlFeishuInboxRepository(options: JsonlFeishuInboxRepositoryOptions): Promise<FeishuInboxRepository>;
+//#endregion
+//#region src/application/host/agent-instance-registry.d.ts
+interface AgentInstanceRecord {
+  readonly agentId: string;
+  readonly binding: AgentInstanceBinding;
+  readonly bindingKey: string;
+  readonly instanceId: string;
+  readonly runtimeGenerationId: string;
+}
+type AgentInstanceBinding = {
+  readonly kind: "endpoint";
+  readonly endpointId: string;
+} | {
+  readonly kind: "automation";
+  readonly automationId: string;
+};
+interface AgentInstanceRegistryOptions {
+  readonly initialRecords?: ReadonlyArray<AgentInstanceRecord>;
+}
+interface AgentInstanceRegistry {
+  resolveAutomation(automationId: string, definition: ResolvedRivusAgentDefinition): AgentInstanceRecord;
+  resolveEndpoint(endpointId: string, definition: ResolvedRivusAgentDefinition): AgentInstanceRecord;
+  snapshot(): ReadonlyArray<AgentInstanceRecord>;
+}
+declare class AgentInstanceConflict extends Error {
+  readonly name = "AgentInstanceConflict";
+}
+declare function createAgentInstanceRegistry(options?: AgentInstanceRegistryOptions): AgentInstanceRegistry;
+//#endregion
+//#region src/application/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 {
+  readonly reason?: string;
+  readonly runId: AgentRunId;
+  readonly sessionKey: SessionKey;
+}
+interface PooledAgentRuntime {
+  readonly concurrency?: "managed";
+  cancel?(input: AgentRuntimeCancellation): 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>;
+  run(instance: AgentInstanceRecord, input: AgentRuntimeInput): Promise<unknown>;
+  disposeAll(): Promise<void>;
+}
+declare class AgentInstanceBusy extends Error {
+  readonly name = "AgentInstanceBusy";
+}
+declare class AgentRuntimeDisposed extends Error {
+  readonly name = "AgentRuntimeDisposed";
+}
+declare function createAgentRuntimePool(options: AgentRuntimePoolOptions): AgentRuntimePool;
+//#endregion
+//#region src/application/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/infrastructure/http/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/application/agent/agent-harness-client.d.ts
+interface AgentHarnessClient {
+  readonly harness: AgentHarness;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Promise<boolean>;
+  forSession(sessionKey: SessionKey): AgentSessionClient;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunId(): AgentRunId | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentHarnessAvailability;
+  getHistory(): AgentHistory;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getSessionHistory(sessionKey: SessionKey): AgentHistory;
+  getSessionLatestRunSnapshot(sessionKey: SessionKey): AgentRunSnapshot | undefined;
+  getSessionLatestRunSummary(sessionKey: SessionKey): AgentRunSummary | undefined;
+  getSessionRuns(sessionKey: SessionKey): ReadonlyArray<AgentRunSummary>;
+  getSessionSnapshot(sessionKey: SessionKey): AgentSessionSnapshot;
+  getSessionSummary(sessionKey: SessionKey): AgentSessionSummary | undefined;
+  getSessionTranscript(sessionKey: SessionKey): AgentTranscript;
+  getSessionState(sessionKey: SessionKey): AgentRunState | undefined;
+  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, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+  tryPrompt(command: PromptCommand): Promise<AgentClientAttempt<AgentPromptResult, unknown>>;
+  tryPromptText(command: PromptCommand): Promise<AgentClientAttempt<string, unknown>>;
+}
+interface AgentSessionClient {
+  readonly handle: AgentSessionHandle;
+  readonly sessionKey: SessionKey;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Promise<boolean>;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentSessionAvailability;
+  getHistory(): AgentHistory;
+  getLatestRunSnapshot(): AgentRunSnapshot | undefined;
+  getLatestRunSummary(): AgentRunSummary | undefined;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRuns(): ReadonlyArray<AgentRunSummary>;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getSnapshot(): AgentSessionSnapshot;
+  getState(): AgentRunState | undefined;
+  getSummary(): AgentSessionSummary | undefined;
+  getTranscript(): AgentTranscript;
+  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, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, 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/infrastructure/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/infrastructure/config/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 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/infrastructure/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/infrastructure/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/application/feishu/feishu-message-queue.d.ts
+interface FeishuMessageQueueOptions {
+  readonly clock?: {
+    readonly now: () => string;
+  };
+  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 repository?: FeishuInboxRepository;
+  readonly retryDelayMs?: number;
+}
+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";
+};
+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/application/feishu/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/application/feishu/feishu-message-worker.d.ts
+interface FeishuMessageWorkerQueue {
+  drainOne(): Effect.Effect<FeishuMessageDrainResult, unknown>;
+  pending(): number;
+}
+interface FeishuMessageWorkerDrainAvailableResult {
+  readonly drained: number;
+  readonly results: ReadonlyArray<Extract<FeishuMessageDrainResult, {
+    readonly handled: true;
+  }>>;
+}
+interface FeishuMessageWorker {
+  drainAvailable(): Effect.Effect<FeishuMessageWorkerDrainAvailableResult, unknown>;
+}
+interface FeishuMessageWorkerOptions {
+  readonly concurrency?: number;
+  readonly queue: FeishuMessageWorkerQueue;
+}
+declare function createFeishuMessageWorker(options: FeishuMessageWorkerOptions): FeishuMessageWorker;
+//#endregion
+//#region src/application/feishu/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>;
+}
+interface FeishuWorkerLoop {
+  running(): boolean;
+  start(): void;
+  stop(): Promise<void>;
+}
+declare function createFeishuWorkerLoop(options: FeishuWorkerLoopOptions): FeishuWorkerLoop;
+//#endregion
+//#region src/application/daemon/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/application/daemon/rivus-daemon-transport.d.ts
+interface CompositeRivusDaemonTransportOptions {
+  readonly transports: ReadonlyArray<RivusDaemonTransport>;
+}
+declare function createCompositeRivusDaemonTransport(options: CompositeRivusDaemonTransportOptions): RivusDaemonTransport;
+//#endregion
+//#region src/application/feishu/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 FeishuReceiveMessageReplayResult {
+  readonly accepted: FeishuMessageAcceptResult;
+  readonly drained: FeishuMessageWorkerDrainAvailableResult;
+  readonly intake: FeishuMessageIntakeSummary;
+}
+//#endregion
+//#region src/application/daemon/rivus-daemon-status.d.ts
+interface RivusDaemonStatus {
+  readonly agentId: string;
+  readonly harness: {
+    readonly activeRunId?: AgentRunId;
+    readonly activeRunState?: AgentRunState;
+    readonly activeSessionKey?: SessionKey;
+    readonly busy: boolean;
+  };
+  readonly history: AgentHistory;
+  readonly process: {
+    readonly running: boolean;
+  };
+  readonly queue: {
+    readonly pending: number;
+  };
+  readonly receive?: FeishuReceiveRuntimeStatus;
+  readonly transport: {
+    readonly running: boolean;
+  };
+  readonly workerLoop: {
+    readonly running: boolean;
+  };
+}
+interface RivusDaemonStatusReporter {
+  status(): Effect.Effect<RivusDaemonStatus, unknown>;
+}
+interface RivusDaemonStatusReporterOptions {
+  readonly activeRun?: () => ActiveAgentRun | undefined;
+  readonly activeRunId?: () => AgentRunId | undefined;
+  readonly activeRunState?: () => AgentRunState | undefined;
+  readonly agentId: string;
+  readonly availability?: () => AgentHarnessAvailability;
+  readonly pending: () => number;
+  readonly processRunning: () => boolean;
+  readonly receiveStatus?: () => FeishuReceiveRuntimeStatus;
+  readonly restoreHistory: () => Effect.Effect<AgentHistory, unknown>;
+  readonly transportRunning: () => boolean;
+  readonly workerLoopRunning: () => boolean;
+}
+declare function createRivusDaemonStatusReporter(options: RivusDaemonStatusReporterOptions): RivusDaemonStatusReporter;
+//#endregion
+//#region src/infrastructure/http/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/application/daemon/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/application/host/rivus-agent-host.d.ts
+interface RivusEndpointDefinition {
+  readonly id: string;
+  readonly agentId: string;
+}
+interface RivusAgentHostOptions {
+  readonly automations?: ReadonlyArray<RivusAutomationDefinition>;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly endpoints: ReadonlyArray<RivusEndpointDefinition>;
+  readonly runtimePool: AgentRuntimePool;
+}
+interface RivusAutomationDefinition {
+  readonly definition: ResolvedRivusAgentDefinition;
+  readonly id: string;
+}
+interface RivusEndpointInput extends AgentRuntimeInput {}
+interface RivusAgentHost {
+  cancelEndpoint(endpointId: string, input: AgentRuntimeCancellation): Promise<boolean>;
+  handleAutomation(automationId: string, input: AgentRuntimeInput): Promise<unknown>;
+  handleEndpoint(endpointId: string, input: RivusEndpointInput): Promise<unknown>;
+  resolveAutomation(automationId: string): AgentInstanceRecord;
+  resolveEndpoint(endpointId: string): AgentInstanceRecord;
+}
+declare class InvalidRivusEndpointBinding extends Error {
+  readonly name = "InvalidRivusEndpointBinding";
+}
+declare function createRivusAgentHost(options: RivusAgentHostOptions): RivusAgentHost;
+//#endregion
+//#region src/application/plugin/rivus-plugin-loader.d.ts
+interface RivusPluginDeclaration {
+  readonly id: string;
+  readonly module: string;
+  readonly required: boolean;
+}
+interface RivusDeploymentManifest {
+  readonly plugins: ReadonlyArray<RivusPluginDeclaration>;
+  readonly agents: ReadonlyArray<RivusAgentDeployment>;
+  readonly automations?: ReadonlyArray<RivusAutomationDeployment>;
+  readonly endpoints: ReadonlyArray<RivusEndpointDeployment>;
+  readonly defaultAgentId: string;
+  readonly defaultEndpointId: string;
+}
+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 id: string;
+  readonly agentId: string;
+  readonly templateId: string;
+  readonly enabled: boolean;
+  readonly required: boolean;
+  readonly schedule: string;
+  readonly timeZone: string;
+  readonly delivery: RivusAutomationDelivery;
+}
+interface RivusEndpointDeployment {
+  readonly id: string;
+  readonly agentId: string;
+  readonly sessionNamespace: string;
+  readonly credentialRef: string;
+  readonly enabled: boolean;
+  readonly experimental?: RivusEndpointExperimentalFeatures;
+  readonly required: boolean;
+  readonly baseUrl: string;
+  readonly streamMinIntervalMs: number;
+  readonly groupPolicy: "mention-only" | "ignore-unmentioned" | "default-responder";
+}
+interface RivusEndpointExperimentalFeatures {
+  readonly cotMessages: boolean;
+}
+interface RivusPluginModuleLoadRequest {
+  readonly deploymentRoot: string;
+  readonly module: string;
+  readonly pluginId: string;
+}
+type RivusPluginModule = RivusPlugin | {
+  readonly default: RivusPlugin | (() => RivusPlugin | Promise<RivusPlugin>);
+};
+interface RivusPluginLoadStatus {
+  readonly id: string;
+  readonly module: string;
+  readonly required: boolean;
+  readonly status: "loaded" | "failed";
+  readonly version?: string;
+  readonly error?: string;
+}
+interface RivusAgentDeploymentStatus {
+  readonly agentId: string;
+  readonly pluginId: string;
+  readonly profileId: string;
+  readonly status: "enabled" | "disabled";
+  readonly reason?: string;
+  readonly definition?: ResolvedRivusAgentDefinition;
+}
+interface LoadedRivusDeployment {
+  readonly manifest: RivusDeploymentManifest;
+  readonly catalog: RivusPluginCatalog;
+  readonly plugins: ReadonlyArray<RivusPluginLoadStatus>;
+  readonly agents: ReadonlyArray<RivusAgentDeploymentStatus>;
+  readonly definitions: ReadonlyArray<ResolvedRivusAgentDefinition>;
+  readonly automationDefinitions: ReadonlyArray<ResolvedRivusAutomationDefinition>;
+}
+interface ResolvedRivusAutomationDefinition extends RivusAutomationDeployment {
+  readonly runtimeDefinition: ResolvedRivusAgentDefinition;
+  readonly template: RegisteredRivusAutomation;
+}
+interface LoadRivusDeploymentOptions {
+  readonly deploymentRoot: string;
+  readonly manifest: RivusDeploymentManifest;
+  readonly loadModule: (request: RivusPluginModuleLoadRequest) => Promise<RivusPluginModule> | RivusPluginModule;
+}
+declare class RivusPluginLoadError extends Error {
+  readonly pluginId: string;
+  readonly moduleSpecifier: string;
+  readonly name = "RivusPluginLoadError";
+  constructor(pluginId: string, moduleSpecifier: string, message: string, options?: ErrorOptions);
+}
+declare function loadRivusDeployment(options: LoadRivusDeploymentOptions): Promise<LoadedRivusDeployment>;
+declare function validateRivusDeploymentManifest(manifest: RivusDeploymentManifest): void;
+//#endregion
+//#region src/application/automation/automation-mandate.d.ts
+interface AutomationBinding {
+  readonly agentId: string;
+  readonly bindingId: string;
+  readonly delivery: AutomationDeliveryBinding;
+  readonly schedule: string;
+  readonly servicePrincipalId: string;
+  readonly skillGrantRevision: string;
+  readonly skillIds: ReadonlyArray<string>;
+  readonly templateId: string;
+  readonly timeZone: string;
+  readonly toolIds: ReadonlyArray<string>;
+}
+interface AutomationDeliveryBinding {
+  readonly endpointId: string;
+  readonly targetKey: string;
+  readonly targetType: "chat_id" | "open_id" | "user_id" | "union_id" | "email";
+}
+interface AutomationMandate extends AutomationBinding {
+  readonly id: string;
+  readonly active: boolean;
+}
+interface AutomationTick {
+  readonly tickId: string;
+  readonly mandateId: string;
+  readonly occurrence: string;
+  readonly claimedBy: string;
+}
+interface AutomationMandateStore {
+  activate(binding: AutomationBinding): AutomationMandate;
+  revoke(id: string): void;
+  claim(id: string, occurrence: string, workerId: string): AutomationTick;
+}
+declare class AutomationMandateError extends Error {
+  readonly name = "AutomationMandateError";
+}
+declare function createAutomationMandateStore(): AutomationMandateStore;
+//#endregion
+//#region src/application/automation/scheduled-automation.d.ts
+type AutomationTickStatus = "running" | "failed" | "generated" | "delivered";
+interface AutomationTickRecord {
+  readonly automationId: string;
+  readonly body?: string;
+  readonly error?: string;
+  readonly occurrence: string;
+  readonly mandateId: string;
+  readonly providerMessageId?: string;
+  readonly revision: number;
+  readonly runId?: string;
+  readonly status: AutomationTickStatus;
+  readonly tickId: string;
+}
+interface AutomationTickRepository {
+  get(mandateId: string, occurrence: string): Promise<AutomationTickRecord | undefined>;
+  put(record: AutomationTickRecord): Promise<AutomationTickRecord>;
+}
+interface ScheduledAutomationRunInput {
+  readonly occurrence: string;
+  readonly sessionKey: string;
+  readonly text: string;
+  readonly tickId: string;
+}
+interface ScheduledAutomationRunResult {
+  readonly body: string;
+  readonly runId: string;
+}
+interface ScheduledAutomationDeliveryInput {
+  readonly body: string;
+  readonly idempotencyKey: string;
+}
+interface ScheduledAutomationOptions {
+  readonly automationId: string;
+  readonly binding: AutomationBinding;
+  readonly clock?: ScheduledAutomationClock;
+  readonly createInput: (tick: RivusAutomationTickContext) => RivusAutomationInput;
+  readonly deliver: (input: ScheduledAutomationDeliveryInput) => Promise<{
+    readonly providerMessageId: string;
+  }>;
+  readonly repository: AutomationTickRepository;
+  readonly onError?: (error: unknown) => Promise<void> | void;
+  readonly retryDelayMs?: number;
+  readonly run: (input: ScheduledAutomationRunInput) => Promise<ScheduledAutomationRunResult>;
+}
+interface ScheduledAutomationClock {
+  now(): Date;
+  sleep(milliseconds: number, signal: AbortSignal): Promise<void>;
+}
+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/application/deployment/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 CreateRivusDeploymentAutomationInput {
+  readonly automationId: string;
+  readonly definition: ResolvedRivusAutomationDefinition;
+  readonly deliveryEndpoint: RivusEndpointDeployment;
+  readonly instanceId: string;
+  readonly run: (input: ScheduledAutomationRunInput) => Promise<unknown>;
+}
+interface CreateRivusDeploymentEndpointInput {
+  readonly agentId: string;
+  readonly cancel: (input: AgentRuntimeCancellation) => Promise<boolean>;
+  readonly endpointId: string;
+  readonly definition: RivusEndpointDeployment;
+  readonly handle: (input: RivusEndpointInput) => Promise<unknown>;
+  readonly instanceId: string;
+}
+interface CreateRivusDeploymentRuntimeInput extends AgentInstanceRecord {
+  readonly catalog: RivusPluginCatalog;
+  readonly definition: ResolvedRivusAgentDefinition;
+}
+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>;
+}
+type RivusDeploymentComponentLifecycle = "disabled" | "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+type RivusDeploymentEndpointLifecycle = RivusDeploymentComponentLifecycle;
+type RivusDeploymentAutomationLifecycle = RivusDeploymentComponentLifecycle;
+interface RivusDeploymentEndpointStatus {
+  readonly agentId: string;
+  readonly endpointId: string;
+  readonly enabled: boolean;
+  readonly required: boolean;
+  readonly running: boolean;
+  readonly lifecycle: RivusDeploymentEndpointLifecycle;
+  readonly error?: string;
+}
+type RivusDeploymentDaemonLifecycle = "stopped" | "starting" | "running" | "degraded" | "stopping" | "cleanup-required";
+interface RivusDeploymentDaemonStatus {
+  readonly running: boolean;
+  readonly ready: boolean;
+  readonly lifecycle: RivusDeploymentDaemonLifecycle;
+  readonly defaultAgentId: string;
+  readonly defaultEndpointId: string;
+  readonly plugins: LoadedRivusDeployment["plugins"];
+  readonly agents: LoadedRivusDeployment["agents"];
+  readonly endpoints: ReadonlyArray<RivusDeploymentEndpointStatus>;
+  readonly automations: ReadonlyArray<RivusDeploymentAutomationStatus>;
+}
+interface RivusDeploymentAutomationStatus {
+  readonly agentId: string;
+  readonly automationId: string;
+  readonly enabled: boolean;
+  readonly required: boolean;
+  readonly running: boolean;
+  readonly lifecycle: RivusDeploymentAutomationLifecycle;
+  readonly error?: string;
+}
+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 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 function createRivusDeploymentDaemon(options: CreateRivusDeploymentDaemonOptions): Promise<RivusDeploymentDaemon>;
+//#endregion
+//#region src/composition/rivus-deployment-cli-process.d.ts
+interface RivusDeploymentBootstrapAdapters {
+  readonly initialInstanceRecords?: AgentInstanceRegistryOptions["initialRecords"];
+  readonly dispose?: () => Promise<void> | void;
+  readonly createAutomation?: (input: CreateRivusDeploymentAutomationInput) => RivusDeploymentAutomation | Promise<RivusDeploymentAutomation>;
+  readonly createRecoveryControl?: () => Promise<RecoveryControl> | RecoveryControl;
+  readonly createRuntime: (input: CreateRivusDeploymentRuntimeInput) => PooledAgentRuntime | Promise<PooledAgentRuntime>;
+  readonly createEndpoint: (input: CreateRivusDeploymentEndpointInput) => RivusDeploymentEndpoint | Promise<RivusDeploymentEndpoint>;
+  readonly replayReceiveMessage?: (handleDefault: (input: RivusEndpointInput) => Promise<unknown>, payload: FeishuReceiveMessagePayload, options?: FeishuReceiveMessageReplayOptions) => Effect.Effect<FeishuReceiveMessageReplayResult, unknown>;
+}
+interface RivusDeploymentBootstrapContext {
+  readonly argv: ReadonlyArray<string>;
+  readonly env: RivusDaemonEnv;
+  readonly manifestPath: 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;
+}
+declare function runRivusDaemonCli(options: RivusDaemonCliOptions): Effect.Effect<number>;
+//#endregion
+//#region src/infrastructure/feishu/feishu-human-interaction-card.d.ts
+interface FeishuRawCardJson {
+  readonly body: {
+    readonly elements: ReadonlyArray<unknown>;
+  };
+  readonly config: {
+    readonly streaming_mode?: boolean;
+    readonly update_multi: true;
+  };
+  readonly header: {
+    readonly template: "blue" | "green" | "grey" | "orange" | "red";
+    readonly title: {
+      readonly content: string;
+      readonly tag: "plain_text";
+    };
+  };
+  readonly schema: "2.0";
+}
+declare function createFeishuHumanInteractionCard(interaction: HumanInteraction): FeishuRawCardJson;
+//#endregion
+//#region src/infrastructure/feishu/feishu-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/infrastructure/feishu/feishu-event-handlers.d.ts
+interface FeishuEventHandlerQueue {
+  accept(payload: FeishuReceiveMessagePayload): Effect.Effect<FeishuMessageAcceptResult, unknown>;
+}
+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 agentId: string;
+  readonly clock: AgentClock;
+  readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly loop: AgentLoop;
+  readonly prepareRun?: (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+  readonly periodicFlush?: FeishuPeriodicFlushSupervisor;
+  readonly publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly runIds: RunIdGenerator;
+}
+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/application/agent/agent-history.d.ts
+interface AgentHistoryEventLog {
+  readAll(): Effect.Effect<ReadonlyArray<AgentDomainEvent>, unknown>;
+}
+declare function restoreAgentHistory(eventLog: AgentHistoryEventLog): Effect.Effect<AgentHistory, unknown>;
+//#endregion
+//#region src/infrastructure/feishu/feishu-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/infrastructure/feishu/feishu-cardkit-publisher.d.ts
+interface FeishuCardTarget {
+  readonly cardId: string;
+  readonly elementId: string;
+}
+interface FeishuCardKitTextUpdate {
+  readonly cardId: string;
+  readonly elementId: string;
+  readonly content: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitFinish {
+  readonly cardId: string;
+  readonly text: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitFail {
+  readonly cardId: string;
+  readonly errorMessage: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitCancel {
+  readonly cardId: string;
+  readonly reason?: string;
+  readonly sequence: number;
+}
+interface FeishuCardKitClient {
+  cancel(request: FeishuCardKitCancel): Effect.Effect<void, unknown>;
+  updateText(request: FeishuCardKitTextUpdate): Effect.Effect<void, unknown>;
+  finish(request: FeishuCardKitFinish): Effect.Effect<void, unknown>;
+  fail(request: FeishuCardKitFail): Effect.Effect<void, unknown>;
+}
+interface FeishuCardKitPublisherOptions {
+  readonly client: FeishuCardKitClient;
+  readonly ledger?: FeishuCardDeliveryLedger;
+  readonly resolveTarget: (runId: AgentRunId) => Effect.Effect<FeishuCardTarget, unknown>;
+}
+interface FeishuCardKitPublisher {
+  publish(action: FeishuStreamAction): Effect.Effect<void, unknown>;
+}
+declare function createFeishuCardKitPublisher(options: FeishuCardKitPublisherOptions): FeishuCardKitPublisher;
+//#endregion
+//#region src/infrastructure/feishu/feishu-card-target-registry.d.ts
+declare class FeishuCardTargetNotFound {
+  readonly runId: AgentRunId;
+  readonly _tag = "FeishuCardTargetNotFound";
+  constructor(runId: AgentRunId);
+}
+type FeishuCardTargetRegistryOperation = "load" | "save";
+declare class FeishuCardTargetRegistryStoreError {
+  readonly operation: FeishuCardTargetRegistryOperation;
+  readonly cause: unknown;
+  readonly _tag = "FeishuCardTargetRegistryStoreError";
+  constructor(operation: FeishuCardTargetRegistryOperation, cause: unknown);
+}
+interface FeishuCardTargetRegistry {
+  bind(runId: AgentRunId, target: FeishuCardTarget): Effect.Effect<void, FeishuCardTargetRegistryStoreError>;
+  release(runId: AgentRunId): Effect.Effect<void, FeishuCardTargetRegistryStoreError>;
+  resolveTarget(runId: AgentRunId): Effect.Effect<FeishuCardTarget, FeishuCardTargetNotFound | FeishuCardTargetRegistryStoreError>;
+  size(): number;
+}
+interface JsonFileFeishuCardTargetRegistryOptions {
+  readonly filePath: string;
+}
+declare function createInMemoryFeishuCardTargetRegistry(): FeishuCardTargetRegistry;
+declare function createJsonFileFeishuCardTargetRegistry(options: JsonFileFeishuCardTargetRegistryOptions): FeishuCardTargetRegistry;
+//#endregion
+//#region src/infrastructure/feishu/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/infrastructure/feishu/feishu-coalescing-publisher.d.ts
+interface FeishuCoalescingPublisher extends FeishuStreamActionPublisher {
+  flush(runId?: AgentRunId): Effect.Effect<void, unknown>;
+}
+interface FeishuCoalescingPublisherOptions {
+  readonly publisher: FeishuStreamActionPublisher;
+}
+declare function createCoalescingFeishuPublisher(options: FeishuCoalescingPublisherOptions): FeishuCoalescingPublisher;
+//#endregion
+//#region src/infrastructure/feishu/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/infrastructure/feishu/feishu-openapi-client.d.ts
+interface FeishuOpenApiRequest {
+  readonly method: "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/infrastructure/persistence/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): Effect.Effect<ReadonlyArray<AgentDomainEvent>, AgentEventLogStoreError>;
+}
+interface JsonlAgentEventLogOptions {
+  readonly filePath: string;
+}
+declare function createJsonlAgentEventLog(options: JsonlAgentEventLogOptions): AgentEventLog;
+//#endregion
+//#region src/composition/rivus-daemon-bootstrap.d.ts
+type ConfiguredRivusDaemonBootstrapRequest = ConfiguredFeishuOpenApiRequest;
+type ConfiguredRivusDaemonBootstrapResponse = ConfiguredFeishuOpenApiResponse;
+interface ConfiguredRivusDaemonBootstrapOptions {
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly clock: AgentClock;
+  readonly config: RivusDaemonConfig;
+  readonly createStatusTransport?: (statusReporter: RivusDaemonStatusReporter) => RivusDaemonTransport;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly eventLog: AgentEventLog;
+  readonly flushIntervalMs?: number;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly loop: AgentLoop;
+  readonly onWorkerError?: (error: unknown) => void | Promise<void>;
+  readonly request: (request: ConfiguredRivusDaemonBootstrapRequest) => Effect.Effect<ConfiguredRivusDaemonBootstrapResponse, unknown>;
+  readonly runIds: RunIdGenerator;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+  readonly websocketClient: FeishuWebSocketClient;
+  readonly workerIntervalMs?: number;
+}
+interface ConfiguredRivusDaemonBootstrap {
+  readonly cardTargets: FeishuCardTargetRegistry;
+  readonly eventLog: AgentEventLog;
+  readonly process: RivusDaemonProcess;
+  readonly publisher: FeishuCoalescingPublisher;
+  readonly runtime: FeishuAgentRuntime;
+  readonly statusReporter: RivusDaemonStatusReporter;
+  readonly transport: RivusDaemonTransport;
+  readonly websocketTransport: FeishuWebSocketDaemon;
+  readonly workerLoop: FeishuWorkerLoop;
+  promptText(command: PromptCommand): Effect.Effect<string, unknown>;
+  restoreHistory(): Effect.Effect<AgentHistory, unknown>;
+  status(): Effect.Effect<RivusDaemonStatus, unknown>;
+}
+declare function restoreConfiguredRivusDaemonBootstrap(options: ConfiguredRivusDaemonBootstrapOptions): Effect.Effect<ConfiguredRivusDaemonBootstrap, unknown>;
+declare function createConfiguredRivusDaemonBootstrap(options: ConfiguredRivusDaemonBootstrapOptions): ConfiguredRivusDaemonBootstrap;
+//#endregion
+//#region src/application/agent/agent-model-content-observer.d.ts
+interface AgentModelInputObservation {
+  readonly input: unknown;
+  readonly modelCallId: string;
+  readonly runId: AgentRunId;
+}
+interface AgentModelOutputObservation {
+  readonly modelCallId: string;
+  readonly output: unknown;
+  readonly runId: AgentRunId;
+}
+interface AgentModelContentObserver {
+  observeInput(observation: AgentModelInputObservation): void;
+  observeOutput(observation: AgentModelOutputObservation): void;
+}
+//#endregion
+//#region src/infrastructure/observability/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/infrastructure/observability/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/infrastructure/observability/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/infrastructure/pi/pi-skill-tool.d.ts
+interface PiSkillRuntime {
+  readonly prompt: string;
+  readonly tool?: ToolDefinition;
+}
+declare function createPiSkillRuntime(skills: ReadonlyArray<RegisteredRivusSkill>): PiSkillRuntime;
+//#endregion
+//#region src/infrastructure/pi/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 PiAgentSessionHandle {
+  readonly activate?: (input: AgentLoopInput) => Promise<void> | void;
+  readonly dispose?: () => Promise<void> | void;
+  readonly resolveToolName?: (toolName: string) => string;
+  readonly session: PiAgentSession;
+}
+interface PiAgentLoopOptions {
+  readonly disposeSessionAfterRun?: boolean;
+  readonly modelContentObserver?: AgentModelContentObserver;
+  readonly resolveSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+}
+interface PiCreateAgentSessionResult {
+  readonly session: PiAgentSession;
+}
+interface PiSdkAgentLoopOptions<TSessionOptions = unknown> {
+  readonly createAgentSession: (options: TSessionOptions | undefined) => Promise<PiCreateAgentSessionResult> | PiCreateAgentSessionResult;
+  readonly sessionOptions?: TSessionOptions;
+}
+declare function createPiAgentLoop(options: PiAgentLoopOptions): AgentLoop;
+declare function createPiSdkAgentLoop<TSessionOptions = unknown>(options: PiSdkAgentLoopOptions<TSessionOptions>): AgentLoop;
+//#endregion
+//#region src/infrastructure/pi/pi-session-registry.d.ts
+interface PiSessionRegistryOptions {
+  readonly createSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+}
+interface PiSessionRegistry {
+  resolve(input: AgentLoopInput): Promise<PiAgentSessionHandle>;
+  size(): number;
+  dispose(sessionKey: SessionKey): Promise<void>;
+  disposeAll(): Promise<void>;
+}
+declare function createPiSessionRegistry(options: PiSessionRegistryOptions): PiSessionRegistry;
+//#endregion
+//#region src/infrastructure/feishu/feishu-cardkit-openapi-client.d.ts
+interface FeishuCardKitOpenApiClientOptions {
+  readonly agentName?: string;
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+}
+declare function createFeishuCardKitOpenApiClient(options: FeishuCardKitOpenApiClientOptions): FeishuCardKitClient;
+//#endregion
+//#region src/infrastructure/feishu/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/infrastructure/feishu/feishu-cardkit-target-preparation.d.ts
+interface FeishuCardTargetCreator {
+  createTarget(run: FeishuAgentRunPreparation): Effect.Effect<FeishuCardTarget, unknown>;
+}
+interface FeishuCardTargetPreparationOptions {
+  readonly createTarget: (run: FeishuAgentRunPreparation) => Effect.Effect<FeishuCardTarget, unknown>;
+  readonly registry: FeishuCardTargetRegistry;
+}
+interface FeishuCardKitOpenApiTargetCreatorOptions {
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+  readonly elementId: string;
+  readonly initialContent?: string;
+  readonly title?: string;
+}
+interface ConfiguredFeishuCardKitTargetPreparationOptions {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+  readonly elementId?: string;
+  readonly initialContent?: string;
+  readonly registry: FeishuCardTargetRegistry;
+  readonly title?: string;
+}
+declare function createFeishuCardTargetPreparation(options: FeishuCardTargetPreparationOptions): (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+declare function createConfiguredFeishuCardKitTargetPreparation(options: ConfiguredFeishuCardKitTargetPreparationOptions): (run: FeishuAgentRunPreparation) => Effect.Effect<void, unknown>;
+declare function createFeishuCardKitOpenApiTargetCreator(options: FeishuCardKitOpenApiTargetCreatorOptions): FeishuCardTargetCreator;
+//#endregion
+//#region src/infrastructure/feishu/feishu-configured-cardkit-publisher.d.ts
+interface ConfiguredFeishuCardKitPublisherOptions {
+  readonly agentName?: string;
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+  readonly ledger?: FeishuCardDeliveryLedger;
+  readonly resolveTarget: (runId: AgentRunId) => Effect.Effect<FeishuCardTarget, unknown>;
+  readonly sleep: (ms: number) => Effect.Effect<void, unknown>;
+}
+declare function createConfiguredFeishuCardKitPublisher(options: ConfiguredFeishuCardKitPublisherOptions): FeishuCoalescingPublisher;
+//#endregion
+//#region src/infrastructure/feishu/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 createSequenceRunIds(runIds: ReadonlyArray<AgentRunId>): RunIdGenerator;
+//#endregion
+//#region src/application/plugin/rivus-plugin-registry.d.ts
+declare function createRivusPluginCatalog(): RivusPluginCatalog;
+declare function resolveRivusAgentDefinition(catalog: RivusPluginCatalog, deployment: RivusAgentDeployment): ResolvedRivusAgentDefinition;
+//#endregion
+//#region src/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>;
+}
+interface WorkspaceInstructionsProvider {
+  resolve(request: WorkspaceInstructionsRequest): Promise<WorkspaceInstructionsView>;
+}
+declare class InvalidWorkspaceRoot extends Error {
+  readonly name = "InvalidWorkspaceRoot";
+}
+declare function createWorkspaceRootHandle(rootPath: string): Promise<WorkspaceRootHandle>;
+//#endregion
+//#region src/infrastructure/workspace/agents-md-instructions-provider.d.ts
+declare class WorkspaceInstructionsSourceError extends Error {
+  readonly relativePath: string;
+  readonly reason: string;
+  readonly name = "WorkspaceInstructionsSourceError";
+  constructor(relativePath: string, reason: string);
+}
+declare function createAgentsMdInstructionsProvider(): WorkspaceInstructionsProvider;
+//#endregion
+//#region src/application/delegation/tool-authority.d.ts
+interface InvocationAuthorityRef {
+  readonly id: string;
+}
+interface InvocationAuthority {
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly memory?: AgentMemoryAuthority;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+declare class InvalidInvocationAuthority extends Error {
+  readonly name = "InvalidInvocationAuthority";
+}
+declare function createInvocationAuthority(authority: InvocationAuthority): InvocationAuthorityRef;
+//#endregion
+//#region src/application/delegation/tool-broker.d.ts
+interface AuthorizationPolicyState {
+  readonly epoch: number;
+  readonly revokedToolIds: ReadonlyArray<string>;
+}
+interface AuthorizationPolicyProvider {
+  current(): Promise<AuthorizationPolicyState>;
+}
+interface ToolApprovalRequest {
+  readonly approvalId: string;
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly inputDigest: string;
+  readonly operationId: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly tenantKey: string;
+  readonly callId: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+  readonly risk: RivusToolRisk;
+}
+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 class ToolInvocationDenied extends Error {
+  readonly name = "ToolInvocationDenied";
+}
+declare function createToolBroker(options: ToolBrokerOptions): ToolBroker;
+//#endregion
+//#region src/infrastructure/persistence/jsonl-tool-operation-ledger.d.ts
+declare function openJsonlToolOperationLedger(options: {
+  readonly filePath: string;
+}): Promise<ToolOperationLedger>;
+//#endregion
+//#region src/infrastructure/persistence/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<CreateRivusDeploymentEndpointInput, "agentId" | "cancel" | "handle"> {
+  readonly botOpenId: string;
+  readonly endpointId?: string;
+  readonly eventDispatcher: FeishuWebSocketEventDispatcher;
+  readonly groupPolicy: FeishuEndpointGroupPolicy;
+  readonly interactions?: FeishuHumanInteractionActions;
+  readonly inboxRepository?: FeishuInboxRepository;
+  readonly maxPendingMessages?: number;
+  readonly memoryTenantId?: 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 publish: (action: FeishuStreamAction) => Effect.Effect<void, unknown>;
+  readonly publishRunUpdate?: AgentRunUpdateHandler;
+  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): RivusDeploymentEndpoint;
+//#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/application/memory/agent-memory.d.ts
+interface MemorySearchQuery {
+  readonly query: string;
+}
+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>>;
+}
+interface AgentMemoryService {
+  bind(binding: MemoryBinding): AgentMemoryHandle;
+}
+interface AgentMemoryServiceOptions {
+  readonly ids?: {
+    readonly next: () => string;
+  };
+  readonly initial?: ReadonlyArray<AgentMemorySnapshot>;
+  readonly persist?: (snapshot: AgentMemorySnapshot) => Promise<void>;
+}
+declare class AgentMemoryError extends Error {
+  readonly name = "AgentMemoryError";
+}
+declare function createAgentMemoryService(options?: AgentMemoryServiceOptions): AgentMemoryService;
+//#endregion
+//#region src/application/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/infrastructure/persistence/jsonl-agent-memory-service.d.ts
+declare function openJsonlAgentMemoryService(options: {
+  readonly filePath: string;
+}): Promise<AgentMemoryService>;
+//#endregion
+//#region src/application/memory/context-assembler.d.ts
+type AgentContextLayerKind = "host-safety" | "system-prompt" | "managed-instructions" | "workspace-instructions" | "tool-schema" | "skill" | "memory" | "compaction" | "transcript" | "current-input";
+interface AgentContextLayer {
+  readonly kind: AgentContextLayerKind;
+  readonly content: string;
+}
+interface AgentContextInput {
+  readonly hostSafety: string;
+  readonly systemPrompt: string;
+  readonly managedInstructions?: string;
+  readonly workspaceInstructions?: ReadonlyArray<string>;
+  readonly toolSchemas: ReadonlyArray<string>;
+  readonly skills?: ReadonlyArray<string>;
+  readonly memory?: ReadonlyArray<string>;
+  readonly compaction?: string;
+  readonly transcript?: ReadonlyArray<string>;
+  readonly currentInput: string;
+  readonly maxBytes: number;
+}
+interface AssembledAgentContext {
+  readonly layers: ReadonlyArray<AgentContextLayer>;
+  readonly omittedKinds: ReadonlyArray<AgentContextLayerKind>;
+  readonly bytes: number;
+}
+declare class AgentContextBudgetExceeded extends Error {
+  readonly name = "AgentContextBudgetExceeded";
+}
+declare function assembleAgentContext(input: AgentContextInput): AssembledAgentContext;
+//#endregion
+//#region src/application/memory/compaction.d.ts
+interface CompactionInput {
+  readonly tenantId: string;
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly conversationId: string;
+  readonly profileRevision: string;
+  readonly watermark: number;
+  readonly transcript: ReadonlyArray<string>;
+}
+interface CompactorPort {
+  compact(input: CompactionInput): Promise<string>;
+}
+interface CompactionSnapshot extends Omit<CompactionInput, "transcript"> {
+  readonly id: string;
+  readonly summary: string;
+}
+interface CompactionService {
+  createCandidate(input: CompactionInput): Promise<CompactionSnapshot>;
+  commit(candidateId: string): CompactionSnapshot;
+  current(instanceId: string, conversationId: string): CompactionSnapshot | undefined;
+}
+declare class CompactionError extends Error {
+  readonly name = "CompactionError";
+}
+declare function createCompactionService(options: {
+  readonly compactor: CompactorPort;
+}): CompactionService;
+//#endregion
+//#region src/application/automation/daily-automation-schedule.d.ts
+interface DailyAutomationSchedule {
+  currentOccurrence(now: Date): string | undefined;
+  nextOccurrence(now: Date): Date;
+}
+declare function createDailyAutomationSchedule(expression: string, timeZone: string, now?: Date): DailyAutomationSchedule;
+//#endregion
+//#region src/infrastructure/persistence/json-automation-tick-repository.d.ts
+interface OpenJsonAutomationTickRepositoryOptions {
+  readonly filePath: string;
+}
+declare function openJsonAutomationTickRepository(options: OpenJsonAutomationTickRepositoryOptions): Promise<AutomationTickRepository>;
+//#endregion
+//#region src/application/automation/plugin-state.d.ts
+interface PluginStateRecord {
+  readonly pluginId: string;
+  readonly agentId: string;
+  readonly key: string;
+  readonly value: unknown;
+  readonly revision: number;
+}
+interface PutPluginState {
+  readonly pluginId: string;
+  readonly agentId: string;
+  readonly key: string;
+  readonly value: unknown;
+  readonly expectedRevision: number;
+}
+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/application/automation/delivery-outbox.d.ts
+type AutomationOutcome = {
+  readonly kind: "suppressed";
+} | {
+  readonly kind: "report" | "alert";
+  readonly body: string;
+  readonly target: string;
+};
+type DeliveryJobStatus = "pending" | "delivered" | "reconciliation-required";
+interface DeliveryJob {
+  readonly id: string;
+  readonly tickId: string;
+  readonly kind: "report" | "alert";
+  readonly body: string;
+  readonly target: string;
+  readonly status: DeliveryJobStatus;
+  readonly receiptId?: string;
+}
+interface DeliveryOutbox {
+  enqueue(job: Omit<DeliveryJob, "status">): DeliveryJob;
+  recordAttempt(id: string, result: {
+    readonly kind: "delivered";
+    readonly providerMessageId: string;
+  } | {
+    readonly kind: "uncertain";
+  }): DeliveryJob;
+  snapshot(): ReadonlyArray<DeliveryJob>;
+}
+interface CommitAutomationOutcomeInput {
+  readonly tickId: string;
+  readonly outcome: AutomationOutcome;
+  readonly state: PluginStateStore;
+  readonly stateUpdate: PutPluginState;
+  readonly outbox: DeliveryOutbox;
+}
+interface CommittedAutomationOutcome {
+  readonly state: PluginStateRecord;
+  readonly job?: DeliveryJob;
+}
+declare class DeliveryOutboxError extends Error {
+  readonly name = "DeliveryOutboxError";
+}
+declare function createDeliveryOutbox(): DeliveryOutbox;
+declare function commitAutomationOutcome(input: CommitAutomationOutcomeInput): CommittedAutomationOutcome;
+//#endregion
+//#region src/application/delegation/delegation-service.d.ts
+interface DelegationEdge {
+  readonly fromAgentId: string;
+  readonly toAgentId: string;
+  readonly toolIds: ReadonlyArray<string>;
+  readonly maxHops: number;
+  readonly maxBudget: number;
+}
+interface DelegationRequest {
+  readonly callerAuthority: InvocationAuthorityRef;
+  readonly targetAgentId: string;
+  readonly targetInstanceId: string;
+  readonly targetToolGrantSet: RivusToolGrantSet;
+  readonly requestedToolIds: ReadonlyArray<string>;
+  readonly hopCount: number;
+  readonly budget: number;
+}
+interface DelegationGrant {
+  readonly id: string;
+  readonly request: DelegationRequest;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly authority: InvocationAuthorityRef;
+}
+interface DelegationService {
+  delegate(request: DelegationRequest): DelegationGrant;
+}
+declare class DelegationDenied extends Error {
+  readonly name = "DelegationDenied";
+}
+declare function createDelegationService(options: {
+  readonly edges: ReadonlyArray<DelegationEdge>;
+}): DelegationService;
+declare function intersectToolIds(sets: ReadonlyArray<ReadonlyArray<string>>): RivusToolGrantSet;
+//#endregion
+//#region src/application/delegation/subagent-coordinator.d.ts
+interface SpawnSubagentRequest {
+  readonly parentAuthority: InvocationAuthorityRef;
+  readonly childAgentId: string;
+  readonly childProfileToolIds: ReadonlyArray<string>;
+  readonly childDeploymentToolIds: ReadonlyArray<string>;
+  readonly requestedToolIds: ReadonlyArray<string>;
+}
+interface SubagentRecord {
+  readonly id: string;
+  readonly parentRunId: string;
+  readonly childAgentId: string;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly authority: InvocationAuthorityRef;
+  readonly capabilities: {
+    readonly senderIdentity: false;
+    readonly privateMemory: false;
+    readonly shell: false;
+  };
+  readonly status: "active" | "cancelled";
+}
+interface SubagentCoordinator {
+  spawn(request: SpawnSubagentRequest): SubagentRecord;
+  cancelParent(parentRunId: string): void;
+  get(id: string): SubagentRecord | undefined;
+}
+declare function createSubagentCoordinator(): SubagentCoordinator;
+//#endregion
+//#region src/infrastructure/plugin/node-rivus-plugin-module-loader.d.ts
+declare function loadNodeRivusPluginModule(request: RivusPluginModuleLoadRequest): Promise<RivusPluginModule>;
+//#endregion
+//#region src/infrastructure/config/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);
+}
+declare function loadRivusDeploymentManifest(manifestPath: string, options?: LoadRivusDeploymentManifestOptions): Promise<RivusDeploymentManifest>;
+//#endregion
+//#region src/infrastructure/runtime/configured-rivus-deployment-daemon.d.ts
+type CreateConfiguredRivusDeploymentDaemonOptions = Omit<CreateRivusDeploymentDaemonOptions, "deploymentRoot" | "loadModule" | "manifest"> & {
+  readonly manifestPath: string;
+  readonly manifestOptions?: LoadRivusDeploymentManifestOptions;
+};
+declare function createConfiguredRivusDeploymentDaemon(options: CreateConfiguredRivusDeploymentDaemonOptions): Promise<RivusDeploymentDaemon>;
+//#endregion
+//#region src/domain/human-interaction-transition.d.ts
+declare class HumanInteractionTransitionDenied extends Error {
+  readonly name = "HumanInteractionTransitionDenied";
+}
+declare function transitionHumanInteraction(interaction: HumanInteraction, transition: HumanInteractionTransition): HumanInteraction;
+//#endregion
+//#region src/application/delegation/tool-input-digest.d.ts
+declare class InvalidStableJson extends Error {
+  readonly name: string;
+}
+declare class InvalidToolInput extends InvalidStableJson {
+  readonly name = "InvalidToolInput";
+}
+declare function createToolInputDigest(input: unknown): string;
+declare function normalizeStableJson(value: unknown): unknown;
+//#endregion
+//#region src/infrastructure/pi/pi-tool-proxy.d.ts
+interface PiToolApprovalRequest {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly approvalId: string;
+  readonly callId: string;
+  readonly endpointId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly risk: RivusToolRisk;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly signal?: AbortSignal;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface PiToolApprovalGateway {
+  requestApproval(request: PiToolApprovalRequest): Promise<void>;
+}
+interface PiToolProxyOptions {
+  readonly agentId: string;
+  readonly approvals: PiToolApprovalGateway;
+  readonly broker: ToolBroker;
+  readonly getActiveInput: () => AgentLoopInput | undefined;
+  readonly instanceId: string;
+  readonly memoryScopes?: ReadonlyArray<MemoryScope>;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+}
+declare function createPiToolProxyDefinitions(options: PiToolProxyOptions): ToolDefinition[];
+declare function createPiToolNameResolver(tools: ReadonlyArray<Pick<RivusResolvedToolDescriptor, "id">>): (toolName: string) => string;
+//#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/infrastructure/feishu/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/infrastructure/feishu/feishu-markdown-message-sender.d.ts
+interface FeishuMarkdownMessageInput {
+  readonly idempotencyKey: string;
+  readonly markdown: string;
+  readonly receiveId: string;
+  readonly receiveIdType: RivusAutomationDeliveryTargetType;
+}
+interface FeishuMarkdownMessageSender {
+  send(input: FeishuMarkdownMessageInput): Effect.Effect<{
+    readonly providerMessageId: string;
+  }, unknown>;
+}
+declare function createConfiguredFeishuMarkdownMessageSender(options: {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}): FeishuMarkdownMessageSender;
+//#endregion
+//#region src/infrastructure/persistence/jsonl-human-interaction-repository.d.ts
+interface JsonlHumanInteractionRepositoryOptions {
+  readonly filePath: string;
+}
+declare function createJsonlHumanInteractionRepository(options: JsonlHumanInteractionRepositoryOptions): HumanInteractionRepository;
+//#endregion
+//#region src/infrastructure/feishu/feishu-agent-run-card.d.ts
+type FeishuAgentRunCardInput = {
+  readonly agentName: string;
+  readonly elementId?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly status: "running";
+  readonly text?: string;
+} | {
+  readonly agentName: string;
+  readonly status: "completed";
+  readonly text: string;
+} | {
+  readonly agentName: string;
+  readonly status: "cancelled" | "failed";
+};
+declare function createFeishuAgentRunCard(input: FeishuAgentRunCardInput): FeishuRawCardJson;
+//#endregion
+//#region src/infrastructure/feishu/feishu-human-interaction-presenter.d.ts
+interface FeishuHumanInteractionPresenterOptions {
+  readonly baseUrl?: string;
+  readonly client: FeishuOpenApiClient;
+}
+declare function createFeishuHumanInteractionPresenter(options: FeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+//#endregion
+//#region src/infrastructure/feishu/feishu-configured-human-interaction-presenter.d.ts
+interface ConfiguredFeishuHumanInteractionPresenterOptions {
+  readonly client: FeishuOpenApiClient;
+  readonly config: RivusDaemonConfig;
+}
+declare function createConfiguredFeishuHumanInteractionPresenter(options: ConfiguredFeishuHumanInteractionPresenterOptions): HumanInteractionPresenter;
+//#endregion
+export { type ActiveAgentRun, type AgentClientAttempt, type AgentClientFailure, type AgentClientSuccess, type AgentClock, AgentContextBudgetExceeded, type AgentContextInput, type AgentContextLayer, type AgentContextLayerKind, type AgentConversationMessagesOptions, type AgentDomainEvent, type AgentDomainEventCallback, type AgentDomainEventHandler, type AgentDomainEventListener, type AgentDomainEventSink, type AgentDomainEventSinkCallback, AgentEventHandlerFailed, type AgentEventLog, type AgentEventLogOperation, AgentEventLogStoreError, AgentEventSinkFailed, type AgentHarness, type AgentHarnessAvailability, AgentHarnessBusy, type AgentHarnessBusyAvailability, type AgentHarnessClient, type AgentHarnessError, type AgentHarnessIdleAvailability, type AgentHarnessOptions, type AgentHistory, type AgentHistoryEventLog, AgentInstanceBusy, AgentInstanceConflict, type AgentInstanceRecord, type AgentInstanceRegistry, type AgentInstanceRegistryOptions, type AgentInvocationOrigin, type AgentLoop, type AgentLoopCallback, type AgentLoopCallbackOutput, type AgentLoopCallbackResult, type AgentLoopEvent, type AgentLoopEventLike, AgentLoopFailed, type AgentLoopInput, type AgentLoopModelExecutionEnd, type AgentLoopModelExecutionEndOptions, type AgentLoopModelExecutionStart, type AgentLoopModelExecutionStartOptions, type AgentLoopSkillExecutionEnd, type AgentLoopSkillExecutionEndOptions, type AgentLoopSkillExecutionStart, type AgentLoopSkillExecutionStartOptions, type AgentLoopTextDelta, type AgentLoopThinkingDelta, type AgentLoopToolExecutionEnd, type AgentLoopToolExecutionEndOptions, type AgentLoopToolExecutionStart, type AgentLoopToolExecutionStartOptions, type AgentLoopToolExecutionUpdate, type AgentLoopToolExecutionUpdateOptions, type AgentMemoryAuthority, AgentMemoryError, type AgentMemoryHandle, type AgentMemoryIdentity, type AgentMemoryService, type AgentMemoryServiceOptions, type AgentMemorySnapshot, type AgentModelContentObserver, type AgentModelExecutionEnded, type AgentModelExecutionEvent, type AgentModelExecutionStarted, type AgentModelInputObservation, type AgentModelOutputObservation, type AgentModelUsage, type AgentPromptResult, type AgentRunAccepted, AgentRunCancelled, type AgentRunCancelled$1 as AgentRunCancelledEvent, type AgentRunCompleted, type AgentRunFailed, type AgentRunId, type AgentRunPhase, type AgentRunSnapshot, type AgentRunState, type AgentRunSummary, type AgentRunUpdate, type AgentRunUpdateCallback, type AgentRunUpdateHandler, type AgentRunUpdateListener, type AgentRuntime, type AgentRuntimeCancellation, AgentRuntimeDisposed, type AgentRuntimeInput, type AgentRuntimePool, type AgentRuntimePoolOptions, type AgentSessionAvailability, type AgentSessionBusyAvailability, type AgentSessionClient, type AgentSessionHandle, type AgentSessionOtherBusyAvailability, type AgentSessionOwnedBusyAvailability, type AgentSessionSnapshot, type AgentSessionSummary, type AgentSkillExecutionEnded, type AgentSkillExecutionStarted, type AgentSkillExecutionState, type AgentTextDeltaCallback, type AgentToolExecutionEnded, type AgentToolExecutionEvent, type AgentToolExecutionStarted, type AgentToolExecutionUpdated, type AgentTranscript, type AgentTranscriptMessage, type AgentTranscriptMessageRole, type AgentTranscriptTurn, type AgentTurnCompleted, type AgentTurnStarted, type ApprovedHumanInteractionState, type AssembledAgentContext, type AssistantTextDelta, type AssistantThinkingDelta, type AsyncIterableAgentLoopOptions, type AuthorizationPolicyProvider, type AuthorizationPolicyState, type AutomationAgentInvocationOrigin, type AutomationBinding, type AutomationDeliveryBinding, type AutomationMandate, AutomationMandateError, type AutomationMandateStore, type AutomationOutcome, type AutomationTick, type AutomationTickRecord, type AutomationTickRepository, type AutomationTickStatus, type CancelledHumanInteractionState, type CommitAutomationOutcomeInput, type CommittedAutomationOutcome, CompactionError, type CompactionInput, type CompactionService, type CompactionSnapshot, type CompactorPort, type CompositeRivusDaemonTransportOptions, type ConfiguredFeishuCardKitPublisherOptions, type ConfiguredFeishuCardKitTargetPreparationOptions, type ConfiguredFeishuHumanInteractionPresenterOptions, type ConfiguredFeishuOpenApiRequest, type ConfiguredFeishuOpenApiResponse, type ConfiguredRivusDaemonBootstrap, type ConfiguredRivusDaemonBootstrapOptions, type ConfiguredRivusDaemonBootstrapRequest, type ConfiguredRivusDaemonBootstrapResponse, type ConsumeToolApprovalInput, type CreateConfiguredRivusDeploymentDaemonOptions, type CreateRivusDeploymentAutomationInput, type CreateRivusDeploymentDaemonOptions, type CreateRivusDeploymentEndpointInput, type CreateRivusDeploymentRuntimeInput, type DailyAutomationSchedule, type DeadLetterRecoveryItem, type DeadLetterRequeueResult, type DefaultAgentHarnessClientFromCallbackOptions, type DefaultAgentHarnessClientFromTextCallbackOptions, type DefaultAgentHarnessClientOptions, type DefaultAgentHarnessFromCallbackOptions, type DefaultAgentHarnessFromTextCallbackOptions, type DefaultAgentHarnessOptions, type DefaultAgentRuntimeFromCallbackOptions, type DefaultAgentRuntimeFromTextCallbackOptions, type DefaultAgentRuntimeOptions, type DefaultAgentRuntimeSessionOptions, DelegationDenied, type DelegationEdge, type DelegationGrant, type DelegationRequest, type DelegationService, type DeliveryJob, type DeliveryJobStatus, type DeliveryOutbox, DeliveryOutboxError, type EventAgentLoopOptions, type ExpiredHumanInteractionState, type FeishuAgentCommand, type FeishuAgentDaemon, type FeishuAgentDaemonCancelResult, type FeishuAgentDaemonHandleMessageOptions, type FeishuAgentDaemonHandleResult, type FeishuAgentDaemonInteractionResult, type FeishuAgentDaemonOptions, type FeishuAgentDaemonRunResult, type FeishuAgentDaemonSkippedResult, type FeishuAgentExecution, type FeishuAgentExecutionResult, type FeishuAgentInvocationOrigin, type FeishuAgentMessageSideEffects, type FeishuAgentRunCardInput, type FeishuAgentRunPreparation, type FeishuAgentRuntime, type FeishuAgentRuntimeOptions, type FeishuCancelMessageIntakeSummary, type FeishuCancelRunCommand, type FeishuCardActionCallbackResponse, type FeishuCardActionCommand, type FeishuCardActionIntakeError, type FeishuCardActionToast, type FeishuCardActionTriggerPayload, type FeishuCardDeliveryLedger, type FeishuCardDeliveryLedgerStateOptions, type FeishuCardDeliveryReconciler, type FeishuCardDeliveryReconcilerOptions, type FeishuCardDeliveryRecord, type FeishuCardKitCancel, type FeishuCardKitClient, type FeishuCardKitFail, type FeishuCardKitFinish, type FeishuCardKitOpenApiClientOptions, type FeishuCardKitOpenApiTargetCreatorOptions, type FeishuCardKitPublisher, type FeishuCardKitPublisherOptions, type FeishuCardKitTextUpdate, type FeishuCardTarget, type FeishuCardTargetCreator, FeishuCardTargetNotFound, type FeishuCardTargetPreparationOptions, type FeishuCardTargetRegistry, type FeishuCardTargetRegistryOperation, FeishuCardTargetRegistryStoreError, type FeishuCoalescingPublisher, type FeishuCoalescingPublisherOptions, type FeishuConversationReference, FeishuCotProtocolError, type FeishuCotPublisher, type FeishuCotPublisherOptions, type FeishuCotRunPreparation, type FeishuDeploymentEndpointOptions, FeishuEndpointCredentialError, type FeishuEndpointCredentials, type FeishuEndpointGroupPolicy, type FeishuEventHandlerCardActions, type FeishuEventHandlerQueue, type FeishuEventHandlers, type FeishuEventHandlersOptions, type FeishuHumanInteractionActions, type FeishuHumanInteractionPresenterOptions, type FeishuInboxCompletedState, type FeishuInboxDeadState, type FeishuInboxDelivery, type FeishuInboxDeliveryState, type FeishuInboxLeasedState, type FeishuInboxPendingState, type FeishuInboxRepository, type FeishuInboxRepositoryStateOptions, type FeishuMarkdownMessageInput, type FeishuMarkdownMessageSender, type FeishuMessageAcceptResult, type FeishuMessageDrainResult, type FeishuMessageIntakeBaseSummary, type FeishuMessageIntakeError, type FeishuMessageIntakeOptions, type FeishuMessageIntakeSummary, type FeishuMessageQueue, type FeishuMessageQueueOptions, type FeishuMessageWorker, type FeishuMessageWorkerDrainAvailableResult, type FeishuMessageWorkerOptions, type FeishuMessageWorkerQueue, type FeishuOpenApiClient, FeishuOpenApiError, type FeishuOpenApiRequest, type FeishuOpenApiResponse, type FeishuPeriodicFlush, type FeishuPeriodicFlushOptions, type FeishuPeriodicFlushSupervisor, type FeishuPresentationPreparationOptions, type FeishuPromptAgentCommand, type FeishuPromptMessageIntakeSummary, type FeishuRawCardJson, type FeishuReceiveAcceptedObservation, type FeishuReceiveHandledObservation, type FeishuReceiveMessageHandlerPayload, type FeishuReceiveMessagePayload, type FeishuReceiveMessageReplayOptions, type FeishuReceiveMessageReplayResult, type FeishuReceiveMessageSummary, type FeishuReceiveRuntimeStatus, type FeishuResolveInteractionCommand, type FeishuSdkReceiveMessagePayload, type FeishuSessionReference, type FeishuStreamAction, type FeishuStreamActionPublisher, type FeishuStreamProjector, FeishuTenantAccessTokenError, type FeishuTenantAccessTokenProvider, type FeishuTenantAccessTokenProviderOptions, type FeishuTenantAccessTokenRequest, type FeishuTenantAccessTokenResponse, type FeishuTextReplySender, type FeishuWebSocketClient, type FeishuWebSocketClientStartOptions, type FeishuWebSocketDaemon, type FeishuWebSocketDaemonOptions, type FeishuWebSocketEventDispatcher, type FeishuWebSocketRuntime, type FeishuWorkerLoop, type FeishuWorkerLoopOptions, type FetchLike, type FetchLikeResponse, type HumanInteraction, type HumanInteractionActor, type HumanInteractionBase, type HumanInteractionClock, type HumanInteractionEndpointRegistry, type HumanInteractionFact, type HumanInteractionId, type HumanInteractionPresenter, type HumanInteractionRepository, HumanInteractionRepositoryError, type HumanInteractionResolutionAction, type HumanInteractionService, type HumanInteractionServiceOptions, type HumanInteractionTransition, HumanInteractionTransitionDenied, InvalidFeishuCardAction, InvalidFeishuMessageContent, InvalidFeishuSessionReference, InvalidInvocationAuthority, InvalidRecoveryAction, InvalidRivusEndpointBinding, InvalidRivusPlugin, InvalidStableJson, InvalidToolInput, InvalidWorkspaceRoot, type InvocationAuthority, type InvocationAuthorityRef, type JsonFetchRequestOptions, type JsonFileFeishuCardTargetRegistryOptions, type JsonHttpRequest, type JsonHttpResponse, type JsonlAgentEventLogOptions, type JsonlFeishuCardDeliveryLedgerOptions, type JsonlFeishuInboxRepositoryOptions, type JsonlHumanInteractionRepositoryOptions, type JsonlRecoveryControlOptions, type LangfuseAgentTelemetry, type LangfuseTelemetryConfig, LangfuseTelemetryConfigError, type LangfuseTelemetryContentMode, type LangfuseTelemetryEnv, type LoadRivusDeploymentManifestOptions, type LoadRivusDeploymentOptions, type LoadedRivusDeployment, type LocalCliAgentInvocationOrigin, MEMORY_SCOPES, type MemoryBinding, type MemoryInvocationAudience, type MemoryRecord, type MemoryScope, type MemorySearchQuery, type MemoryState, type MemoryTombstoneReceipt, OpenClawEnvImportError, type OpenClawEnvImportOptions, type OpenClawEnvImportResult, type OpenJsonAutomationTickRepositoryOptions, type OpenTelemetryAgentEventSinkOptions, type OpenTelemetryAgentTelemetry, type PendingHumanInteractionState, type PiAgentLoopOptions, type PiAgentSession, type PiAgentSessionEvent, type PiAgentSessionHandle, type PiCreateAgentSessionResult, type PiSdkAgentLoopOptions, type PiSessionRegistry, type PiSessionRegistryOptions, type PiToolApprovalGateway, type PiToolApprovalRequest, type PiToolProxyOptions, PluginStateConflict, type PluginStateRecord, type PluginStateStore, type PooledAgentRuntime, type PromptCommand, type PutPluginState, RIVUS_MEMORY_TOOL_ID, RIVUS_MEMORY_TOOL_PLUGIN_ID, RIVUS_MEMORY_TOOL_VERSION, RIVUS_PLUGIN_API_VERSION, type RateLimitedFeishuPublisherOptions, type RecoveryAction, type RecoveryControl, type RecoveryControlOptions, type RecoverySnapshot, type RegisteredRivusAgentProfile, type RegisteredRivusAutomation, type RegisteredRivusPlugin, type RegisteredRivusSkill, type RegisteredRivusTool, type RejectedHumanInteractionState, type RequestToolApprovalInput, type RequestUserDecisionInput, type ResolveHumanInteractionInput, type ResolvedRivusAgentDefinition, type ResolvedRivusAutomationDefinition, type RivusAgentDeployment, type RivusAgentDeploymentStatus, type RivusAgentHost, type RivusAgentHostOptions, type RivusAgentProfile, type RivusAutomationDelivery, type RivusAutomationDeliveryTargetType, type RivusAutomationDeployment, type RivusAutomationInput, type RivusAutomationTemplate, type RivusAutomationTickContext, type RivusDaemonBootstrapContext, type RivusDaemonBootstrapFactory, type RivusDaemonBootstrapModule, type RivusDaemonCliOptions, type RivusDaemonCliWriter, type RivusDaemonConfig, RivusDaemonConfigError, type RivusDaemonConfigLoaderOptions, type RivusDaemonEnv, type RivusDaemonFeishuReplayRunner, type RivusDaemonProcess, type RivusDaemonProcessOptions, type RivusDaemonPromptRunner, type RivusDaemonRecoveryRunner, type RivusDaemonShutdownController, type RivusDaemonShutdownControllerOptions, type RivusDaemonShutdownSignal, type RivusDaemonSignalSource, type RivusDaemonStatus, type RivusDaemonStatusHttpServer, type RivusDaemonStatusHttpServerOptions, type RivusDaemonStatusReporter, type RivusDaemonStatusReporterOptions, type RivusDaemonTransport, type RivusDaemonWorkerLoop, type RivusDeploymentAutomation, type RivusDeploymentAutomationLifecycle, RivusDeploymentAutomationReadinessError, type RivusDeploymentAutomationStatus, type RivusDeploymentBootstrapAdapters, type RivusDeploymentBootstrapContext, type RivusDeploymentBootstrapFactory, type RivusDeploymentCliProcess, type RivusDeploymentComponentLifecycle, type RivusDeploymentDaemon, type RivusDeploymentDaemonLifecycle, RivusDeploymentDaemonLifecycleError, type RivusDeploymentDaemonStatus, type RivusDeploymentEndpoint, type RivusDeploymentEndpointLifecycle, type RivusDeploymentEndpointStatus, type RivusDeploymentManifest, RivusDeploymentManifestError, RivusDeploymentReadinessError, type RivusEndpointDefinition, type RivusEndpointDeployment, type RivusEndpointExperimentalFeatures, type RivusEndpointInput, type RivusEnvFileVariables, type RivusHostToolDescriptor, type RivusMemoryTool, type RivusPlugin, type RivusPluginCatalog, type RivusPluginCatalogSnapshot, RivusPluginConformanceError, type RivusPluginConformanceInput, type RivusPluginConformanceReport, type RivusPluginDeclaration, type RivusPluginLifecycleProbe, RivusPluginLoadError, type RivusPluginLoadStatus, type RivusPluginManifest, type RivusPluginModule, type RivusPluginModuleLoadRequest, type RivusPluginRegistry, type RivusResolvedToolDescriptor, type RivusSkillDescriptor, type RivusSkillGrantSet, type RivusTextFileReader, type RivusThinkingLevel, type RivusToolDescriptor, type RivusToolExecutionContext, type RivusToolExecutor, type RivusToolFactoryContext, type RivusToolGrantSet, type RivusToolIdempotency, RivusToolInputRejected, type RivusToolRisk, type RunIdGenerator, type ScheduledAutomation, type ScheduledAutomationClock, type ScheduledAutomationDeliveryInput, type ScheduledAutomationOptions, type ScheduledAutomationRunInput, type ScheduledAutomationRunResult, type SelectedHumanInteractionState, type SessionKey, type SessionScheduler, SessionSchedulerCapacityExceeded, SessionSchedulerDisposed, type SessionSchedulerOptions, type SessionSchedulerStatus, type SpawnSubagentRequest, type SubagentCoordinator, type SubagentRecord, type TelemetryContentRedactor, type TelemetryContentRedactorOptions, type TerminalAgentDomainEvent, type TextAgentLoopCallback, type TextAgentLoopOptions, type ToolApprovalBinding, type ToolApprovalInteraction, type ToolApprovalInteractionState, type ToolApprovalRequest, type ToolApprovalService, type ToolBroker, type ToolBrokerOptions, type ToolExecutionRequest, ToolInvocationDenied, type ToolOperationBeginResult, type ToolOperationBinding, type ToolOperationInspectResult, type ToolOperationLedger, type ToolOperationReconciliation, type ToolOperationReconciliationOutcome, type ToolOperationRecord, type ToolOperationRecoveryItem, type ToolOperationResolutionResult, type ToolOperationState, UnsupportedFeishuCardAction, UnsupportedFeishuMessage, type UserDecisionInteraction, type UserDecisionInteractionState, type UserDecisionOption, type WorkspaceInstructionSource, type WorkspaceInstructionsDiagnostic, type WorkspaceInstructionsDiagnosticCode, type WorkspaceInstructionsProvider, type WorkspaceInstructionsRequest, WorkspaceInstructionsSourceError, type WorkspaceInstructionsView, type WorkspaceRootHandle, assembleAgentContext, assertRivusPluginConforms, commitAutomationOutcome, createAgentCommandFromFeishuCardAction, createAgentCommandFromFeishuMessage, createAgentConversationMessages, createAgentDomainEventHandler, createAgentDomainEventSink, createAgentDomainEventSinkFromCallback, createAgentHarness, createAgentHarnessClient, createAgentHarnessPooledRuntime, createAgentInstanceRegistry, createAgentLoopFromCallback, createAgentLoopModelExecutionEnd, createAgentLoopModelExecutionStart, createAgentLoopSkillExecutionEnd, createAgentLoopSkillExecutionStart, createAgentLoopTextDelta, createAgentLoopThinkingDelta, createAgentLoopToolExecutionEnd, createAgentLoopToolExecutionStart, createAgentLoopToolExecutionUpdate, createAgentMemoryService, createAgentRunUpdateHandler, createAgentRuntime, createAgentRuntimePool, createAgentTranscriptMessages, createAgentTranscriptTurn, createAgentsMdInstructionsProvider, createAsyncIterableAgentLoop, createAutomationMandateStore, createCoalescingFeishuPublisher, createCompactionService, createCompositeRivusDaemonTransport, createConfiguredFeishuCardKitPublisher, createConfiguredFeishuCardKitTargetPreparation, createConfiguredFeishuHumanInteractionPresenter, createConfiguredFeishuMarkdownMessageSender, createConfiguredFeishuOpenApiClient, createConfiguredFeishuTextReplySender, createConfiguredRivusDaemonBootstrap, createConfiguredRivusDeploymentDaemon, createDailyAutomationSchedule, createDefaultAgentHarness, createDefaultAgentHarnessClient, createDefaultAgentHarnessClientFromCallback, createDefaultAgentHarnessClientFromTextCallback, createDefaultAgentHarnessFromCallback, createDefaultAgentHarnessFromTextCallback, createDefaultAgentRuntime, createDefaultAgentRuntimeFromCallback, createDefaultAgentRuntimeFromTextCallback, createDelegationService, createDeliveryOutbox, createEventAgentLoop, createFakeRivusPlugin, createFeishuAgentDaemon, createFeishuAgentRunCard, createFeishuAgentRuntime, createFeishuCardActionCallbackResponse, createFeishuCardActionErrorResponse, createFeishuCardDeliveryLedger, createFeishuCardDeliveryReconciler, createFeishuCardKitOpenApiClient, createFeishuCardKitOpenApiTargetCreator, createFeishuCardKitPublisher, createFeishuCardTargetPreparation, createFeishuConversationId, createFeishuCotPublisher, createFeishuDeploymentEndpoint, createFeishuEventHandlers, createFeishuHumanInteractionCard, createFeishuHumanInteractionPresenter, createFeishuInboxRepository, createFeishuMessageQueue, createFeishuMessageWorker, createFeishuOpenApiClient, createFeishuPeriodicFlush, createFeishuPresentationPreparation, createFeishuSessionKey, createFeishuStreamProjector, createFeishuTenantAccessTokenProvider, createFeishuWebSocketDaemon, createFeishuWorkerLoop, createFixedClock, createHumanInteractionEndpointRegistry, createHumanInteractionService, createHumanInteractionToolApprovalGateway, createInMemoryFeishuCardTargetRegistry, createInMemoryHumanInteractionRepository, createInvocationAuthority, createJsonFetchRequest, createJsonFileFeishuCardTargetRegistry, createJsonlAgentEventLog, createJsonlHumanInteractionRepository, createLangfuseAgentTelemetry, createLazyFeishuWebSocketEventDispatcher, createMemoryNamespace, createOpenTelemetryAgentEventSink, createOpenTelemetryAgentTelemetry, createPiAgentLoop, createPiSdkAgentLoop, createPiSessionRegistry, createPiSkillRuntime, createPiToolNameResolver, createPiToolProxyDefinitions, createPluginStateStore, createRateLimitedFeishuPublisher, createRecoveryAction, createRecoveryControl, createRivusAgentHost, createRivusDaemonProcess, createRivusDaemonShutdownController, createRivusDaemonStatusHttpServer, createRivusDaemonStatusReporter, createRivusDeploymentCliProcess, createRivusDeploymentDaemon, createRivusEnvFromOpenClawConfig, createRivusMemoryTool, createRivusMemoryToolContract, createRivusMemoryToolDescriptor, createRivusPluginCatalog, createRoutedHumanInteractionToolApprovalService, createScheduledAutomation, createSequenceRunIds, createSessionScheduler, createSubagentCoordinator, createSystemClock, createTelemetryContentRedactor, createTextAgentLoop, createTextAgentLoopFromCallback, createToolBroker, createToolInputDigest, createToolOperationLedger, createUuidRunIds, createWorkspaceRootHandle, describeFeishuMessageIntake, evolveAgentRun, formatRivusEnvFile, initialAgentRunState, intersectToolIds, isAgentToolExecutionEvent, isAssistantTextDeltaEvent, isAssistantThinkingDeltaEvent, isTerminalAgentDomainEvent, isTerminalAgentRunPhase, loadNodeRivusPluginModule, loadRivusDaemonConfig, loadRivusDeployment, loadRivusDeploymentManifest, normalizeStableJson, openJsonAutomationTickRepository, openJsonlAgentMemoryService, openJsonlFeishuCardDeliveryLedger, openJsonlFeishuInboxRepository, openJsonlRecoveryControl, openJsonlToolOperationLedger, replayAgentHistory, replayAgentTranscript, requiresToolApproval, resolveFeishuEndpointCredentials, resolveLangfuseTelemetryConfig, resolveRivusAgentDefinition, restoreAgentHistory, restoreConfiguredRivusDaemonBootstrap, restrictMemoryScopesForAudience, runRivusDaemonCli, shouldAcceptFeishuEndpointMessage, transitionHumanInteraction, validateRivusDeploymentManifest };