@rivus/runtime 0.16.2

package/dist/index.d.ts

@@ -0,0 +1,1306 @@
+import { $ as createAgentLoopTurnStart, A as AgentLoopSkillExecutionStart, At as AgentModelUsage, B as AgentLoopTurnStart, Bt as AgentToolExecutionUpdated, C as AgentLoopInput, Ct as AgentRunState, D as AgentLoopModelExecutionStartOptions, Dt as AgentModelExecutionEnded, E as AgentLoopModelExecutionStart, Et as AgentDomainEvent, F as AgentLoopToolExecutionEndOptions, Ft as AgentSkillExecutionEnded, G as createAgentLoopModelExecutionStart, Gt as SessionKey, H as EventAgentLoopOptions, Ht as AgentTurnStarted, I as AgentLoopToolExecutionStart, It as AgentSkillExecutionStarted, J as createAgentLoopTextDelta, Jt as isAssistantTextDeltaEvent, K as createAgentLoopSkillExecutionEnd, Kt as TerminalAgentDomainEvent, L as AgentLoopToolExecutionStartOptions, Lt as AgentToolExecutionEnded, M as AgentLoopTextDelta, Mt as AgentRunCompleted, N as AgentLoopThinkingDelta, Nt as AgentRunFailed, O as AgentLoopSkillExecutionEnd, Ot as AgentModelExecutionEvent, P as AgentLoopToolExecutionEnd, Pt as AgentRunId, Q as createAgentLoopToolExecutionUpdate, R as AgentLoopToolExecutionUpdate, Rt as AgentToolExecutionEvent, S as AgentLoopEventLike, St as AgentRunPhase, T as AgentLoopModelExecutionEndOptions, Tt as AgentToolExecutionState, U as TextAgentLoopOptions$1, Ut as AssistantTextDelta, V as AgentSteeringChannel, Vt as AgentTurnCompleted, W as createAgentLoopModelExecutionEnd, Wt as AssistantThinkingDelta, X as createAgentLoopToolExecutionEnd, Xt as isTerminalAgentDomainEvent, Y as createAgentLoopThinkingDelta, Yt as isAssistantThinkingDeltaEvent, Z as createAgentLoopToolExecutionStart, _ as toCompatibilityAgentLoopInput, _t as replayAgentTranscript, a as AgentLoopInput$1, at as AutomationAgentInvocationOrigin, b as AgentLoop, bt as AgentSessionSummary, c as EventAgentLoopOptions$1, ct as LocalCliAgentInvocationOrigin, d as createAgentLoopFromCallback, dt as AgentTranscriptMessage, et as createEventAgentLoop, f as createAsyncIterableAgentLoop, ft as AgentTranscriptMessageRole, g as fromEffectAgentLoop, gt as createAgentTranscriptTurn, h as createTextAgentLoopFromCallback, ht as createAgentTranscriptMessages, i as AgentLoopCallbackResult, it as AgentMemoryInvocationIdentity, j as AgentLoopSkillExecutionStartOptions, jt as AgentRunAccepted, k as AgentLoopSkillExecutionEndOptions, kt as AgentModelExecutionStarted, l as TextAgentLoopCallback, lt as AgentConversationMessagesOptions, m as createTextAgentLoop, mt as createAgentConversationMessages, n as AgentLoopCallback, nt as normalizeAgentLoopEvent, o as AgentSteeringChannel$1, ot as BackgroundSessionAgentInvocationOrigin, p as createEventAgentLoop$1, pt as AgentTranscriptTurn, q as createAgentLoopSkillExecutionStart, qt as isAgentToolExecutionEvent, r as AgentLoopCallbackOutput, rt as AgentInvocationOrigin, s as AsyncIterableAgentLoopOptions, st as FeishuAgentInvocationOrigin, t as AgentLoop$1, tt as createTextAgentLoop$1, u as TextAgentLoopOptions, ut as AgentTranscript, v as toEffectAgentLoop, vt as AgentHistory, w as AgentLoopModelExecutionEnd, wt as AgentSkillExecutionState, x as AgentLoopEvent, xt as replayAgentHistory, y as toEffectAgentLoopInput, yt as AgentRunSummary, z as AgentLoopToolExecutionUpdateOptions, zt as AgentToolExecutionStarted } from "./chunks/agent-loop.js";
+import { $ as RegisteredRivusSkill, A as AgentModelContentObserver, B as RivusToolExecutionOrigin, C as InvocationMemoryAuthority, D as resolveInvocationAuthority, E as createInvocationAuthority, F as RivusMemoryAuthority, G as RivusToolIdempotency, H as RivusToolFactoryContext, I as RivusMemoryScope, J as ModelChangeBoundaryDeadlineError, K as RivusToolInputRejected, L as RivusResolvedToolDescriptor, M as AgentModelOutputObservation, N as RegisteredRivusTool, O as NormalizedAgentInvocation, P as RivusHostToolDescriptor, Q as RunAdmissionOptions, R as RivusToolDescriptor, S as InvocationAuthorityRef, T as InvocationToolGrantSet, U as RivusToolGrantSet, V as RivusToolExecutor, W as RivusToolGrantSetOperations, X as RunAdmission, Y as ModelChangeClock, Z as RunAdmissionLease, _ as ToolRisk, a as AuthorizationPolicyProvider, at as ModelChangeExecutionBudget, b as InvocationAuthority, c as ToolApprovalService, ct as ModelChangeRuntimeContext, d as ToolExecutionContext, dt as ModelReference, et as RivusSkillDescriptor, f as ToolExecutionOrigin, g as ToolIdempotency, h as ToolExecutorInputRejected, i as isRivusRuntimeToolId, it as ModelChangeBudgetReservation, j as AgentModelInputObservation, k as normalizeAgentInvocation, l as ToolCatalog, lt as ModelChangeRuntimePort, m as ToolExecutor, n as RivusRuntimeToolGrantSet, nt as ModelBinding, o as AuthorizationPolicyState, ot as ModelChangePaidCallKind, p as ToolExecutionRequest, q as RivusToolRisk, r as RivusRuntimeToolId, rt as ModelChangeActivationResult, s as ToolApprovalRequest, st as ModelChangeRestoreResult, t as RIVUS_RUNTIME_TOOL_IDS, tt as RivusSkillGrantSet, u as ToolDescriptor, ut as ModelChangeValidationResult, v as requiresToolApproval$1, w as InvocationMemoryScope, x as InvocationAuthorityIdentity, y as InvalidInvocationAuthority, z as RivusToolExecutionContext } from "./chunks/rivus-runtime-tool.js";
+import { Effect, Stream } from "effect";
+import { Tracer } from "@opentelemetry/api";
+
+//#region src/core/application/agent-execution/contracts/agent-execution-errors.d.ts
+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);
+}
+//#endregion
+//#region src/core/application/agent-execution/contracts/agent-execution-contracts.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 runTimeoutMs?: number;
+  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>;
+}
+/**
+ * Standard typed result of a single Agent Run. The public AgentHostRuntime
+ * extension point returns `unknown`; the standard Gateway binding validates the
+ * result into this shape.
+ */
+interface StandardAgentRunResult {
+  readonly finalText: string;
+  readonly runId: AgentRunId;
+}
+/**
+ * Execution control operations shared by the legacy Feishu execution port and
+ * the normalized Gateway execution port. These methods do not depend on the
+ * prompt command shape, so they can be shared without pulling the normalized
+ * invocation graph into the legacy Feishu adapter.
+ */
+interface AgentExecutionControlPort {
+  cancelActiveRun(input: {
+    readonly reason: string;
+    readonly sessionKey: SessionKey;
+  }): Effect.Effect<AgentRunId | undefined, unknown>;
+  cancelRun(input: {
+    readonly reason: string;
+    readonly runId: AgentRunId;
+    readonly sessionKey?: SessionKey;
+  }): Effect.Effect<boolean, unknown>;
+  getActiveRun?(input: {
+    readonly sessionKey: SessionKey;
+  }): Effect.Effect<AgentRunId | undefined, unknown>;
+  steerRun(input: {
+    readonly sessionKey: SessionKey;
+    readonly text: string;
+  }): Effect.Effect<{
+    readonly runId: AgentRunId;
+    readonly steered: true;
+  } | undefined, unknown>;
+}
+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;
+}
+type AgentHarnessError = AgentHarnessBusy | AgentLoopFailed | AgentEventSinkFailed | AgentEventHandlerFailed | AgentRunCancelled;
+interface AgentRunSubscriptionCapabilities {
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+}
+interface AgentHarness extends AgentRunSubscriptionCapabilities {
+  cancelActiveRun(reason?: string): Effect.Effect<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Effect.Effect<boolean>;
+  steerRun(runId: AgentRunId, text: 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>;
+}
+interface AgentSessionHandle extends AgentRunSubscriptionCapabilities {
+  readonly sessionKey: SessionKey;
+  cancelActiveRun(reason?: string): Effect.Effect<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Effect.Effect<boolean>;
+  steerRun(runId: AgentRunId, text: 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>;
+}
+type AgentDomainEventListener = (event: AgentDomainEvent) => void;
+type AgentRunUpdateListener = (update: AgentRunUpdate) => void;
+type AgentDomainEventHandler<R = never> = (event: AgentDomainEvent) => Effect.Effect<void, unknown, R>;
+type AgentRunUpdateHandler<R = never> = (update: AgentRunUpdate) => Effect.Effect<void, unknown, R>;
+interface AgentDomainEventSink {
+  append(event: AgentDomainEvent): Effect.Effect<void, unknown>;
+}
+//#endregion
+//#region src/core/application/agent-execution/contracts/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 WorkspaceInstructionsSourceRequest {
+  readonly maxBytes: number;
+  readonly targetPath?: string;
+  readonly workingDirectory: string;
+  readonly workspaceRoot: WorkspaceRootHandle;
+}
+interface WorkspaceInstructionsSourceResult {
+  readonly diagnostics: ReadonlyArray<WorkspaceInstructionsDiagnostic>;
+  readonly sources: ReadonlyArray<WorkspaceInstructionSource>;
+}
+interface WorkspaceInstructionsSourcePort {
+  load(request: WorkspaceInstructionsSourceRequest): Effect.Effect<WorkspaceInstructionsSourceResult, unknown>;
+}
+//#endregion
+//#region src/core/application/agent-execution/context/workspace-instructions-resolver.d.ts
+declare class InvalidWorkspaceRoot extends Error {
+  readonly name = "InvalidWorkspaceRoot";
+}
+declare class WorkspaceInstructionsSourceError extends Error {
+  readonly relativePath: string;
+  readonly reason: string;
+  readonly name = "WorkspaceInstructionsSourceError";
+  constructor(relativePath: string, reason: string);
+}
+interface WorkspaceInstructionsResolver {
+  resolve(request: WorkspaceInstructionsRequest): Effect.Effect<WorkspaceInstructionsView, unknown>;
+}
+type WorkspaceInstructionsDigest = (value: string) => string;
+declare function createWorkspaceInstructionsResolver(source: WorkspaceInstructionsSourcePort, digest: WorkspaceInstructionsDigest): WorkspaceInstructionsResolver;
+//#endregion
+//#region src/core/application/agent-execution/context/agent-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/core/domain/memory/value-objects/scope.d.ts
+type MemoryScope$1 = "conversation" | "agent-private" | "project" | "shared-user-profile";
+//#endregion
+//#region src/core/domain/memory/value-objects/binding.d.ts
+interface MemoryBinding {
+  readonly agentId: string;
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly scope: MemoryScope$1;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+//#endregion
+//#region src/core/domain/memory/aggregate/snapshot.d.ts
+type MemoryState = "proposed" | "confirmed" | "superseded" | "tombstoned";
+type MemoryRecordSnapshot = Readonly<{
+  readonly content: string;
+  readonly conversationSafe: boolean;
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope$1;
+  readonly state: MemoryState;
+  readonly tombstoneReason?: string;
+  readonly [extension: string]: unknown;
+}>;
+type AgentMemorySnapshot = Readonly<{
+  readonly binding: MemoryBinding;
+  readonly record: MemoryRecordSnapshot;
+  readonly [extension: string]: unknown;
+}>;
+//#endregion
+//#region src/core/domain/memory/aggregate/memory-record.d.ts
+interface ConfirmMemoryRecordInput {
+  readonly expectedRevision: number;
+  readonly conversationSafe?: boolean;
+}
+interface TombstoneMemoryRecordInput {
+  readonly expectedRevision: number;
+  readonly reason?: string;
+}
+//#endregion
+//#region src/core/application/memory/ports/agent-memory-repository.d.ts
+declare class AgentMemoryRepositoryConflict extends Error {
+  readonly name = "AgentMemoryRepositoryConflict";
+}
+/**
+ * Repository implementations exchange this transition-capable record with the
+ * application service. The domain aggregate remains an internal construction
+ * detail of Runtime and is not part of the persistence port.
+ */
+interface AgentMemoryRepositoryRecord extends MemoryRecordSnapshot {
+  readonly binding: MemoryBinding;
+  readonly scope: MemoryScope$1;
+  readonly state: MemoryState;
+  confirm(input: ConfirmMemoryRecordInput): AgentMemoryRepositoryRecord;
+  tombstone(input: TombstoneMemoryRecordInput): AgentMemoryRepositoryRecord;
+  forget(input: TombstoneMemoryRecordInput): AgentMemoryRepositoryRecord;
+  validateTransitionTo(next: AgentMemoryRepositoryRecord): boolean;
+  toSnapshot(): AgentMemorySnapshot;
+}
+interface AgentMemoryRepository {
+  get(binding: MemoryBinding, id: string): Effect.Effect<AgentMemoryRepositoryRecord | undefined, unknown>;
+  list(binding: MemoryBinding): Effect.Effect<ReadonlyArray<AgentMemoryRepositoryRecord>, unknown>;
+  save(snapshot: AgentMemorySnapshot): Effect.Effect<AgentMemoryRepositoryRecord, unknown>;
+}
+//#endregion
+//#region src/core/application/memory/commands/agent-memory-service.d.ts
+interface MemorySearchQuery {
+  readonly query: string;
+}
+interface MemoryHandle {
+  readonly namespace: string;
+  readonly scope: MemoryScope$1;
+  confirm(input: {
+    readonly id: string;
+    readonly expectedRevision: number;
+    readonly conversationSafe?: boolean;
+  }): Effect.Effect<MemoryRecordSnapshot, unknown>;
+  forgetRequest(input: {
+    readonly expectedRevision: number;
+    readonly id: string;
+    readonly reason?: string;
+  }): Effect.Effect<MemoryRecordSnapshot, unknown>;
+  inspect(id: string): Effect.Effect<MemoryRecordSnapshot | undefined, unknown>;
+  propose(input: {
+    readonly content: string;
+  }): Effect.Effect<MemoryRecordSnapshot, unknown>;
+  read(id: string): Effect.Effect<MemoryRecordSnapshot | undefined, unknown>;
+  search(query: MemorySearchQuery): Effect.Effect<ReadonlyArray<MemoryRecordSnapshot>, unknown>;
+}
+interface MemoryService {
+  bind(binding: MemoryBinding): MemoryHandle;
+}
+interface MemoryIdentity {
+  next(): string;
+}
+declare class AgentMemoryError extends Error {
+  readonly name = "AgentMemoryError";
+}
+declare function createMemoryService(options: {
+  readonly identity: MemoryIdentity;
+  readonly repository: AgentMemoryRepository;
+}): MemoryService;
+//#endregion
+//#region src/adapters/agent/memory/memory-handle-contract.d.ts
+/** Shared Promise handle shape used by the canonical and legacy Memory DTOs. */
+interface MemoryHandleContract<MemoryRecord> {
+  readonly namespace: string;
+  readonly scope: MemoryScope$1;
+  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>>;
+}
+//#endregion
+//#region src/adapters/agent/memory/agent-memory-access.d.ts
+declare const MEMORY_SCOPES: readonly ["conversation", "agent-private", "project", "shared-user-profile"];
+type MemoryScope = MemoryScope$1;
+type AgentMemoryRecord = MemoryRecordSnapshot;
+type MemoryInvocationAudience = "group" | "private";
+interface AgentMemoryIdentity {
+  readonly audience: MemoryInvocationAudience;
+  readonly conversationId?: string;
+  readonly projectId?: string;
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface AgentMemoryAuthority extends AgentMemoryIdentity {
+  readonly scopes: ReadonlyArray<MemoryScope>;
+}
+/** Promise-based Memory access used by the Host tool compatibility boundary. */
+interface AgentMemoryHandle extends MemoryHandleContract<AgentMemoryRecord> {}
+/** Consumer-owned port implemented by Memory compatibility adapters. */
+interface AgentMemoryService {
+  bind(binding: MemoryBinding): AgentMemoryHandle;
+}
+//#endregion
+//#region src/adapters/agent/memory/rivus-memory-tool-contract.d.ts
+declare const RIVUS_MEMORY_TOOL_ID = "memory";
+declare const RIVUS_MEMORY_TOOL_PLUGIN_ID = "rivus-core";
+declare const RIVUS_MEMORY_TOOL_VERSION = "1.0.0";
+declare function createRivusMemoryToolContract(scopes: ReadonlyArray<MemoryScope>): Readonly<{
+  description: "Search and read Memory inside Host-bound scopes; propose or request forgetting only in writable private scopes.";
+  digest: "sha256:rivus-memory-v3";
+  id: "memory";
+  idempotency: "required";
+  inputSchema: Readonly<{
+    additionalProperties: false;
+    properties: {
+      scope?: {
+        description: string;
+        enum: MemoryScope$1[];
+        type: string;
+      };
+      command: {
+        description: string;
+        enum: string[];
+        type: string;
+      };
+      id: {
+        description: string;
+        minLength: number;
+        type: string;
+      };
+      input: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          content: {
+            minLength: number;
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      query: {
+        additionalProperties: boolean;
+        description: string;
+        properties: {
+          query: {
+            type: string;
+          };
+        };
+        required: string[];
+        type: string;
+      };
+      reason: {
+        description: string;
+        type: string;
+      };
+    };
+    required: string[];
+    type: "object";
+  }>;
+  risk: "mutate";
+  version: "1.0.0";
+}>;
+//#endregion
+//#region src/adapters/agent/memory/memory-tool-contract.d.ts
+interface MemoryTombstoneReceipt {
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope$1;
+  readonly state: "tombstoned";
+}
+/** Shared command protocol; each Memory surface supplies its own record DTO. */
+interface MemoryToolContract<MemoryRecord> {
+  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$1, "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$1;
+  }): Promise<ReadonlyArray<MemoryRecord>>;
+  replayCompleted(command: unknown, completedResult: unknown): Promise<unknown>;
+}
+//#endregion
+//#region src/adapters/agent/memory/rivus-memory-tool.d.ts
+interface RivusMemoryTool extends MemoryToolContract<AgentMemoryRecord> {}
+declare function createRivusMemoryTool(memory: AgentMemoryHandle | ReadonlyArray<AgentMemoryHandle>): RivusMemoryTool;
+declare function createRivusMemoryToolDescriptor(options: {
+  readonly memory: AgentMemoryService;
+}): RivusHostToolDescriptor;
+//#endregion
+//#region src/adapters/agent/memory/project-memory-prompt-preparer.d.ts
+interface ProjectMemoryRecallOptions {
+  readonly agentId: string;
+  readonly memory: AgentMemoryService;
+  readonly projectId: string;
+  readonly maxBytes?: number;
+  readonly maxRecords?: number;
+  readonly identity?: ProjectMemoryRecallIdentity;
+}
+interface ProjectMemoryRecallIdentity {
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface ProjectMemoryPromptInput {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly text: string;
+}
+declare function createProjectMemoryPromptPreparer(options: ProjectMemoryRecallOptions): (input: ProjectMemoryPromptInput) => Promise<string>;
+//#endregion
+//#region src/adapters/agent/workspace/agents-md-instructions-source.d.ts
+declare function createAgentsMdInstructionsSource(): WorkspaceInstructionsSourcePort;
+//#endregion
+//#region src/adapters/agent/workspace/node-workspace-root-registry.d.ts
+declare function createWorkspaceRootHandle(rootPath: string): Promise<WorkspaceRootHandle>;
+declare function resolveWorkspaceRootPath(handle: WorkspaceRootHandle): string;
+//#endregion
+//#region src/adapters/agent/memory/persisted-memory-record.d.ts
+/** Persistence codecs use this named transition surface without publishing the domain aggregate class. */
+interface PersistedMemoryRecord extends AgentMemoryRepositoryRecord, AgentMemoryRecord {
+  readonly binding: MemoryBinding;
+  confirm(input: {
+    readonly expectedRevision: number;
+    readonly conversationSafe?: boolean;
+  }): PersistedMemoryRecord;
+  tombstone(input: {
+    readonly expectedRevision: number;
+    readonly reason?: string;
+  }): PersistedMemoryRecord;
+  forget(input: {
+    readonly expectedRevision: number;
+    readonly reason?: string;
+  }): PersistedMemoryRecord;
+  validateTransitionTo(next: PersistedMemoryRecord): boolean;
+  toSnapshot(): AgentMemorySnapshot;
+}
+declare function createPersistedMemoryRecord(input: {
+  readonly binding: MemoryBinding;
+  readonly content: string;
+  readonly id: string;
+}): PersistedMemoryRecord;
+declare function restorePersistedMemoryRecord(snapshot: unknown): PersistedMemoryRecord;
+//#endregion
+//#region src/adapters/observability/content/telemetry-content-redactor.d.ts
+interface TelemetryContentRedactorOptions {
+  readonly maxArrayItems?: number;
+  readonly maxDepth?: number;
+  readonly maxObjectKeys?: number;
+  readonly maxSerializedLength?: number;
+  readonly maxStringLength?: number;
+}
+type TelemetryContentRedactor = (value: unknown) => string;
+declare function createTelemetryContentRedactor(options?: TelemetryContentRedactorOptions): TelemetryContentRedactor;
+//#endregion
+//#region src/adapters/observability/agent/langfuse-agent-telemetry.d.ts
+type LangfuseTelemetryEnv = Readonly<Record<string, string | undefined>>;
+type LangfuseTelemetryContentMode = "metadata-only" | "redacted";
+interface LangfuseTelemetryConfig {
+  readonly contentMode?: LangfuseTelemetryContentMode;
+  readonly endpoint: string;
+  readonly environment: string;
+  readonly publicKey: string;
+  readonly secretKey: string;
+  readonly serviceName: string;
+}
+interface LangfuseAgentTelemetry {
+  readonly modelContentObserver: AgentModelContentObserver;
+  readonly sink: AgentDomainEventSink;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+declare class LangfuseTelemetryConfigError extends Error {
+  constructor(message: string);
+}
+declare function resolveLangfuseTelemetryConfig(env: LangfuseTelemetryEnv): LangfuseTelemetryConfig | undefined;
+declare function createLangfuseAgentTelemetry(config: LangfuseTelemetryConfig): LangfuseAgentTelemetry;
+//#endregion
+//#region src/adapters/observability/agent/open-telemetry-agent-event-sink.d.ts
+interface OpenTelemetryAgentEventSinkOptions {
+  readonly captureContent?: boolean;
+  readonly onProjectionError?: (error: unknown, event: AgentDomainEvent) => Promise<void> | void;
+  readonly redactContent?: TelemetryContentRedactor;
+  readonly tracer: Tracer;
+}
+interface OpenTelemetryAgentTelemetry {
+  readonly modelContentObserver: AgentModelContentObserver;
+  readonly sink: AgentDomainEventSink;
+}
+declare function createOpenTelemetryAgentEventSink(options: OpenTelemetryAgentEventSinkOptions): AgentDomainEventSink;
+declare function createOpenTelemetryAgentTelemetry(options: OpenTelemetryAgentEventSinkOptions): OpenTelemetryAgentTelemetry;
+//#endregion
+//#region src/core/domain/tool-operation/value-objects/binding.d.ts
+interface ToolOperationBinding$1 {
+  readonly agentId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly sourceMessageId: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+//#endregion
+//#region src/core/domain/tool-operation/aggregate/snapshot.d.ts
+type ToolOperationState$1 = {
+  readonly status: "pending";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly reason: string;
+  readonly status: "reconciliation-required";
+} | {
+  readonly status: "aborted";
+};
+interface ToolOperationReconciliationAction {
+  readonly actorId: string;
+  readonly at: string;
+  readonly note: string;
+}
+interface ToolOperationReconciliation$1 extends ToolOperationReconciliationAction {
+  readonly outcome: "applied" | "not-applied";
+}
+interface ToolOperationSnapshot {
+  readonly binding: ToolOperationBinding$1;
+  readonly operationId: string;
+  readonly reconciliation?: ToolOperationReconciliation$1;
+  readonly revision: number;
+  readonly state: ToolOperationState$1;
+}
+type ToolOperationRecord$1 = ToolOperationSnapshot;
+type ToolOperationReconciliationOutcome$1 = {
+  readonly result: unknown;
+  readonly status: "applied";
+} | {
+  readonly status: "not-applied";
+};
+type ToolOperationBeginResult$1 = {
+  readonly status: "acquired";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly status: "blocked";
+  readonly reason: string;
+};
+type ToolOperationInspectResult$1 = {
+  readonly status: "missing";
+} | {
+  readonly result: unknown;
+  readonly status: "completed";
+} | {
+  readonly status: "blocked";
+  readonly reason: string;
+};
+//#endregion
+//#region src/core/domain/tool-operation/aggregate/tool-operation.d.ts
+interface CreateToolOperationInput {
+  readonly binding: ToolOperationBinding$1;
+  readonly operationId: string;
+}
+interface ReconcileToolOperationInput {
+  readonly action: ToolOperationReconciliationAction;
+  readonly expectedRevision: number;
+  readonly operationId: string;
+  readonly outcome: ToolOperationReconciliationOutcome$1;
+}
+/** Immutable transitions do not serialize concurrent writes; the ledger serializes persisted transitions. */
+declare class ToolOperation {
+  #private;
+  private constructor();
+  static create(input: CreateToolOperationInput): ToolOperation;
+  static restore(value: unknown): ToolOperation;
+  get binding(): ToolOperationBinding$1;
+  get operationId(): string;
+  get reconciliation(): ToolOperationReconciliation$1 | undefined;
+  get revision(): number;
+  get state(): ToolOperationState$1;
+  matchesBinding(binding: ToolOperationBinding$1): boolean;
+  complete(result: unknown): ToolOperation;
+  abort(): ToolOperation;
+  requireReconciliation(reason: string): ToolOperation;
+  retry(): ToolOperation;
+  recoverInterrupted(): ToolOperation;
+  reconcile(input: ReconcileToolOperationInput): ToolOperation;
+  validateTransitionTo(next: ToolOperation): boolean;
+  toSnapshot(): ToolOperationSnapshot;
+  private requirePending;
+  private next;
+}
+//#endregion
+//#region src/core/domain/tool-operation/factories/restore-tool-operation.d.ts
+declare function restoreToolOperation(snapshot: unknown): ToolOperation;
+//#endregion
+//#region src/core/application/recovery/recovery-action.d.ts
+/** The audited actor, timestamp, and note shared by recovery operations. */
+interface RecoveryAction extends ToolOperationReconciliationAction {}
+declare class InvalidRecoveryAction extends Error {
+  readonly name = "InvalidRecoveryAction";
+}
+declare function createRecoveryAction(input: RecoveryAction): RecoveryAction;
+//#endregion
+//#region src/core/application/agent-execution/execution/agent-harness.d.ts
+declare function createAgentHarness(options: AgentHarnessOptions): AgentHarness;
+//#endregion
+//#region src/core/application/agent-execution/execution/agent-event-sink.d.ts
+declare function createAgentDomainEventSink(append: (event: AgentDomainEvent) => Effect.Effect<void, unknown>): AgentDomainEventSink;
+//#endregion
+//#region src/core/application/agent-execution/execution/agent-loop-event-mapper.d.ts
+declare function describeLoopError(error: unknown): string;
+declare function toDomainEvent(runId: AgentRunId, sessionKey: SessionKey, event: AgentLoopEvent, occurredAt: Date): AgentDomainEvent;
+//#endregion
+//#region src/core/application/agent-execution/history/agent-run-state-projection.d.ts
+declare const initialAgentRunState: AgentRunState;
+declare function isTerminalAgentRunPhase(phase: AgentRunPhase): boolean;
+declare function evolveAgentRun(state: AgentRunState, event: AgentDomainEvent): AgentRunState;
+//#endregion
+//#region src/core/application/agent-execution/history/restore-agent-history.d.ts
+interface AgentHistoryEventLog {
+  readAll(): Effect.Effect<ReadonlyArray<AgentDomainEvent>, unknown>;
+}
+declare function restoreAgentHistory(eventLog: AgentHistoryEventLog): Effect.Effect<AgentHistory, unknown>;
+//#endregion
+//#region src/core/application/agent-execution/query/agent-execution-query-store.d.ts
+interface AgentExecutionQueryStore {
+  project(event: AgentDomainEvent): AgentRunUpdate;
+  getHistory(): AgentHistory;
+  getLatestState(): AgentRunState;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getSessionHistory(sessionKey: SessionKey): AgentHistory;
+  getSessionLatestRunSnapshot(sessionKey: SessionKey): AgentRunSnapshot | undefined;
+  getSessionLatestRunSummary(sessionKey: SessionKey): AgentRunSummary | undefined;
+  getSessionRunEvents(sessionKey: SessionKey, runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getSessionRunSnapshot(sessionKey: SessionKey, runId: AgentRunId): AgentRunSnapshot | undefined;
+  getSessionRunState(sessionKey: SessionKey, runId: AgentRunId): AgentRunState | undefined;
+  getSessionRunSummary(sessionKey: SessionKey, runId: AgentRunId): AgentRunSummary | undefined;
+  getSessionRunUpdates(sessionKey: SessionKey, runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getSessionRuns(sessionKey: SessionKey): ReadonlyArray<AgentRunSummary>;
+  getSessionSnapshot(sessionKey: SessionKey, availability: AgentSessionAvailability): AgentSessionSnapshot;
+  getSessionState(sessionKey: SessionKey): AgentRunState | undefined;
+  getSessionSummary(sessionKey: SessionKey): AgentSessionSummary | undefined;
+  getSessionTranscript(sessionKey: SessionKey): AgentTranscript;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, listener: AgentDomainEventListener): () => void;
+  subscribeRunUpdates(runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeSession(sessionKey: SessionKey, listener: AgentDomainEventListener): () => void;
+  subscribeSessionRun(sessionKey: SessionKey, runId: AgentRunId, listener: AgentDomainEventListener): () => void;
+  subscribeSessionRunUpdates(sessionKey: SessionKey, runId: AgentRunId, listener: AgentRunUpdateListener): () => void;
+  subscribeSessionUpdates(sessionKey: SessionKey, listener: AgentRunUpdateListener): () => void;
+  subscribeUpdates(listener: AgentRunUpdateListener): () => void;
+}
+interface AgentExecutionQueryStoreOptions {
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+}
+declare function createAgentExecutionQueryStore(options?: AgentExecutionQueryStoreOptions): AgentExecutionQueryStore;
+//#endregion
+//#region src/core/application/agent-execution/query/agent-event-notifications.d.ts
+declare function notifyListeners(listeners: Iterable<AgentDomainEventListener>, event: AgentDomainEvent): void;
+declare function notifyUpdateListeners(listeners: Iterable<AgentRunUpdateListener>, update: AgentRunUpdate): void;
+//#endregion
+//#region src/core/application/agent-execution/query/agent-run-projection.d.ts
+declare function toRunUpdate(event: AgentDomainEvent, state: AgentRunState, previousState: AgentRunState | undefined): AgentRunUpdate;
+declare function replayRunUpdates(events: ReadonlyArray<AgentDomainEvent>): ReadonlyArray<AgentRunUpdate>;
+declare function buildRunSnapshot(runId: AgentRunId, events: ReadonlyArray<AgentDomainEvent>, updates: ReadonlyArray<AgentRunUpdate>, state?: AgentRunState, summary?: AgentRunSummary): AgentRunSnapshot;
+//#endregion
+//#region src/core/application/agent-execution/query/agent-session-history.d.ts
+interface AgentSessionHistoryView {
+  readonly history: AgentHistory;
+  readonly latestRunSummary?: AgentRunSummary;
+  readonly runs: ReadonlyArray<AgentRunSummary>;
+  readonly summary?: AgentSessionSummary;
+  readonly transcript: AgentTranscript;
+}
+declare function projectAgentSessionHistory(events: ReadonlyArray<AgentDomainEvent>, runStates: ReadonlyMap<AgentRunId, AgentRunState>, sessionKey: SessionKey): AgentSessionHistoryView;
+declare function buildAgentSessionSnapshot(input: {
+  readonly availability: AgentSessionAvailability;
+  readonly sessionKey: SessionKey;
+  readonly state?: AgentRunState;
+  readonly view: AgentSessionHistoryView;
+}): AgentSessionSnapshot;
+//#endregion
+//#region src/core/application/agent-execution/run-admission/run-admission.d.ts
+/**
+ * Home-wide run admission shared by every foreground/background runtime.
+ *
+ * This is the single execution-side admission mechanism. The Gateway
+ * coordinator wraps it with the model-change request identity and drain
+ * deadline via the `ModelChangeBoundaryPort` adapter in the deployment
+ * boundary; no second counter or parallel lifecycle is created.
+ */
+declare function createRunAdmission(options: RunAdmissionOptions): RunAdmission;
+declare function remainingUntil(clock: ModelChangeClock, deadlineAt: string): number;
+//#endregion
+//#region src/core/application/agent-execution/streaming/agent-run-streams.d.ts
+type AgentPromptExecutor = <R>(command: PromptCommand, emit: (event: AgentDomainEvent, state: AgentRunState, previousState: AgentRunState | undefined) => Effect.Effect<void, unknown, R>, interruptionReason?: string) => Effect.Effect<AgentPromptResult, AgentHarnessError, R>;
+interface AgentRunStreams {
+  events(command: PromptCommand): Stream.Stream<AgentDomainEvent, AgentHarnessError>;
+  text(command: PromptCommand): Stream.Stream<string, AgentHarnessError>;
+  updates(command: PromptCommand): Stream.Stream<AgentRunUpdate, AgentHarnessError>;
+}
+declare function createAgentRunStreams(runPrompt: AgentPromptExecutor): AgentRunStreams;
+//#endregion
+//#region src/core/application/memory/commands/memory-binding.d.ts
+declare function normalizeMemoryBinding(binding: MemoryBinding): MemoryBinding;
+declare function createMemoryNamespace$1(binding: MemoryBinding): string;
+//#endregion
+//#region src/core/application/memory/ports/compactor.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): Effect.Effect<string, unknown>;
+}
+//#endregion
+//#region src/core/application/memory/compaction/compaction-service.d.ts
+interface CompactionSnapshot extends Omit<CompactionInput, "transcript"> {
+  readonly id: string;
+  readonly summary: string;
+}
+interface CompactionService {
+  createCandidate(input: CompactionInput): Effect.Effect<CompactionSnapshot, unknown>;
+  commit(candidateId: string): Effect.Effect<CompactionSnapshot, unknown>;
+  current(instanceId: string, conversationId: string): CompactionSnapshot | undefined;
+}
+declare class CompactionError extends Error {
+  readonly name = "CompactionError";
+}
+declare function createEffectCompactionService(options: {
+  readonly compactor: CompactorPort;
+  readonly identity: {
+    readonly next: () => string;
+  };
+}): CompactionService;
+//#endregion
+//#region src/adapters/outbound/persistence/memory/agent-memory-snapshot-codec.d.ts
+declare const AGENT_MEMORY_JSONL_VERSION = 1;
+declare function encodeAgentMemorySnapshot(snapshot: AgentMemorySnapshot): string;
+declare function decodeAgentMemorySnapshots(raw: string): ReadonlyArray<AgentMemorySnapshot>;
+//#endregion
+//#region src/adapters/outbound/persistence/memory/in-memory-agent-memory-repository.d.ts
+declare function createInMemoryAgentMemoryRepository(options?: {
+  readonly initial?: ReadonlyArray<AgentMemorySnapshot>;
+  readonly persist?: (snapshot: AgentMemorySnapshot) => Effect.Effect<void, unknown>;
+}): AgentMemoryRepository;
+//#endregion
+//#region src/adapters/outbound/persistence/memory/jsonl-agent-memory-repository.d.ts
+declare function openJsonlAgentMemoryRepository(options: Readonly<{
+  readonly filePath: string;
+}>): Effect.Effect<AgentMemoryRepository, unknown>;
+//#endregion
+//#region src/core/application/tool-execution/brokerage/tool-input-digest.d.ts
+declare class InvalidStableJson extends Error {
+  readonly name: string;
+}
+declare class InvalidToolInput extends InvalidStableJson {
+  readonly name = "InvalidToolInput";
+}
+type ToolInputDigest = (canonicalJson: string) => string;
+declare function createToolInputDigest$1(input: unknown, digest: ToolInputDigest): string;
+declare function normalizeStableJson(value: unknown): unknown;
+//#endregion
+//#region src/core/application/tool-execution/operation/tool-operation-ledger.d.ts
+interface ToolOperationLedger$1 {
+  abort(operationId: string, binding: ToolOperationBinding$1): Effect.Effect<void, unknown>;
+  begin(operationId: string, binding: ToolOperationBinding$1): Effect.Effect<ToolOperationBeginResult$1, unknown>;
+  complete(operationId: string, binding: ToolOperationBinding$1, result: unknown): Effect.Effect<void, unknown>;
+  inspect(operationId: string, binding: ToolOperationBinding$1): Effect.Effect<ToolOperationInspectResult$1, unknown>;
+  reconciliationRequired(): ReadonlyArray<ToolOperationRecord$1>;
+  reconcile(input: {
+    readonly action: ToolOperationReconciliationAction;
+    readonly expectedRevision: number;
+    readonly operationId: string;
+    readonly outcome: ToolOperationReconciliationOutcome$1;
+  }): Effect.Effect<ToolOperationRecord$1, unknown>;
+  requireReconciliation(operationId: string, binding: ToolOperationBinding$1, reason: string): Effect.Effect<void, unknown>;
+  unresolvedForSource(sourceMessageId: string): ReadonlyArray<ToolOperationRecord$1>;
+}
+interface ToolOperationLedgerOptions {
+  readonly initial?: ReadonlyArray<ToolOperationRecord$1>;
+  readonly persist?: (record: ToolOperationRecord$1) => Effect.Effect<void, unknown>;
+}
+declare class ToolOperationLedgerError extends Error {
+  readonly name = "ToolOperationLedgerError";
+}
+declare function createToolOperationLedger$1(options?: ToolOperationLedgerOptions): ToolOperationLedger$1;
+//#endregion
+//#region src/core/application/tool-execution/brokerage/tool-broker.d.ts
+interface ToolBrokerOptions {
+  readonly approvals: ToolApprovalService;
+  readonly catalog: ToolCatalog;
+  readonly digest: ToolInputDigest;
+  readonly hostTools?: ReadonlyArray<ToolDescriptor>;
+  readonly operations?: ToolOperationLedger$1;
+  readonly policy: AuthorizationPolicyProvider;
+}
+interface ToolBroker {
+  execute(request: ToolExecutionRequest): Effect.Effect<unknown, unknown>;
+}
+declare class ToolInvocationDenied extends Error {
+  readonly name = "ToolInvocationDenied";
+}
+declare function createToolBroker(options: ToolBrokerOptions): ToolBroker;
+//#endregion
+//#region src/adapters/outbound/persistence/tool-operation/tool-operation-snapshot-codec.d.ts
+declare const TOOL_OPERATION_JSONL_VERSION = 1;
+declare function encodeToolOperationSnapshot(record: ToolOperationRecord$1): string;
+declare function decodeToolOperationSnapshots(raw: string): ReadonlyArray<ToolOperationRecord$1>;
+//#endregion
+//#region src/adapters/outbound/persistence/tool-operation/jsonl-tool-operation-ledger.d.ts
+declare function openJsonlToolOperationLedger(options: {
+  readonly filePath: string;
+}): Effect.Effect<ToolOperationLedger$1, unknown>;
+//#endregion
+//#region src/adapters/outbound/persistence/agent-run/event-log/jsonl-agent-event-log.d.ts
+type AgentEventLogOperation = "append" | "read";
+declare class AgentEventLogStoreError {
+  readonly operation: AgentEventLogOperation;
+  readonly cause: unknown;
+  readonly _tag = "AgentEventLogStoreError";
+  constructor(operation: AgentEventLogOperation, cause: unknown);
+}
+interface AgentEventLog extends AgentDomainEventSink {
+  append(event: AgentDomainEvent): Effect.Effect<void, AgentEventLogStoreError>;
+  readAll(): Effect.Effect<ReadonlyArray<AgentDomainEvent>, AgentEventLogStoreError>;
+  readRun(runId: AgentRunId): Effect.Effect<ReadonlyArray<AgentDomainEvent>, AgentEventLogStoreError>;
+}
+interface JsonlAgentEventLogOptions {
+  readonly filePath: string;
+}
+declare function createJsonlAgentEventLog(options: JsonlAgentEventLogOptions): AgentEventLog;
+//#endregion
+//#region src/testing/fakes.d.ts
+declare function createFixedClock(now: Date): AgentClock;
+declare function createTestClock(initial: Date): AgentClock & {
+  advance(ms: number): void;
+};
+declare function createSequenceRunIds(runIds: ReadonlyArray<AgentRunId>): RunIdGenerator;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/loop/agent-loop-prompt-transformer.d.ts
+declare function createAgentLoopPromptTransformer(options: {
+  readonly loop: AgentLoop$1;
+  readonly transform: (input: AgentLoopInput$1) => Promise<string> | string;
+}): AgentLoop$1;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-harness.d.ts
+interface AgentHarnessOptions$1 {
+  readonly loop: AgentLoop$1;
+  readonly runIds: RunIdGenerator;
+  readonly clock: AgentClock;
+  readonly runTimeoutMs?: number;
+  readonly initialRunStates?: ReadonlyArray<AgentRunState>;
+  readonly initialEvents?: ReadonlyArray<AgentDomainEvent>;
+  readonly eventSinks?: ReadonlyArray<AgentDomainEventSink>;
+}
+declare function createAgentHarness$1(options: AgentHarnessOptions$1): AgentHarness;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-callback-adapters.d.ts
+type AgentDomainEventCallback = (event: AgentDomainEvent) => void | Promise<void>;
+type AgentDomainEventSinkCallback = AgentDomainEventCallback;
+type AgentRunUpdateCallback = (update: AgentRunUpdate) => void | Promise<void>;
+declare function createAgentDomainEventSinkFromCallback(append: AgentDomainEventSinkCallback): AgentDomainEventSink;
+declare function createAgentDomainEventHandler(handle: AgentDomainEventCallback): AgentDomainEventHandler;
+declare function createAgentRunUpdateHandler(handle: AgentRunUpdateCallback): AgentRunUpdateHandler;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/runtime/agent-harness-client.d.ts
+interface AgentRunLookupClient {
+  getRunSummary(runId: AgentRunId): AgentRunSummary | undefined;
+  getRunUpdates(runId: AgentRunId): ReadonlyArray<AgentRunUpdate> | undefined;
+  getRunEvents(runId: AgentRunId): ReadonlyArray<AgentDomainEvent> | undefined;
+  getRunState(runId: AgentRunId): AgentRunState | undefined;
+  getRunSnapshot(runId: AgentRunId): AgentRunSnapshot | undefined;
+}
+interface AgentHarnessClient extends AgentRunLookupClient {
+  readonly harness: AgentHarness;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Promise<boolean>;
+  forSession(sessionKey: SessionKey): AgentSessionClient;
+  getSessionHistory(sessionKey: SessionKey): AgentHistory;
+  getSessionTranscript(sessionKey: SessionKey): AgentTranscript;
+  getSessionSnapshot(sessionKey: SessionKey): AgentSessionSnapshot;
+  getSessionSummary(sessionKey: SessionKey): AgentSessionSummary | undefined;
+  getSessionState(sessionKey: SessionKey): AgentRunState | undefined;
+  getSessionRuns(sessionKey: SessionKey): ReadonlyArray<AgentRunSummary>;
+  getSessionLatestRunSummary(sessionKey: SessionKey): AgentRunSummary | undefined;
+  getSessionLatestRunSnapshot(sessionKey: SessionKey): AgentRunSnapshot | undefined;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunId(): AgentRunId | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentHarnessAvailability;
+  getHistory(): AgentHistory;
+  getState(): AgentRunState;
+  prompt(command: PromptCommand): Promise<AgentPromptResult>;
+  promptRunSnapshot(command: PromptCommand): Promise<AgentRunSnapshot>;
+  promptSnapshot(command: PromptCommand): Promise<AgentSessionSnapshot>;
+  promptText(command: PromptCommand): Promise<string>;
+  promptTurn(command: PromptCommand): Promise<AgentTranscriptTurn>;
+  promptWithEvents(command: PromptCommand, onEvent: AgentDomainEventCallback): Promise<AgentPromptResult>;
+  promptWithText(command: PromptCommand, onTextDelta: AgentTextDeltaCallback): Promise<AgentPromptResult>;
+  promptWithUpdates(command: PromptCommand, onUpdate: AgentRunUpdateCallback): Promise<AgentPromptResult>;
+  stream(command: PromptCommand): AsyncIterable<AgentDomainEvent>;
+  streamText(command: PromptCommand): AsyncIterable<string>;
+  streamUpdates(command: PromptCommand): AsyncIterable<AgentRunUpdate>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, 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 extends AgentRunLookupClient {
+  readonly handle: AgentSessionHandle;
+  readonly sessionKey: SessionKey;
+  cancelActiveRun(reason?: string): Promise<boolean>;
+  cancelRun(runId: AgentRunId, reason?: string): Promise<boolean>;
+  getSnapshot(): AgentSessionSnapshot;
+  getState(): AgentRunState | undefined;
+  getSummary(): AgentSessionSummary | undefined;
+  getTranscript(): AgentTranscript;
+  getRuns(): ReadonlyArray<AgentRunSummary>;
+  getLatestRunSnapshot(): AgentRunSnapshot | undefined;
+  getLatestRunSummary(): AgentRunSummary | undefined;
+  getActiveRun(): ActiveAgentRun | undefined;
+  getActiveRunState(): AgentRunState | undefined;
+  getAvailability(): AgentSessionAvailability;
+  getHistory(): AgentHistory;
+  prompt(text: string): Promise<AgentPromptResult>;
+  promptRunSnapshot(text: string): Promise<AgentRunSnapshot>;
+  promptSnapshot(text: string): Promise<AgentSessionSnapshot>;
+  promptText(text: string): Promise<string>;
+  promptTurn(text: string): Promise<AgentTranscriptTurn>;
+  promptWithEvents(text: string, onEvent: AgentDomainEventCallback): Promise<AgentPromptResult>;
+  promptWithText(text: string, onTextDelta: AgentTextDeltaCallback): Promise<AgentPromptResult>;
+  promptWithUpdates(text: string, onUpdate: AgentRunUpdateCallback): Promise<AgentPromptResult>;
+  stream(text: string): AsyncIterable<AgentDomainEvent>;
+  streamText(text: string): AsyncIterable<string>;
+  streamUpdates(text: string): AsyncIterable<AgentRunUpdate>;
+  subscribe(listener: AgentDomainEventListener): () => void;
+  subscribeRun(runId: AgentRunId, 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/adapters/compatibility/agent-execution/runtime/agent-runtime-primitives.d.ts
+type DefaultAgentHarnessOptions = Omit<AgentHarnessOptions$1, "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/adapters/compatibility/memory/public-contract.d.ts
+/** Legacy Promise API record shape; keep this as an interface for consumer augmentation. */
+interface MemoryRecord {
+  readonly content: string;
+  readonly conversationSafe: boolean;
+  readonly id: string;
+  readonly revision: number;
+  readonly scope: MemoryScope;
+  readonly state: MemoryState;
+  readonly tombstoneReason?: string;
+}
+/** Legacy Promise API snapshot shape; keep this as an interface for consumer augmentation. */
+interface AgentMemorySnapshot$1 {
+  readonly binding: MemoryBinding;
+  readonly record: MemoryRecord;
+}
+/** Promise-based Memory access exposed by the legacy host-tool boundary. */
+interface AgentMemoryHandle$1 extends MemoryHandleContract<MemoryRecord> {}
+/** Consumer-owned Memory service port used by the legacy Promise API. */
+interface AgentMemoryService$1 {
+  bind(binding: MemoryBinding): AgentMemoryHandle$1;
+}
+declare function createMemoryNamespace(binding: MemoryBinding): string;
+declare function restrictMemoryScopesForAudience(scopes: ReadonlyArray<MemoryScope>, audience: MemoryInvocationAudience): ReadonlyArray<MemoryScope>;
+//#endregion
+//#region src/adapters/compatibility/memory/project-memory-prompt-preparer.d.ts
+interface LegacyProjectMemoryRecallOptions {
+  readonly agentId: string;
+  readonly memory: AgentMemoryService$1;
+  readonly projectId: string;
+  readonly maxBytes?: number;
+  readonly maxRecords?: number;
+  readonly identity?: LegacyProjectMemoryRecallIdentity;
+}
+interface LegacyProjectMemoryRecallIdentity {
+  readonly subjectId: string;
+  readonly tenantId: string;
+}
+interface LegacyProjectMemoryPromptInput {
+  readonly invocation?: AgentInvocationOrigin;
+  readonly text: string;
+}
+declare function createLegacyProjectMemoryPromptPreparer(options: LegacyProjectMemoryRecallOptions): (input: LegacyProjectMemoryPromptInput) => Promise<string>;
+//#endregion
+//#region src/adapters/compatibility/memory/rivus-memory-tool.d.ts
+interface LegacyRivusMemoryTool extends MemoryToolContract<MemoryRecord> {}
+declare function createLegacyRivusMemoryTool(memory: AgentMemoryHandle$1 | ReadonlyArray<AgentMemoryHandle$1>): LegacyRivusMemoryTool;
+declare function createLegacyRivusMemoryToolDescriptor(options: {
+  readonly memory: AgentMemoryService$1;
+}): RivusHostToolDescriptor;
+//#endregion
+//#region src/adapters/compatibility/memory/compaction/compaction-service.d.ts
+interface CompactorPort$1 {
+  compact(input: CompactionInput): Promise<string>;
+}
+interface CompactionService$1 {
+  createCandidate(input: CompactionInput): Promise<CompactionSnapshot>;
+  commit(candidateId: string): CompactionSnapshot;
+  current(instanceId: string, conversationId: string): CompactionSnapshot | undefined;
+}
+declare function createCompactionService(options: {
+  readonly compactor: CompactorPort$1;
+}): CompactionService$1;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/public-contract.d.ts
+interface InvocationAuthorityRef$1 extends InvocationAuthorityRef {}
+interface InvocationAuthority$1 extends Omit<InvocationAuthority, "memory" | "toolGrantSet"> {
+  readonly memory?: RivusMemoryAuthority;
+  readonly toolGrantSet: RivusToolGrantSet;
+}
+declare function createInvocationAuthority$1(authority: InvocationAuthority$1): InvocationAuthorityRef$1;
+declare function createToolInputDigest(input: unknown): string;
+declare function requiresToolApproval(risk: RivusToolRisk): boolean;
+//#endregion
+//#region src/adapters/compatibility/tool-execution/tool-operation-ledger.d.ts
+interface ToolOperationBinding extends ToolOperationBinding$1 {}
+type ToolOperationState = ToolOperationState$1;
+interface ToolOperationReconciliation extends ToolOperationReconciliation$1 {}
+interface ToolOperationRecord extends ToolOperationRecord$1 {}
+type ToolOperationReconciliationOutcome = ToolOperationReconciliationOutcome$1;
+type ToolOperationBeginResult = ToolOperationBeginResult$1;
+type ToolOperationInspectResult = ToolOperationInspectResult$1;
+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;
+declare function adaptEffectToolOperationLedger(ledger: ToolOperationLedger$1): ToolOperationLedger;
+declare function toEffectToolOperationLedger(ledger: ToolOperationLedger): ToolOperationLedger$1;
+//#endregion
+export { AGENT_MEMORY_JSONL_VERSION, 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 AgentExecutionControlPort, type AgentExecutionQueryStore, type AgentExecutionQueryStoreOptions, type AgentHarness, type AgentHarnessAvailability, AgentHarnessBusy, type AgentHarnessBusyAvailability, type AgentHarnessClient, type AgentHarnessError, type AgentHarnessIdleAvailability, type AgentHarnessOptions, type AgentHistory, type AgentHistoryEventLog, type AgentInvocationOrigin, type AgentLoop, 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 AgentLoopTurnStart, type AgentMemoryAuthority, type AgentMemoryAuthority as LegacyAgentMemoryAuthority, AgentMemoryError, type AgentMemoryHandle, type AgentMemoryIdentity, type AgentMemoryIdentity as LegacyAgentMemoryIdentity, type AgentMemoryInvocationIdentity, type AgentMemoryRecord, type AgentMemoryRepository, AgentMemoryRepositoryConflict, type AgentMemoryRepositoryRecord, type AgentMemoryService, type AgentMemorySnapshot, type AgentModelContentObserver, type AgentModelExecutionEnded, type AgentModelExecutionEvent, type AgentModelExecutionStarted, type AgentModelInputObservation, type AgentModelOutputObservation, type AgentModelUsage, type AgentPromptExecutor, type AgentPromptResult, type AgentRunAccepted, AgentRunCancelled, type AgentRunCancelled as AgentRunCancelledEvent, type AgentRunCompleted, type AgentRunFailed, type AgentRunId, type AgentRunPhase, type AgentRunSnapshot, type AgentRunState, type AgentRunStreams, type AgentRunSummary, type AgentRunUpdate, type AgentRunUpdateCallback, type AgentRunUpdateHandler, type AgentRunUpdateListener, type AgentRuntime, type AgentSessionAvailability, type AgentSessionBusyAvailability, type AgentSessionClient, type AgentSessionHandle, type AgentSessionHistoryView, type AgentSessionOtherBusyAvailability, type AgentSessionOwnedBusyAvailability, type AgentSessionSnapshot, type AgentSessionSummary, type AgentSkillExecutionEnded, type AgentSkillExecutionStarted, type AgentSkillExecutionState, type AgentSteeringChannel, type AgentTextDeltaCallback, type AgentToolExecutionEnded, type AgentToolExecutionEvent, type AgentToolExecutionStarted, type AgentToolExecutionState, type AgentToolExecutionUpdated, type AgentTranscript, type AgentTranscriptMessage, type AgentTranscriptMessageRole, type AgentTranscriptTurn, type AgentTurnCompleted, type AgentTurnStarted, type AssembledAgentContext, type AssistantTextDelta, type AssistantThinkingDelta, type AuthorizationPolicyProvider, type AuthorizationPolicyState, type AutomationAgentInvocationOrigin, type BackgroundSessionAgentInvocationOrigin, CompactionError, CompactionError as LegacyCompactionError, type CompactionInput, type CompactionInput as LegacyCompactionInput, type CompactionService, type CompactionSnapshot, type CompactionSnapshot as LegacyCompactionSnapshot, type CompactorPort, type DefaultAgentHarnessClientFromCallbackOptions, type DefaultAgentHarnessClientFromTextCallbackOptions, type DefaultAgentHarnessClientOptions, type DefaultAgentHarnessFromCallbackOptions, type DefaultAgentHarnessFromTextCallbackOptions, type DefaultAgentHarnessOptions, type DefaultAgentRuntimeFromCallbackOptions, type DefaultAgentRuntimeFromTextCallbackOptions, type DefaultAgentRuntimeOptions, type DefaultAgentRuntimeSessionOptions, type EventAgentLoopOptions, type FeishuAgentInvocationOrigin, InvalidInvocationAuthority, InvalidInvocationAuthority as LegacyInvalidInvocationAuthority, InvalidRecoveryAction, InvalidStableJson, InvalidStableJson as LegacyInvalidStableJson, InvalidToolInput, InvalidToolInput as LegacyInvalidToolInput, InvalidWorkspaceRoot, type InvocationAuthority, type InvocationAuthorityIdentity, type InvocationAuthorityRef, type InvocationMemoryAuthority, type InvocationMemoryScope, type InvocationToolGrantSet, type JsonlAgentEventLogOptions, type LangfuseAgentTelemetry, type LangfuseTelemetryConfig, LangfuseTelemetryConfigError, type LangfuseTelemetryContentMode, type LangfuseTelemetryEnv, type AgentHarnessOptions$1 as LegacyAgentHarnessOptions, type AgentLoop$1 as LegacyAgentLoop, type AgentLoopCallback as LegacyAgentLoopCallback, type AgentLoopCallbackOutput as LegacyAgentLoopCallbackOutput, type AgentLoopCallbackResult as LegacyAgentLoopCallbackResult, type AgentLoopInput$1 as LegacyAgentLoopInput, type AgentMemoryHandle$1 as LegacyAgentMemoryHandle, type AgentMemoryService$1 as LegacyAgentMemoryService, type AgentMemorySnapshot$1 as LegacyAgentMemorySnapshot, type AgentSteeringChannel$1 as LegacyAgentSteeringChannel, type AsyncIterableAgentLoopOptions as LegacyAsyncIterableAgentLoopOptions, type CompactionService$1 as LegacyCompactionService, type CompactorPort$1 as LegacyCompactorPort, type EventAgentLoopOptions$1 as LegacyEventAgentLoopOptions, type InvocationAuthority$1 as LegacyInvocationAuthority, type InvocationAuthorityRef$1 as LegacyInvocationAuthorityRef, type MemoryBinding as LegacyMemoryBinding, type MemoryBinding, type MemoryInvocationAudience as LegacyMemoryInvocationAudience, type MemoryInvocationAudience, type MemoryRecord as LegacyMemoryRecord, type MemoryScope as LegacyMemoryScope, type MemoryScope, type MemorySearchQuery as LegacyMemorySearchQuery, type MemorySearchQuery, type MemoryState as LegacyMemoryState, type MemoryState, type LegacyProjectMemoryPromptInput, type LegacyProjectMemoryRecallIdentity, type LegacyProjectMemoryRecallOptions, type LegacyRivusMemoryTool, type TextAgentLoopCallback as LegacyTextAgentLoopCallback, type TextAgentLoopOptions as LegacyTextAgentLoopOptions, type ToolOperationBeginResult as LegacyToolOperationBeginResult, type ToolOperationBinding as LegacyToolOperationBinding, type ToolOperationInspectResult as LegacyToolOperationInspectResult, type ToolOperationLedger as LegacyToolOperationLedger, type ToolOperationReconciliation as LegacyToolOperationReconciliation, type ToolOperationReconciliationOutcome as LegacyToolOperationReconciliationOutcome, type ToolOperationRecord as LegacyToolOperationRecord, type ToolOperationState as LegacyToolOperationState, type LocalCliAgentInvocationOrigin, MEMORY_SCOPES, type MemoryHandle, type MemoryIdentity, type MemoryService, type MemoryTombstoneReceipt, type ModelBinding, type ModelChangeActivationResult, ModelChangeBoundaryDeadlineError, type ModelChangeBudgetReservation, type ModelChangeClock, type ModelChangeExecutionBudget, type ModelChangePaidCallKind, type ModelChangeRestoreResult, type ModelChangeRuntimeContext, type ModelChangeRuntimePort, type ModelChangeValidationResult, type ModelReference, type NormalizedAgentInvocation, type OpenTelemetryAgentEventSinkOptions, type OpenTelemetryAgentTelemetry, type PersistedMemoryRecord, type ToolOperation as PersistedToolOperation, type ProjectMemoryPromptInput, type ProjectMemoryRecallIdentity, type ProjectMemoryRecallOptions, type PromptCommand, RIVUS_MEMORY_TOOL_ID, RIVUS_MEMORY_TOOL_PLUGIN_ID, RIVUS_MEMORY_TOOL_VERSION, RIVUS_RUNTIME_TOOL_IDS, type RecoveryAction, type RegisteredRivusSkill, type RegisteredRivusTool, type RivusHostToolDescriptor, type RivusMemoryAuthority, type RivusMemoryScope, type RivusMemoryTool, type RivusResolvedToolDescriptor, type RivusRuntimeToolGrantSet, type RivusRuntimeToolId, type RivusSkillDescriptor, type RivusSkillGrantSet, type RivusToolDescriptor, type RivusToolExecutionContext, type RivusToolExecutionOrigin, type RivusToolExecutor, type RivusToolFactoryContext, type RivusToolGrantSet, type RivusToolGrantSetOperations, type RivusToolIdempotency, RivusToolInputRejected, type RivusToolRisk, type RunAdmission, type RunAdmissionLease, type RunAdmissionOptions, type RunIdGenerator, type SessionKey, type StandardAgentRunResult, TOOL_OPERATION_JSONL_VERSION, type TelemetryContentRedactor, type TelemetryContentRedactorOptions, type TerminalAgentDomainEvent, type TextAgentLoopOptions$1 as TextAgentLoopOptions, type ToolApprovalRequest, type ToolApprovalService, type ToolBroker, type ToolBrokerOptions, type ToolCatalog, type ToolDescriptor, type ToolExecutionContext, type ToolExecutionOrigin, type ToolExecutionRequest, type ToolExecutor, ToolExecutorInputRejected, type ToolIdempotency, type ToolInputDigest, ToolInvocationDenied, type ToolOperationBeginResult$1 as ToolOperationBeginResult, type ToolOperationBinding$1 as ToolOperationBinding, type ToolOperationInspectResult$1 as ToolOperationInspectResult, type ToolOperationLedger$1 as ToolOperationLedger, ToolOperationLedgerError, type ToolOperationLedgerOptions, type ToolOperationReconciliation$1 as ToolOperationReconciliation, type ToolOperationReconciliationAction, type ToolOperationReconciliationOutcome$1 as ToolOperationReconciliationOutcome, type ToolOperationRecord$1 as ToolOperationRecord, type ToolOperationState$1 as ToolOperationState, type ToolRisk, type WorkspaceInstructionSource, type WorkspaceInstructionsDiagnostic, type WorkspaceInstructionsDiagnosticCode, type WorkspaceInstructionsRequest, WorkspaceInstructionsSourceError, type WorkspaceInstructionsSourcePort, type WorkspaceInstructionsSourceRequest, type WorkspaceInstructionsSourceResult, type WorkspaceInstructionsView, type WorkspaceRootHandle, adaptEffectToolOperationLedger as adaptLegacyEffectToolOperationLedger, assembleAgentContext, buildAgentSessionSnapshot, buildRunSnapshot, createAgentConversationMessages, createAgentDomainEventHandler, createAgentDomainEventSink, createAgentDomainEventSinkFromCallback, createAgentExecutionQueryStore, createAgentHarness, createAgentHarnessClient, createAgentLoopModelExecutionEnd, createAgentLoopModelExecutionStart, createAgentLoopSkillExecutionEnd, createAgentLoopSkillExecutionStart, createAgentLoopTextDelta, createAgentLoopThinkingDelta, createAgentLoopToolExecutionEnd, createAgentLoopToolExecutionStart, createAgentLoopToolExecutionUpdate, createAgentLoopTurnStart, createAgentRunStreams, createAgentRunUpdateHandler, createAgentRuntime, createAgentTranscriptMessages, createAgentTranscriptTurn, createAgentsMdInstructionsSource, createDefaultAgentHarness, createDefaultAgentHarnessClient, createDefaultAgentHarnessClientFromCallback, createDefaultAgentHarnessClientFromTextCallback, createDefaultAgentHarnessFromCallback, createDefaultAgentHarnessFromTextCallback, createDefaultAgentRuntime, createDefaultAgentRuntimeFromCallback, createDefaultAgentRuntimeFromTextCallback, createEffectCompactionService, createEventAgentLoop, createFixedClock, createInMemoryAgentMemoryRepository, createInvocationAuthority, createJsonlAgentEventLog, createLangfuseAgentTelemetry, createAgentHarness$1 as createLegacyAgentHarness, createAgentLoopFromCallback as createLegacyAgentLoopFromCallback, createAgentLoopPromptTransformer as createLegacyAgentLoopPromptTransformer, createAsyncIterableAgentLoop as createLegacyAsyncIterableAgentLoop, createCompactionService as createLegacyCompactionService, createEventAgentLoop$1 as createLegacyEventAgentLoop, createInvocationAuthority$1 as createLegacyInvocationAuthority, createMemoryNamespace as createLegacyMemoryNamespace, createLegacyProjectMemoryPromptPreparer, createLegacyRivusMemoryTool, createLegacyRivusMemoryToolDescriptor, createTextAgentLoop as createLegacyTextAgentLoop, createTextAgentLoopFromCallback as createLegacyTextAgentLoopFromCallback, createToolInputDigest as createLegacyToolInputDigest, createToolOperationLedger as createLegacyToolOperationLedger, createMemoryNamespace$1 as createMemoryNamespace, createMemoryService, createOpenTelemetryAgentEventSink, createOpenTelemetryAgentTelemetry, createPersistedMemoryRecord, createProjectMemoryPromptPreparer, createRecoveryAction, createRivusMemoryTool, createRivusMemoryToolContract, createRivusMemoryToolDescriptor, createRunAdmission, createSequenceRunIds, createSystemClock, createTelemetryContentRedactor, createTestClock, createTextAgentLoop$1 as createTextAgentLoop, createToolBroker, createToolInputDigest$1 as createToolInputDigest, createToolOperationLedger$1 as createToolOperationLedger, createUuidRunIds, createWorkspaceInstructionsResolver, createWorkspaceRootHandle, decodeAgentMemorySnapshots, decodeToolOperationSnapshots, describeLoopError, encodeAgentMemorySnapshot, encodeToolOperationSnapshot, evolveAgentRun, fromEffectAgentLoop as fromEffectLegacyAgentLoop, initialAgentRunState, isAgentToolExecutionEvent, isAssistantTextDeltaEvent, isAssistantThinkingDeltaEvent, isRivusRuntimeToolId, isTerminalAgentDomainEvent, isTerminalAgentRunPhase, normalizeAgentInvocation, normalizeAgentLoopEvent, normalizeStableJson as normalizeLegacyStableJson, normalizeStableJson, normalizeMemoryBinding, notifyListeners, notifyUpdateListeners, openJsonlAgentMemoryRepository, openJsonlToolOperationLedger, projectAgentSessionHistory, remainingUntil, replayAgentHistory, replayAgentTranscript, replayRunUpdates, requiresToolApproval as requiresLegacyToolApproval, requiresToolApproval$1 as requiresToolApproval, resolveInvocationAuthority, resolveLangfuseTelemetryConfig, resolveWorkspaceRootPath, restoreAgentHistory, restorePersistedMemoryRecord, restoreToolOperation as restorePersistedToolOperation, restrictMemoryScopesForAudience as restrictLegacyMemoryScopesForAudience, toDomainEvent, toEffectAgentLoop as toEffectLegacyAgentLoop, toEffectAgentLoopInput as toEffectLegacyAgentLoopInput, toEffectToolOperationLedger as toEffectLegacyToolOperationLedger, toCompatibilityAgentLoopInput as toLegacyAgentLoopInput, toRunUpdate };