@rowan-agent/agent 0.7.1 → 0.7.4

package/dist/index.d.ts

@@ -1,252 +1,54 @@
-import * as _rowan_agent_models from '@rowan-agent/models';
-import { LlmRequest, LlmResponse, ModelRef, LlmModelUsage, Outcome, AgentMessage, ToolResult, StreamFn, AgentEventListener, ToolCall, Skill as Skill$1, ContentBlock, ModelConfig } from '@rowan-agent/models';
-export { AgentEvent, AgentEventListener, AgentMessage, ModelConfig, ModelRef, Outcome, Skill, StreamFn, ToolResult } from '@rowan-agent/models';
 import Type from 'typebox';
+import * as _rowan_agent_models from '@rowan-agent/models';
+import { LlmContentPart, ContentBlock, ModelRef, ModelConfig, StreamFn } from '@rowan-agent/models';
+export { ModelConfig, ModelRef, StreamFn } from '@rowan-agent/models';
 
-type ExecutionTurn = {
+type AgentMessage = {
     id: string;
-    sessionId: string;
-    parentSessionId?: string;
-    phase: string;
-    requestedAtMs: number;
-    completedAtMs: number;
-    model: ModelRef;
-    usage?: LlmModelUsage;
-};
-/** Raw model input/output for session persistence. */
-type ModelTranscript = {
-    request: LlmRequest;
-    response: LlmResponse;
-};
-
-declare const opaqueIdBrand: unique symbol;
-type OpaqueId<Kind extends string> = string & {
-    readonly [opaqueIdBrand]: Kind;
-};
-type AgentId = OpaqueId<"AgentId">;
-type AgentRunId = OpaqueId<"AgentRunId">;
-type RuntimeMessageId = OpaqueId<"RuntimeMessageId">;
-type RuntimeEventId = OpaqueId<"RuntimeEventId">;
-type LeaseId = OpaqueId<"LeaseId">;
-type RuntimeToolCallId = OpaqueId<"RuntimeToolCallId">;
-type AgentLifecycleState = "active" | "paused";
-type SessionLifecycleState = "active" | "archived" | "deleting";
-type RuntimeMessageState = "queued" | "leased" | "acknowledged" | "dead_lettered";
-type AgentRunState = "queued" | "running" | "suspended" | "completed" | "failed" | "cancelled";
-/** Opaque execution checkpoint owned by the Agent loop and persisted by Runtime. */
-type AgentRunExecutionState = Readonly<Record<string, unknown>>;
-/** Host-owned correlation data persisted with a Run and echoed by Runtime Events. */
-type AgentRunMetadata = Readonly<Record<string, unknown>>;
-type AgentInputRequest = {
-    phase: string;
-    prompt: string;
-    requestedAt: string;
-};
-type RuntimeToolCallState = "queued" | "running" | "completed" | "failed" | "indeterminate";
-type AgentRecord = {
-    id: AgentId;
-    sessionId: string;
-    state: AgentLifecycleState;
-    lifecycleState: SessionLifecycleState;
-    parentSessionId?: string;
-    createdAt: string;
-    updatedAt: string;
-};
-type RuntimeLease = {
-    id: LeaseId;
-    runId: AgentRunId;
-    workerId: string;
-    leasedAt: string;
-    expiresAt: string;
-};
-type RuntimeMessage = {
-    id: RuntimeMessageId;
-    agentId: AgentId;
-    kind: "agent_input";
-    input: AgentMessage;
-    state: RuntimeMessageState;
-    attempts: number;
-    runId?: AgentRunId;
-    lease?: RuntimeLease;
-    deadLetterReason?: string;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | LlmContentPart[];
     createdAt: string;
-    updatedAt: string;
+    metadata?: Record<string, unknown> & {
+        phase?: string;
+    };
 };
-type AgentRunRecord = {
-    id: AgentRunId;
-    agentId: AgentId;
-    messageId: RuntimeMessageId;
-    state: AgentRunState;
-    attempt: number;
-    leaseId?: LeaseId;
-    outcome?: Outcome;
-    suspensionReason?: string;
-    inputRequest?: AgentInputRequest;
-    executionState?: AgentRunExecutionState;
-    metadata?: AgentRunMetadata;
-    createdAt: string;
-    updatedAt: string;
+type Skill = {
+    name: string;
+    description: string;
+    /** Absolute path to the SKILL.md file */
+    filePath: string;
+    /** Directory containing the SKILL.md file */
+    baseDir: string;
+    /** Full body content of the SKILL.md (after frontmatter) */
+    content: string;
+    disableModelInvocation: boolean;
 };
-type RuntimeEventKind = "agent_created" | "agent_paused" | "agent_resumed" | "session_archived" | "session_unarchived" | "message_enqueued" | "run_enqueued" | "run_leased" | "lease_expired" | "lease_recovered" | "run_suspended" | "run_retry_scheduled" | "run_completed" | "run_aborted" | "message_acknowledged" | "message_dead_lettered" | "tool_call_created" | "tool_call_started" | "tool_call_failed" | "tool_call_completed" | "tool_call_indeterminate";
-type RuntimeEvent = {
-    id: RuntimeEventId;
-    sequence: number;
-    kind: RuntimeEventKind;
-    agentId?: AgentId;
-    messageId?: RuntimeMessageId;
-    runId?: AgentRunId;
-    toolCallId?: RuntimeToolCallId;
+type Outcome$1 = {
+    id: string;
+    message: string;
+    /** Publish this outcome's message as an assistant message before completing the run. */
+    display?: boolean;
     payload?: unknown;
-    createdAt: string;
-};
-type RuntimeEventCursor = {
-    after?: RuntimeEventId;
-    limit?: number;
-};
-type RuntimeEventCheckpoint = {
-    consumerId: string;
-    sequence: number;
-    eventId?: RuntimeEventId;
-    updatedAt: string;
+    toolResults?: Array<{
+        toolCallId: string;
+        toolName: string;
+        ok: boolean;
+        content: unknown;
+        error?: string;
+    }>;
 };
-type RuntimeToolCall = {
-    id: RuntimeToolCallId;
-    agentId: AgentId;
-    runId: AgentRunId;
+type ToolCall = {
+    id: string;
     name: string;
     args: unknown;
-    state: RuntimeToolCallState;
-    result?: ToolResult;
-    indeterminateReason?: string;
-    createdAt: string;
-    updatedAt: string;
-};
-
-type BeforePhaseHook = (phaseId: string, input: PhaseContext) => Promise<BeforePhaseHookResult>;
-type AfterPhaseHook = (phaseId: string, output: PhaseOutput) => Promise<AfterPhaseHookResult>;
-type BeforePromptHook = (phaseId: string, input: PhaseContext) => Promise<PhaseContext>;
-type LoopMetrics = {
-    /** Number of phase iterations executed. */
-    iterations: number;
-    /** Phase transition history. */
-    phaseTransitions: Array<{
-        from: string;
-        to: string;
-        ts: string;
-    }>;
-    /** Number of times compaction was triggered. */
-    compactionCount: number;
-    /** Number of retry attempts due to transient errors. */
-    retryCount: number;
-    /** Loop start timestamp. */
-    startedAt: string;
-    /** Loop start time as epoch ms (for duration calculation). */
-    startedAtMs: number;
-    /** Loop end timestamp (set on completion). */
-    endedAt?: string;
-    /** Total wall-clock duration in ms. */
-    durationMs?: number;
-};
-type SessionState = {
-    currentPhase: string;
-    attempt: number;
-    metrics: LoopMetrics;
-    status: "idle" | "running" | "suspended" | "completed" | "aborted" | "failed";
-    continuation?: SessionContinuationState;
-};
-type SessionContinuationState = {
-    isContinuing: boolean;
-    previousPayload?: unknown;
-    previousResults: Array<{
-        name: string;
-        output?: unknown;
-    }>;
-    pendingInstruction?: string;
-    previousPhaseMessageId?: string;
-};
-type AgentConfig = {
-    model: ModelRef;
-    stream: StreamFn;
-    context: AgentContext;
-    sessionId?: string;
-    sessionState?: SessionState;
-    maxAttempts?: number;
-    runtime?: AgentRuntimePort;
-    emit?: AgentEventListener;
-    signal?: AbortSignal;
-    beforeToolCall?: BeforeToolCall;
-    afterToolCall?: AfterToolCall;
-    beforePhase?: BeforePhaseHook;
-    afterPhase?: AfterPhaseHook;
-    beforePrompt?: BeforePromptHook;
-    onModelTranscript?: (transcript: ModelTranscript, meta: {
-        phase: string;
-        model: ModelRef;
-    }) => Promise<void>;
-    onMessage?: (message: AgentMessage) => Promise<void>;
-    onOutcome?: (outcome: Outcome) => Promise<void>;
-    /** Internal: await next user messages before retrying the same phase. */
-    waitForInput?: (state?: SessionState, inputRequest?: AgentInputRequest) => Promise<AgentMessage[]>;
-};
-type ToolRunnerInput = {
-    config: AgentConfig;
-    toolCall: ToolCall;
-};
-type ToolRunner = (input: ToolRunnerInput) => Promise<ToolResult>;
-type AgentRuntimePort = {
-    tools?: ToolRunner;
 };
-
-type ToolContext = Pick<AgentContext, "skills"> & {
+type ToolResult = {
     toolCallId: string;
+    toolName: string;
+    ok: boolean;
+    content: unknown;
+    error?: string;
 };
-type ToolExecutionMode = "sequential" | "parallel";
-type Tool<TArgs = unknown> = {
-    name: string;
-    description: string;
-    parameters: Type.TSchema;
-    /** One-line snippet shown in the system prompt tool list. */
-    promptSnippet?: string;
-    /** Additional guidelines appended to the system prompt when this tool is active. */
-    promptGuidelines?: string[];
-    /** Whether this tool can run concurrently with others. Default: "parallel". */
-    executionMode?: ToolExecutionMode;
-    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
-};
-/** Context snapshot passed into the low-level agent loop. */
-type AgentContext = {
-    /** System prompt included with the request. */
-    systemPrompt: string;
-    /** Transcript visible to the model. */
-    messages: AgentMessage[];
-    /** Tools available for this run. */
-    tools: Tool[];
-    /** Skills available for this run. */
-    skills: Skill$1[];
-    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
-    phases?: PhaseRegistry;
-};
-type BeforeToolCall = (input: {
-    tool: Tool;
-    args: unknown;
-}) => Promise<{
-    allow: true;
-} | {
-    allow: false;
-    reason: string;
-}>;
-type AfterToolCall = (input: {
-    tool: Tool;
-    result: ToolResult;
-}) => Promise<ToolResult>;
-type RunResult = {
-    sessionId: string;
-    messages: AgentMessage[];
-    outcome: Outcome;
-    metrics: LoopMetrics;
-};
-type Unsubscribe = () => void;
-declare function createMessage(role: AgentMessage["role"], content: AgentMessage["content"], metadata?: Record<string, unknown>): AgentMessage;
 
 type ModelInvokeOutput = {
     text: string;
@@ -271,100 +73,6 @@ type PhaseExecution = {
     executeTool(context: AgentContext, toolCall: ToolCall): Promise<ToolResult>;
 };
 
-/** Unified phase output — model decides routing via route. */
-type PhaseOutput = {
-    message: string;
-    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
-    route: string;
-    /** Phase name that produced this output */
-    phase?: string;
-    /** Tool calls from the model invocation (used by framework for route extraction) */
-    toolCalls?: Array<{
-        id: string;
-        name: string;
-        args: unknown;
-    }>;
-    /** Route reason extracted from route tool call (for hooks to inspect) */
-    routeReason?: string;
-    /** Structured data from this phase, passed to the next phase */
-    payload?: unknown;
-};
-/** Phase machine state — tracks position and inter-phase data */
-interface PhaseState {
-    current: string;
-    available: string[];
-    iterations: number;
-    payload?: unknown;
-}
-type PhaseInvocation = {
-    mode: "serial";
-    instanceId: string;
-} | {
-    mode: "parallel";
-    instanceId: string;
-    groupId: string;
-    index: number;
-    count: number;
-    sourcePhaseId: string;
-};
-/** Everything a phase needs to execute */
-interface PhaseContext {
-    systemPrompt: string;
-    messages: AgentMessage[];
-    /** Phase-filtered tools */
-    tools: Tool[];
-    /** Phase-filtered skills */
-    skills: Skill$1[];
-    /** Phase machine state */
-    state: PhaseState;
-    /** Identity and dispatch metadata for this phase execution */
-    readonly invocation: PhaseInvocation;
-    /** Additional guideline bullets appended to the system prompt */
-    promptGuidelines?: string[];
-    /** Text to append after the system prompt */
-    appendSystemPrompt?: string;
-}
-/**
- * Loaded Phase object
- */
-interface Phase {
-    /** Unique phase identity and display name. */
-    name: string;
-    /** Description */
-    description: string;
-    /** Restricted tools (undefined = all tools available) */
-    tools?: string[];
-    /** Restricted skills (undefined = all skills available) */
-    skills?: string[];
-    /** Forced next phase */
-    target?: string;
-    /** Expected input fields (key → description) */
-    input?: Record<string, string>;
-    /** If true, phase gets a fresh context when executed in parallel */
-    isolated?: boolean;
-    /** Path to PHASE.md file */
-    filePath: string;
-    /** Phase directory path */
-    baseDir: string;
-    /** PHASE.md body content */
-    content: string;
-    /** Model override for this phase (resolved from frontmatter) */
-    model?: ModelRef;
-    /** ExtensionAPI factory function (default export pattern) */
-    factory?: (api: ExtensionAPI) => Promise<void>;
-    /** Direct run function */
-    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
-}
-/**
- * Phase registry containing all loaded phases
- */
-interface PhaseRegistry {
-    /** Map of phase name to Phase object */
-    phases: Map<string, Phase>;
-    /** Entry phase name (null until Agent applies its default phase) */
-    entryPhaseId: string | null;
-}
-
 /**
  * Extension types — simplified for the new hook-based system.
  */
@@ -409,14 +117,14 @@ interface ToolDefinition {
     /** Parameter schema (JSON Schema) */
     parameters: Record<string, unknown>;
     /** Execute the tool */
-    execute: (args: unknown, signal?: AbortSignal) => Promise<ToolExecutionResult>;
+    execute: (args: unknown, signal?: AbortSignal) => Promise<ToolExecutionResult$1>;
     /** Optional: per-tool execution mode override */
     executionMode?: "sequential" | "parallel";
 }
 /**
  * Result from tool execution.
  */
-interface ToolExecutionResult {
+interface ToolExecutionResult$1 {
     /** Content blocks to return to the LLM */
     content: Array<{
         type: string;
@@ -441,19 +149,6 @@ type ExecResult = {
     stdout: string;
     stderr: string;
 };
-type BeforePhaseHookResult = {
-    abort?: Outcome;
-    skip?: {
-        route: string;
-        message: string;
-    };
-    input?: PhaseContext;
-};
-type AfterPhaseHookResult = {
-    abort?: Outcome;
-    retry?: PhaseContext;
-    output?: PhaseOutput;
-};
 /**
  * Result of loading extensions from filesystem.
  * The runner takes these and creates Extension tracking objects.
@@ -518,376 +213,63 @@ interface EventBus {
     count(event: string): number;
 }
 
-/**
- * @module extensions/hooks
- *
- * Type-safe hook system
- *
- * ## Overview
- *
- * The hook system allows extensions to intercept and modify Agent behavior at specific points.
- *
- * ## Hook Categories
- *
- * ### Modifiable (return result to change behavior)
- *
- * | Hook | Return | Effect |
- * |------|--------|--------|
- * | `before_phase` | `{ abort?, skip?, input? }` | Abort, skip, or modify phase input |
- * | `after_phase` | `{ abort?, retry?, output? }` | Abort, retry, or replace phase output |
- * | `before_prompt` | `{ input? }` | Modify input sent to LLM |
- * | `before_tool_call` | `{ allow, reason? }` | Allow/block tool execution |
- * | `after_tool_call` | `{ result? }` | Modify tool execution result |
- *
- * ### Listen-only (return void)
- *
- * | Hook | Trigger |
- * |------|---------|
- * | `agent_start` | Agent starts |
- * | `agent_end` | Agent ends |
- * | `turn_start` | Conversation turn starts |
- * | `turn_end` | Conversation turn ends |
- * | `message_start` | Message streaming starts |
- * | `message_update` | Message streaming update |
- * | `message_end` | Message completes |
- * | `tool_execution_start` | Tool execution starts |
- * | `tool_execution_update` | Tool execution progress update |
- * | `tool_execution_end` | Tool execution completes |
- * | `queue_update` | Queue state update |
- * | `save_point` | Session save point |
- * | `abort` | Agent aborted |
- * | `settled` | Agent idle |
- *
- * ## Usage Example
- *
- * ```typescript
- * import type { ExtensionAPI } from "@rowan-agent/agent";
- *
- * export default function(api: ExtensionAPI) {
- *   // Block dangerous tools
- *   api.on("before_tool_call", (event) => {
- *     if (event.tool.name === "bash") {
- *       const cmd = (event.args as any).command;
- *       if (cmd.includes("rm -rf")) {
- *         return { allow: false, reason: "Dangerous command" };
- *       }
- *     }
- *     return { allow: true };
- *   });
- *
- *   // Inject context
- *   api.on("before_prompt", (event) => {
- *     return {
- *       input: {
- *         ...event.input,
- *         systemPrompt: event.input.systemPrompt + "\n\nExtra context",
- *       },
- *     };
- *   });
- *
- *   // Log tool calls
- *   api.on("tool_execution_end", (event) => {
- *     console.log(`Tool ${event.toolName}: ${event.result.ok ? "success" : "failed"}`);
- *   });
- * }
- * ```
- */
-
-/**
- * before_phase event - triggered before phase execution
- *
- * Return `{ abort }` to abort the agent.
- * Return `{ skip: { route, message } }` to skip the phase.
- * Return `{ input }` to replace the phase input.
- */
 interface BeforePhaseEvent {
     type: "before_phase";
-    /** Phase name about to execute */
     phaseId: string;
-    /** Phase input */
     input: PhaseContext;
 }
-/**
- * after_phase event - triggered after phase execution
- *
- * Return `{ abort }` to abort the agent.
- * Return `{ retry }` to re-execute the phase with new input.
- * Return `{ output }` to replace the phase output.
- */
 interface AfterPhaseEvent {
     type: "after_phase";
-    /** Phase name that completed */
     phaseId: string;
-    /** Phase output */
     output: PhaseOutput;
 }
-/**
- * before_prompt event - triggered before building LLM request
- *
- * Return `{ input }` to replace the input sent to LLM.
- */
 interface BeforePromptEvent {
     type: "before_prompt";
-    /** Current phase name */
     phaseId: string;
-    /** Phase input (modifiable) */
     input: PhaseContext;
 }
-/**
- * before_tool_call event - triggered before tool execution
- *
- * Return `{ allow: false, reason }` to block execution.
- * Return `{ allow: true }` to allow execution.
- */
 interface BeforeToolCallEvent {
     type: "before_tool_call";
-    /** Tool definition */
-    tool: Tool;
-    /** Tool arguments */
+    tool: Tool$1;
     args: unknown;
 }
-/**
- * after_tool_call event - triggered after tool execution
- *
- * Return `{ result }` to replace the tool execution result.
- */
 interface AfterToolCallEvent {
     type: "after_tool_call";
-    /** Tool definition */
-    tool: Tool;
-    /** Tool execution result */
+    tool: Tool$1;
     result: ToolResult;
 }
-/**
- * agent_start event - triggered when agent starts
- */
-interface AgentStartEvent {
-    type: "agent_start";
-    /** Session ID */
-    sessionId: string;
+type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
+interface BeforePhaseResult {
+    abort?: Outcome$1;
+    skip?: {
+        route: string;
+        message: string;
+    };
+    input?: PhaseContext;
 }
-/**
- * agent_end event - triggered when agent ends
- */
-interface AgentEndEvent {
-    type: "agent_end";
-    /** Session ID */
-    sessionId: string;
-    /** Execution outcome */
-    outcome: Outcome;
-    /** All messages */
-    messages: AgentMessage[];
+interface AfterPhaseResult {
+    abort?: Outcome$1;
+    retry?: PhaseContext;
+    output?: PhaseOutput;
 }
-/**
- * turn_start event - triggered when conversation turn starts
- */
-interface TurnStartEvent {
-    type: "turn_start";
-    /** Current message list */
-    messages: AgentMessage[];
-}
-/**
- * turn_end event - triggered when conversation turn ends
- */
-interface TurnEndEvent {
-    type: "turn_end";
-    /** Message list */
-    messages: AgentMessage[];
-    /** Turn outcome (optional) */
-    outcome?: Outcome;
-}
-/**
- * message_start event - triggered when message streaming starts
- */
-interface MessageStartEvent {
-    type: "message_start";
-    /** Message object */
-    message: AgentMessage;
-}
-/**
- * message_update event - triggered on message streaming update
- */
-interface MessageUpdateEvent {
-    type: "message_update";
-    /** Message object */
-    message: AgentMessage;
-    /** Delta text */
-    delta: string;
-}
-/**
- * message_end event - triggered when message completes
- */
-interface MessageEndEvent {
-    type: "message_end";
-    /** Message object */
-    message: AgentMessage;
-}
-/**
- * tool_execution_start event - triggered when tool execution starts
- */
-interface ToolExecutionStartEvent {
-    type: "tool_execution_start";
-    /** Tool call ID */
-    toolCallId: string;
-    /** Tool name */
-    toolName: string;
-    /** Tool arguments */
-    args: unknown;
-}
-/**
- * tool_execution_update event - triggered on tool execution progress
- */
-interface ToolExecutionUpdateEvent {
-    type: "tool_execution_update";
-    /** Tool call ID */
-    toolCallId: string;
-    /** Tool name */
-    toolName: string;
-}
-/**
- * tool_execution_end event - triggered when tool execution completes
- */
-interface ToolExecutionEndEvent {
-    type: "tool_execution_end";
-    /** Tool call ID */
-    toolCallId: string;
-    /** Tool name */
-    toolName: string;
-    /** Tool execution result */
-    result: ToolResult;
-}
-/**
- * queue_update event - triggered on queue state update
- */
-interface QueueUpdateEvent {
-    type: "queue_update";
-    /** Pending message count */
-    pendingCount: number;
-}
-/**
- * save_point event - triggered at session save point
- */
-interface SavePointEvent {
-    type: "save_point";
-    /** Whether there are pending mutations */
-    hadPendingMutations: boolean;
-}
-/**
- * abort event - triggered when agent is aborted
- */
-interface AbortEvent {
-    type: "abort";
-    /** Abort reason */
-    reason?: string;
-}
-/**
- * settled event - triggered when agent is idle
- */
-interface SettledEvent {
-    type: "settled";
-}
-/** Union type of all hook events */
-type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent | AgentStartEvent | AgentEndEvent | TurnStartEvent | TurnEndEvent | MessageStartEvent | MessageUpdateEvent | MessageEndEvent | ToolExecutionStartEvent | ToolExecutionUpdateEvent | ToolExecutionEndEvent | QueueUpdateEvent | SavePointEvent | AbortEvent | SettledEvent;
-/**
- * before_phase hook return value
- *
- * - `abort`: Abort the entire agent
- * - `skip`: Skip current phase, route to specified phase
- * - `input`: Replace phase input
- */
-interface BeforePhaseResult {
-    /** Abort agent */
-    abort?: Outcome;
-    /** Skip current phase */
-    skip?: {
-        route: string;
-        message: string;
-    };
-    /** Replace phase input */
-    input?: PhaseContext;
-}
-/**
- * after_phase hook return value
- *
- * - `abort`: Abort the entire agent
- * - `retry`: Re-execute phase with new input
- * - `output`: Replace phase output
- */
-interface AfterPhaseResult {
-    /** Abort agent */
-    abort?: Outcome;
-    /** Re-execute phase */
-    retry?: PhaseContext;
-    /** Replace phase output */
-    output?: PhaseOutput;
-}
-/**
- * before_prompt hook return value
- *
- * - `input`: Replace input sent to LLM
- */
 interface BeforePromptResult {
-    /** Replace phase input */
     input?: PhaseContext;
 }
-/**
- * before_tool_call hook return value
- *
- * - `allow`: Whether to allow execution
- * - `reason`: Rejection reason (when allow=false)
- */
 interface BeforeToolCallResult {
-    /** Whether to allow execution */
     allow: boolean;
-    /** Rejection reason */
     reason?: string;
 }
-/**
- * after_tool_call hook return value
- *
- * - `result`: Replace tool execution result
- */
 interface AfterToolCallResult {
-    /** Replace tool execution result */
     result?: ToolResult;
 }
-/**
- * Hook result mapping table.
- *
- * Defines the return type for each hook event:
- * - Modifiable hooks return specific objects
- * - Listen-only hooks return undefined
- */
 interface HookResultMap {
     before_phase: BeforePhaseResult | undefined;
     after_phase: AfterPhaseResult | undefined;
     before_prompt: BeforePromptResult | undefined;
     before_tool_call: BeforeToolCallResult | undefined;
     after_tool_call: AfterToolCallResult | undefined;
-    agent_start: undefined;
-    agent_end: undefined;
-    turn_start: undefined;
-    turn_end: undefined;
-    message_start: undefined;
-    message_update: undefined;
-    message_end: undefined;
-    tool_execution_start: undefined;
-    tool_execution_update: undefined;
-    tool_execution_end: undefined;
-    queue_update: undefined;
-    save_point: undefined;
-    abort: undefined;
-    settled: undefined;
 }
-/** Hook event type string */
 type HookEventType = HookEvent["type"];
-/**
- * Hook handler type.
- *
- * @typeParam K - Hook event type
- * @param event - Event object
- * @returns Result object or void
- */
 type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
     type: K;
 }>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
@@ -1019,11 +401,6 @@ interface ExtensionAPI {
     context: ExtensionContext;
     /** Shared event bus for inter-extension communication. */
     events: EventBus;
-    /** Session context — provides access to the session-level AgentContext. */
-    session: {
-        /** Get the current session AgentContext */
-        getContext(): AgentContext;
-    };
     /** Phase execution capabilities — rovides Phase In/Out, phase identity, and phase routing. */
     phase: {
         /** Phase In: get payload from previous phase */
@@ -1048,657 +425,1299 @@ interface ExtensionAPI {
  */
 type ExtensionFactory = (api: ExtensionAPI) => void | Promise<void>;
 
-/**
- * Load all phases from the target directory.
- *
- * Scans for subdirectories containing PHASE.md files.
- * Returns PhaseRegistry with entryPhaseId:
- * - null by default (caller must explicitly set to start from a specific phase)
- * - Set to a specific phase name to start from that phase
- *
- * When entryPhaseId is null, Agent normalizes the registry to start from its default phase.
- */
-declare function loadPhases(targetPath: string): Promise<PhaseRegistry>;
-
-type AgentExecutionOptions = StreamAgentOptions & {
-    sessionId?: string;
-    agentId?: AgentId;
-    sessionState?: SessionState;
-    onInput?: (message: AgentMessage) => Promise<void>;
-    runtime?: AgentRuntimePort;
-};
-type RunOptions = Partial<AgentExecutionOptions>;
-type RuntimeRunHooks = {
-    onSuspend?: (reason?: string, state?: SessionState, inputRequest?: AgentInputRequest) => Promise<void> | void;
-};
-type AgentStatus = {
-    agentId?: AgentId;
-    sessionId?: string;
-    context: AgentContext;
-    model: ModelRef;
-    tools: Tool[];
-    initialized: boolean;
-    running: boolean;
-    currentResult?: RunResult;
-    error?: string;
+/** Unified phase output — model decides routing via route. */
+type PhaseOutput = {
+    message: string;
+    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end */
+    route: string;
+    /** Phase name that produced this output */
+    phase?: string;
+    /** Tool calls from the model invocation (used by framework for route extraction) */
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        args: unknown;
+    }>;
+    /** Route reason extracted from route tool call (for hooks to inspect) */
+    routeReason?: string;
+    /** Structured data from this phase, passed to the next phase */
+    payload?: unknown;
 };
-declare class AgentExecution {
-    readonly state: AgentStatus;
-    private options;
-    private readonly listeners;
-    private readonly pendingListenerTasks;
-    private readonly listenerErrors;
-    private activeRun?;
-    private extensionRunner?;
-    private loadedExtensions?;
-    private loadedExtensionsCwd?;
-    private runtimeRunId?;
-    get id(): AgentId;
-    get sessionId(): string;
-    static loadSkills(targetPath: string): Promise<AgentContext["skills"]>;
-    static loadPhases(targetPath: Parameters<typeof loadPhases>[0]): Promise<PhaseRegistry>;
-    static loadExtensions(targetPath: string): Promise<LoadExtensionsResult>;
-    constructor(options: AgentExecutionOptions);
-    subscribe(listener: AgentEventListener): Unsubscribe;
-    appendUserMessage(input: string): void;
-    appendMessage(message: AgentMessage): void;
-    appendMessages(messages: AgentMessage[]): void;
-    runWithUserInput(input: string, options?: RunOptions): Promise<RunResult>;
-    runWithMessage(message: AgentMessage, options?: RunOptions, internalHooks?: RuntimeRunHooks): Promise<RunResult>;
-    /** Internal Runtime seam: executes one leased Agent Input. */
-    executeAgentInput(input: AgentMessage, runId: AgentRunId, control: AgentRunControl, executionState?: AgentRunExecutionState): Promise<Outcome>;
-    resetInitialization(): void;
-    getContext(): AgentContext;
-    setContext(context: AgentContext): void;
-    updateContext(updater: (context: AgentContext) => AgentContext): void;
-    forkContext(overrides?: Partial<AgentContext>): AgentContext;
-    getMessages(): AgentMessage[];
-    setMessages(messages: AgentMessage[]): void;
-    clearMessages(): void;
-    getTranscript(): AgentMessage[];
-    replaceTranscript(messages: AgentMessage[]): void;
-    getConfig(): AgentExecutionOptions;
-    setConfig(config: AgentExecutionOptions): void;
-    updateConfig(updater: (config: AgentExecutionOptions) => AgentExecutionOptions): void;
-    setSessionId(sessionId: string): void;
-    getSessionId(): string | undefined;
-    getAgentId(): AgentId | undefined;
-    /** Internal Runtime hook for associating Tool Calls with the leased Run. */
-    getRuntimeRunId(): AgentRunId | undefined;
-    setModel(model: ModelRef): void;
-    setTools(tools: Tool[]): void;
-    setSkills(skills: Skill$1[]): void;
-    setPhases(phases: PhaseRegistry): void;
-    setCwd(cwd: string): void;
-    setStream(stream: StreamFn): void;
-    getModel(): ModelRef;
-    getTools(): Tool[];
-    getSkills(): Skill$1[];
-    getPhases(): PhaseRegistry | undefined;
-    getCwd(): string | undefined;
-    private emitToListeners;
-    flushEvents(): Promise<void>;
-    private processEvents;
-    /**
-     * Hook for before_tool_call — called before a tool executes.
-     * Extensions can block execution by setting allow=false.
-     */
-    private handleBeforeToolCall;
-    /**
-     * Hook for after_tool_call — called after a tool executes.
-     * Extensions can mutate the result.
-     */
-    private handleAfterToolCall;
-    /**
-     * Hook for before_phase — called before a phase executes.
-     * Extensions can abort, skip, or replace the phase input.
-     */
-    private handleBeforePhase;
-    /**
-     * Hook for after_phase — called after a phase executes.
-     * Extensions can abort, retry, or replace the output.
-     */
-    private handleAfterPhase;
-    /**
-     * Hook for before_prompt — called before model request, allowing extensions to transform PhaseContext.
-     * Extensions can transform the PhaseContext (messages, tools, systemPrompt, etc.).
-     */
-    private handleBeforePrompt;
-    private handleRunFailure;
-    private runWithLifecycle;
-    private finishRun;
-    private loadExtensions;
-    run(config?: RunOptions, internalHooks?: RuntimeRunHooks): Promise<RunResult>;
-    abort(reason?: string): void;
-    isSuspended(): boolean;
-    private abortLocal;
-    /** Internal Runtime hook; public callers abort a precise AgentRun. */
-    abortFromRuntime(reason?: string): void;
-    /**
-     * Get formatted skill content for LLM consumption.
-     *
-     * Finds the skill by name and returns the formatted content using `formatSkillInvocation`.
-     * This is a programmatic API for developers to invoke skills directly.
-     *
-     * @param name - The skill name to look up
-     * @param additionalInstructions - Optional additional instructions to append
-     * @returns Formatted skill content string
-     */
-    skill(name: string, additionalInstructions?: string): string;
-    /**
-     * Get formatted phase content for LLM consumption.
-     *
-     * Finds the phase by name and returns the formatted content.
-     * This is a programmatic API for developers to invoke phases directly.
-     *
-     * @param name - The phase name to look up
-     * @returns Formatted phase content string, or empty string if not found
-     */
-    phase(name: string): Promise<string>;
-    waitForIdle(): Promise<void>;
-    private resolveRunConfig;
-    private createContextSnapshot;
-    private cloneOptions;
+/** Phase machine state — tracks position and inter-phase data */
+interface PhaseState {
+    current: string;
+    available: string[];
+    iterations: number;
+    payload?: unknown;
 }
-
-declare const SkillSchema: Type.TObject<{
-    name: Type.TString;
-    description: Type.TString;
-    filePath: Type.TString;
-    baseDir: Type.TString;
-    content: Type.TString;
-    disableModelInvocation: Type.TBoolean;
-}>;
-type Skill = Type.Static<typeof SkillSchema>;
-
-type SessionHeader = {
-    type: "header";
-    id: string;
-    version: string;
-    createdAt: string;
-    updatedAt: string;
-    systemPrompt: string;
-    input: string;
-    parentSessionId?: string;
-    skills: Skill[];
-    title?: string;
-    currentLeafId?: string | null;
+type PhaseInvocation = {
+    mode: "serial";
+    instanceId: string;
+} | {
+    mode: "parallel";
+    instanceId: string;
+    groupId: string;
+    index: number;
+    count: number;
+    sourcePhaseId: string;
 };
-type SessionAgentContext<TTool = unknown> = {
+/** Everything a phase needs to execute */
+interface PhaseContext {
     systemPrompt: string;
     messages: AgentMessage[];
-    tools: TTool[];
+    /** Phase-filtered tools */
+    tools: Tool$1[];
+    /** Phase-filtered skills */
     skills: Skill[];
-};
-type BuildAgentContextInput<TTool = unknown> = {
-    leafId?: string | null;
-    tools?: TTool[];
-    skills?: Skill[];
-};
-type CreateSessionManagerInput = {
-    id?: string;
-    systemPrompt: string;
-    input: string;
-    parentSessionId?: string;
-    skills?: Skill[];
-    title?: string;
-};
-type SessionListItem = {
-    id: string;
-    title?: string;
-    createdAt: string;
-    updatedAt: string;
-    messageCount: number;
-    latestMessage?: string;
-};
-type SessionManager = {
-    getSessionId(): string;
-    getHeader(): Promise<SessionHeader>;
-    appendMessage(message: AgentMessage): Promise<string>;
-    appendOutcome(outcome: Outcome): Promise<string>;
-    appendModelTranscript(transcript: ModelTranscript, meta?: {
-        phase?: string;
-        model?: ModelRef;
-    }): Promise<string>;
-    buildAgentContext<TTool = unknown>(input?: BuildAgentContextInput<TTool>): Promise<SessionAgentContext<TTool>>;
-};
-type SessionManagerProvider = {
-    create(input: CreateSessionManagerInput): Promise<SessionManager>;
-    open(sessionId: string): Promise<SessionManager | undefined>;
-    list(): Promise<SessionListItem[]>;
-    delete(sessionId: string): Promise<boolean>;
-};
+    /** Phase machine state */
+    state: PhaseState;
+    /** Identity and dispatch metadata for this phase execution */
+    readonly invocation: PhaseInvocation;
+    /** Additional guideline bullets appended to the system prompt */
+    promptGuidelines?: string[];
+    /** Text to append after the system prompt */
+    appendSystemPrompt?: string;
+}
+/**
+ * Loaded Phase object
+ */
+interface Phase {
+    /** Unique phase identity and display name. */
+    name: string;
+    /** Description */
+    description: string;
+    /** Restricted tools (undefined = all tools available) */
+    tools?: string[];
+    /** Restricted skills (undefined = all skills available) */
+    skills?: string[];
+    /** Forced next phase */
+    target?: string;
+    /** Expected input fields (key → description) */
+    input?: Record<string, string>;
+    /** If true, phase gets a fresh context when executed in parallel */
+    isolated?: boolean;
+    /** Path to PHASE.md file */
+    filePath: string;
+    /** Phase directory path */
+    baseDir: string;
+    /** PHASE.md body content */
+    content: string;
+    /** Model override for this phase (resolved from frontmatter) */
+    model?: ModelRef;
+    /** ExtensionAPI factory function (default export pattern) */
+    factory?: (api: ExtensionAPI) => Promise<void>;
+    /** Direct run function */
+    run?: (context: PhaseContext, execution: PhaseExecution) => Promise<PhaseOutput | void>;
+}
+/**
+ * Phase registry containing all loaded phases
+ */
+interface PhaseRegistry {
+    /** Map of phase name to Phase object */
+    phases: Map<string, Phase>;
+    /** Entry phase name (null until Agent applies its default phase) */
+    entryPhaseId: string | null;
+}
 
-type CreateAgentInput = {
-    sessionId: string;
-    parentSessionId?: string;
-};
-type EnqueueAgentInput = {
-    agentId: AgentId;
-    input: AgentMessage;
-};
-type AcknowledgeEventAndEnqueueAgentInput = EnqueueAgentInput & {
-    consumerId: string;
-    eventId: RuntimeEventId;
-};
-type EnqueuedAgentInput = {
-    message: RuntimeMessage;
-    run: AgentRunRecord;
-    resumed: boolean;
-};
-type AcknowledgeEventAndEnqueueAgentInputResult = {
-    checkpoint: RuntimeEventCheckpoint;
-    enqueued?: EnqueuedAgentInput;
-};
-type ListRunsInput = {
-    agentId?: AgentId;
-    states?: AgentRunRecord["state"][];
-};
-type RecordRuntimeEventInput = {
-    kind: RuntimeEventKind;
-    related?: Pick<RuntimeEvent, "agentId" | "messageId" | "runId" | "toolCallId">;
-    payload?: unknown;
-};
-type LeaseRunInput = {
-    runId: AgentRunId;
-    workerId: string;
-    leaseDurationMs: number;
-    now?: Date;
-};
-type LeasedRun = {
-    run: AgentRunRecord;
-    message: RuntimeMessage;
-    lease: RuntimeLease;
-};
-type RenewLeaseInput = {
-    runId: AgentRunId;
-    leaseId: LeaseId;
-    leaseDurationMs: number;
-    now?: Date;
-};
-type SuspendRunInput = {
-    runId: AgentRunId;
-    reason?: string;
-    inputRequest?: AgentInputRequest;
-    executionState?: AgentRunExecutionState;
-};
-type CompleteRunInput = {
-    runId: AgentRunId;
-    outcome: Outcome;
-    state?: Extract<AgentRunRecord["state"], "completed" | "failed" | "cancelled">;
-};
-type RetryRunInput = {
-    runId: AgentRunId;
-    reason: string;
-};
-type ExhaustRunInput = {
-    runId: AgentRunId;
-    outcome: Outcome;
-    reason: string;
-};
-type AbortRunInput = {
-    runId: AgentRunId;
-    outcome: Outcome;
+type ToolContext = Pick<AgentContext, "skills"> & {
+    toolCallId: string;
 };
-type CreateToolCallInput = {
-    agentId: AgentId;
-    runId: AgentRunId;
+type ToolExecutionMode = "sequential" | "parallel";
+type Tool$1<TArgs = unknown> = {
     name: string;
-    args: unknown;
-};
-type CompleteToolCallInput = {
-    toolCallId: RuntimeToolCallId;
-    result: ToolResult;
-    state?: Extract<RuntimeToolCall["state"], "completed" | "failed">;
+    description: string;
+    parameters: Type.TSchema;
+    /** One-line snippet shown in the system prompt tool list. */
+    promptSnippet?: string;
+    /** Additional guidelines appended to the system prompt when this tool is active. */
+    promptGuidelines?: string[];
+    /** Whether this tool can run concurrently with others. Default: "parallel". */
+    executionMode?: ToolExecutionMode;
+    execute(args: TArgs, context: ToolContext, signal?: AbortSignal): Promise<ToolResult>;
 };
-type IndeterminateToolCallInput = {
-    toolCallId: RuntimeToolCallId;
-    reason: string;
+/** Context snapshot passed into the low-level agent loop. */
+type AgentContext = {
+    /** System prompt included with the request. */
+    systemPrompt: string;
+    /** Transcript visible to the model. */
+    messages: AgentMessage[];
+    /** Tools available for this run. */
+    tools: Tool$1[];
+    /** Skills available for this run. */
+    skills: Skill[];
+    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
+    phases?: PhaseRegistry;
 };
-interface RuntimeStateStore {
-    createAgent(input: CreateAgentInput): Promise<AgentRecord>;
-    getAgent(agentId: AgentId): Promise<AgentRecord | undefined>;
-    listAgents(): Promise<AgentRecord[]>;
-    setAgentState(agentId: AgentId, state: AgentLifecycleState): Promise<AgentRecord>;
-    setAgentLifecycleState(agentId: AgentId, state: SessionLifecycleState): Promise<AgentRecord>;
-    getAgentBySessionId(sessionId: string): Promise<AgentRecord | undefined>;
-    deleteAgentData(agentId: AgentId): Promise<void>;
-    enqueueAgentInput(input: EnqueueAgentInput): Promise<EnqueuedAgentInput>;
-    getMessage(messageId: RuntimeMessageId): Promise<RuntimeMessage | undefined>;
-    getRun(runId: AgentRunId): Promise<AgentRunRecord | undefined>;
-    listRuns(input?: ListRunsInput): Promise<AgentRunRecord[]>;
-    listActiveRuns(): Promise<AgentRunRecord[]>;
-    leaseRun(input: LeaseRunInput): Promise<LeasedRun>;
-    renewLease(input: RenewLeaseInput): Promise<RuntimeLease>;
-    suspendRun(input: SuspendRunInput): Promise<AgentRunRecord>;
-    completeRun(input: CompleteRunInput): Promise<AgentRunRecord>;
-    retryRun(input: RetryRunInput): Promise<AgentRunRecord>;
-    exhaustRun(input: ExhaustRunInput): Promise<AgentRunRecord>;
-    abortRun(input: AbortRunInput): Promise<AgentRunRecord>;
-    recoverExpiredLeases(now?: Date): Promise<AgentRunRecord[]>;
-    recoverLeases(): Promise<AgentRunRecord[]>;
-    createToolCall(input: CreateToolCallInput): Promise<RuntimeToolCall>;
-    startToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall>;
-    completeToolCall(input: CompleteToolCallInput): Promise<RuntimeToolCall>;
-    markToolCallIndeterminate(input: IndeterminateToolCallInput): Promise<RuntimeToolCall>;
-    getToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall | undefined>;
-    listEvents(cursor?: RuntimeEventCursor): Promise<RuntimeEvent[]>;
-    recordEvent(input: RecordRuntimeEventInput): Promise<RuntimeEvent>;
-    getEventCheckpoint(consumerId: string): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEvent(consumerId: string, eventId: RuntimeEventId): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEventAndEnqueueAgentInput(input: AcknowledgeEventAndEnqueueAgentInput): Promise<AcknowledgeEventAndEnqueueAgentInputResult>;
-}
 
-type ToolRuntimePolicy = {
-    /** A narrowing allow-list. It can never add a Tool to an Agent. */
-    allowedTools?: readonly string[];
-    maxConcurrent?: number;
-    perToolMaxConcurrent?: Readonly<Record<string, number>>;
+type CoreToolContext = {
+    root?: string;
+    maxReadBytes?: number;
+    bashTimeoutMs?: number;
+    maxBashOutputBytes?: number;
 };
 
-type AgentRuntimeOptions = {
-    stateStore: RuntimeStateStore;
-    sessionProvider?: SessionManagerProvider;
-    toolPolicy?: ToolRuntimePolicy;
-    maxConcurrentRuns?: number;
-    maxInfrastructureAttempts?: number;
-    leaseDurationMs?: number;
-    leaseRenewalIntervalMs?: number;
-};
-type RuntimeRunHandle = {
-    notify(run: AgentRunRecord): void;
+/** Durable and transient DTOs owned by the event-driven Agent Runtime. */
+declare const opaqueIdBrand: unique symbol;
+type OpaqueId<Kind extends string> = string & {
+    readonly [opaqueIdBrand]: Kind;
 };
-type RuntimeEventDisposition = {
-    type: "enqueue";
+type AgentId = OpaqueId<"AgentId">;
+type RunId = OpaqueId<"RunId">;
+type MessageId = OpaqueId<"MessageId">;
+type InputRequestId = OpaqueId<"InputRequestId">;
+type ToolCallId = OpaqueId<"ToolCallId">;
+type EventId = OpaqueId<"EventId">;
+type ExecutionId = OpaqueId<"ExecutionId">;
+type OutcomeId = OpaqueId<"OutcomeId">;
+type ConfigToken = OpaqueId<"ConfigToken">;
+type OwnerToken = OpaqueId<"OwnerToken">;
+type EventCursor = OpaqueId<"EventCursor">;
+type AgentListCursor = OpaqueId<"AgentListCursor">;
+type RunListCursor = OpaqueId<"RunListCursor">;
+type JsonPrimitive = null | boolean | number | string;
+type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+type JsonObject = Readonly<Record<string, JsonValue>>;
+type Metadata = JsonObject;
+type TextContent = Readonly<{
+    type: "text";
+    text: string;
+}>;
+type ImageContent = Readonly<{
+    type: "image";
+    data: string;
+    mimeType: string;
+}>;
+type ThinkingContent = Readonly<{
+    type: "thinking";
+    thinking: string;
+    signature?: string;
+}>;
+type ToolUseContent = Readonly<{
+    type: "tool_use";
+    toolCallId: ToolCallId;
+    name: string;
+    input: JsonValue;
+}>;
+type ToolExecutionResult = Readonly<{
+    ok: true;
+    content: JsonValue;
+}> | Readonly<{
+    ok: false;
+    content: JsonValue;
+    error: string;
+}>;
+type DurableToolResult = Readonly<{
+    toolCallId: ToolCallId;
+    toolName: string;
+}> & ToolExecutionResult;
+type ToolResultContent = Readonly<{
+    type: "tool_result";
+    toolCallId: ToolCallId;
+    result: ToolExecutionResult;
+}>;
+type UserContent = string | readonly (TextContent | ImageContent)[];
+type AssistantContent = string | readonly (TextContent | ThinkingContent | ToolUseContent)[];
+type ToolMessageContent = readonly [ToolResultContent, ...ToolResultContent[]];
+type MessageContent = UserContent | AssistantContent | ToolMessageContent;
+type MessageBase = Readonly<{
+    id: MessageId;
     agentId: AgentId;
-    input: AgentMessage;
-};
-type RuntimeEventListener = (event: RuntimeEvent) => RuntimeEventDisposition | void | Promise<RuntimeEventDisposition | void>;
-type RuntimeEventConsumer = {
-    caughtUp: Promise<void>;
-    stop(): void;
-};
-type RuntimeSessionSummary = {
-    id: string;
-    state: SessionLifecycleState;
+    runId: RunId;
+    metadata?: Metadata;
+    sequenceWithinRun: number;
+    createdAt: string;
+}>;
+type UserMessage = MessageBase & Readonly<{
+    role: "user";
+    content: UserContent;
+}>;
+type AssistantMessage = MessageBase & Readonly<{
+    role: "assistant";
+    content: AssistantContent;
+}>;
+type ToolMessage = MessageBase & Readonly<{
+    role: "tool";
+    content: ToolMessageContent;
+}>;
+type Message = UserMessage | AssistantMessage | ToolMessage;
+type Outcome = Readonly<{
+    id: OutcomeId;
+    message: string;
+    payload?: JsonValue;
+    toolResults?: readonly DurableToolResult[];
+}>;
+type RunState = "queued" | "running" | "input_required" | "completed" | "failed" | "cancelled";
+type RunFailure = Readonly<{
+    code: "configuration_unavailable";
+    message: string;
+}> | Readonly<{
+    code: "checkpoint_incompatible";
+    message: string;
+    expected: Readonly<{
+        codec: string;
+        versions: readonly number[];
+    }>;
+    actual: Readonly<{
+        codec: string;
+        version: number;
+    }>;
+}> | Readonly<{
+    code: "runtime_interrupted";
+    message: string;
+    ownerEpoch: number;
+}> | Readonly<{
+    code: "tool_indeterminate";
+    message: string;
+    toolCallIds: readonly [ToolCallId, ...ToolCallId[]];
+}> | Readonly<{
+    code: "execution_failed";
+    message: string;
+    details?: JsonValue;
+}>;
+type QueuedRunFailure = Extract<RunFailure, {
+    code: "configuration_unavailable" | "checkpoint_incompatible";
+}>;
+type RunningRunFailure = Extract<RunFailure, {
+    code: "runtime_interrupted" | "tool_indeterminate" | "execution_failed";
+}>;
+type ToolCallState = "pending" | "running" | "completed" | "failed" | "indeterminate";
+type ToolCallSnapshotBase = Readonly<{
+    id: ToolCallId;
+    agentId: AgentId;
+    runId: RunId;
+    executionId: ExecutionId;
+    requestMessageId: MessageId;
+    name: string;
+    args: JsonValue;
     createdAt: string;
     updatedAt: string;
-    archivedAt?: string;
-    parentSessionId?: string;
+}>;
+type ToolCallSnapshot = ToolCallSnapshotBase & (Readonly<{
+    state: "pending";
+}> | Readonly<{
+    state: "running";
+}> | Readonly<{
+    state: "completed";
+    result: DurableToolResult & Readonly<{
+        ok: true;
+    }>;
+    resultMessageId: MessageId;
+}> | Readonly<{
+    state: "failed";
+    result: DurableToolResult & Readonly<{
+        ok: false;
+    }>;
+    resultMessageId: MessageId;
+}> | Readonly<{
+    state: "indeterminate";
+    result: DurableToolResult & Readonly<{
+        ok: false;
+    }>;
+    resultMessageId: MessageId;
+    reason: string;
+}>);
+type DurableEventBase = Readonly<{
+    id: EventId;
+    schemaVersion: 1;
+    cursor: EventCursor;
+    durability: "durable";
     agentId: AgentId;
-    activeRunCount: number;
-    title?: string;
-};
-declare class AgentRuntime {
-    private readonly stateStore;
-    private readonly sessionProvider?;
-    private readonly maxConcurrentRuns;
-    private readonly maxInfrastructureAttempts;
-    private readonly leaseDurationMs;
-    private readonly leaseRenewalIntervalMs;
-    private readonly toolRuntime;
-    private readonly bindings;
-    private readonly agents;
-    private readonly invalidatedAgents;
-    private readonly runHandles;
-    private readonly runWaiters;
-    private readonly pendingRuns;
-    private readonly scheduledRunIds;
-    private readonly runningAgents;
-    private readonly pausedAgents;
-    private readonly eventSubscriptions;
-    private readonly activeDispatches;
-    private runningRuns;
-    private pumping;
-    private nextWorkerId;
-    private leaseRecoveryTimer;
-    private stopped;
-    private constructor();
-    static start(options: AgentRuntimeOptions): Promise<AgentRuntime>;
-    createAgent(options: AgentOptions): Promise<Agent>;
-    reconstructAgent(agentId: AgentId, options: AgentOptions): Promise<Agent>;
-    stop(): Promise<void>;
-    private bindAgent;
-    private registerRunHandle;
-    private waitForRunChange;
-    private scheduleRun;
-    pauseAgent(agentId: AgentId): Promise<void>;
-    resumeAgent(agentId: AgentId): Promise<void>;
-    getRun(runId: AgentRunId): Promise<AgentRunRecord | undefined>;
-    listActiveRuns(): Promise<AgentRunRecord[]>;
-    listRuns(input?: ListRunsInput): Promise<AgentRunRecord[]>;
-    listSessions(input?: {
-        state?: SessionLifecycleState;
-    }): Promise<RuntimeSessionSummary[]>;
-    archiveSession(sessionId: string): Promise<void>;
-    unarchiveSession(sessionId: string): Promise<void>;
-    deleteSession(sessionId: string): Promise<void>;
-    private requireSessionAgent;
-    getAgent(agentId: AgentId): Agent | undefined;
-    getMessage(messageId: RuntimeMessageId): Promise<RuntimeMessage | undefined>;
-    getToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall | undefined>;
-    abortRun(runId: AgentRunId, reason?: string): Promise<void>;
-    consumeEvents(consumerId: string, listener: RuntimeEventListener): RuntimeEventConsumer;
-    private registerEventConsumer;
-    listEvents(cursor?: RuntimeEventCursor): Promise<RuntimeEvent[]>;
-    private recover;
-    private startLeaseRecovery;
-    private recoverExpiredLeases;
-    private scheduleQueuedRuns;
-    private attachAgent;
-    private submitAgentInput;
-    private pump;
-    private dispatchRun;
-    private finishRun;
-    private finishFailedRun;
-    private notifyRun;
-    private publishEvents;
-    private deliverEvents;
-    private assertRunning;
-}
-
-type AgentRunListener = (state: AgentRunState) => void | Promise<void>;
-type AgentRunHost = {
-    register(handle: RuntimeRunHandle): void;
-    getRun(runId: AgentRunId): Promise<AgentRunRecord | undefined>;
-    waitForRunChange(runId: AgentRunId, state: AgentRunState, updatedAt: string): Promise<void>;
-    abortRun(runId: AgentRunId, reason: string): Promise<void>;
-    consumeEvents(consumerId: string, listener: RuntimeEventListener): RuntimeEventConsumer;
-};
-declare const CREATE_AGENT_RUN: unique symbol;
-declare class AgentRun implements RuntimeRunHandle {
-    private readonly host;
-    private readonly publicMessageId;
-    private current;
-    private readonly listeners;
-    private constructor();
-    static [CREATE_AGENT_RUN](host: AgentRunHost, initial: AgentRunRecord, publicMessageId: string): AgentRun;
-    get id(): AgentRunId;
-    get messageId(): string;
-    get status(): AgentRunState;
-    get state(): AgentRunState;
-    get inputRequest(): AgentInputRequest | undefined;
-    getStatus(): Promise<AgentRunState>;
-    subscribe(listener: AgentRunListener): () => void;
-    consumeRuntimeEvents(consumerId: string, listener: RuntimeEventListener): RuntimeEventConsumer;
-    result(): Promise<Outcome>;
-    abort(reason?: string): Promise<void>;
-    notify(run: AgentRunRecord): void;
-}
+    runId: RunId;
+    runRevision: number;
+    metadata?: Metadata;
+    createdAt: string;
+}>;
+type MessageCommitted = DurableEventBase & Readonly<{
+    kind: "message_committed";
+    message: Message;
+}>;
+type RunTransitioned = DurableEventBase & (Readonly<{
+    kind: "run_transitioned";
+    from: null;
+    to: "queued";
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "input_required";
+    to: "queued";
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "queued";
+    to: "running";
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "running";
+    to: "input_required";
+    request: Readonly<{
+        id: InputRequestId;
+        prompt: AssistantMessage;
+    }>;
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "running";
+    to: "completed";
+    outcome: Outcome;
+    output?: AssistantMessage;
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "queued";
+    to: "failed";
+    failure: QueuedRunFailure;
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "running";
+    to: "failed";
+    failure: RunningRunFailure;
+}> | Readonly<{
+    kind: "run_transitioned";
+    from: "queued" | "running" | "input_required";
+    to: "cancelled";
+    reason?: string;
+}>);
+type ToolStateChanged = DurableEventBase & (Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: null;
+        to: "pending";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "pending";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "pending";
+        to: "running";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "running";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "pending";
+        to: "failed";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "failed";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "running";
+        to: "completed";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "completed";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "running";
+        to: "failed";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "failed";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "running";
+        to: "indeterminate";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "indeterminate";
+    }>;
+}>);
+type DurableRunEvent = MessageCommitted | RunTransitioned | ToolStateChanged;
 
-type AgentCommonOptions = {
-    context: AgentContext;
+type UserInput = string | Readonly<{
+    content: UserContent;
+    metadata?: Metadata;
+}>;
+type ToolInvocationContext = Readonly<{
+    agentId: AgentId;
+    runId: RunId;
+    toolCallId: ToolCallId;
+}>;
+type Tool = Readonly<{
+    name: string;
+    description: string;
+    parameters: Type.TSchema;
+    execute(args: JsonValue, context: ToolInvocationContext, signal: AbortSignal): Promise<ToolExecutionResult>;
+}>;
+type BeforeToolCall = (input: Readonly<{
+    tool: Tool;
+    args: JsonValue;
+    context: ToolInvocationContext;
+    signal: AbortSignal;
+}>) => Readonly<{
+    allow: true;
+}> | Readonly<{
+    allow: false;
+    reason: string;
+}> | Promise<Readonly<{
+    allow: true;
+}> | Readonly<{
+    allow: false;
+    reason: string;
+}>>;
+type AfterToolCall = (input: Readonly<{
+    tool: Tool;
+    result: ToolExecutionResult;
+    context: ToolInvocationContext;
+    signal: AbortSignal;
+}>) => ToolExecutionResult | Promise<ToolExecutionResult>;
+type AgentDefinitionContext = Readonly<{
+    systemPrompt: string;
+    tools: readonly Tool[];
+    skills: readonly Skill[];
+    phases?: PhaseRegistry;
+}>;
+type AgentConfig = Readonly<{
+    identity: string;
+    context: AgentDefinitionContext;
     cwd?: string;
-    extensions?: LoadedExtension[];
+    extensions?: readonly LoadedExtension[];
     maxAttempts?: number;
     beforeToolCall?: BeforeToolCall;
     afterToolCall?: AfterToolCall;
-    onMessage?: (message: AgentMessage) => Promise<void>;
-    onOutcome?: (outcome: Outcome) => Promise<void>;
-    onModelTranscript?: (transcript: ModelTranscript, meta: {
-        phase: string;
-        model: ModelRef;
-    }) => Promise<void>;
-};
-type AgentModelOptions = {
+} & ({
     model: ModelConfig;
     stream?: never;
 } | {
     model: ModelRef;
     stream: StreamFn;
-};
-type AgentOptions = AgentCommonOptions & AgentModelOptions;
-type StreamAgentOptions = AgentCommonOptions & {
-    model: ModelRef;
-    stream: StreamFn;
-};
-type AgentRunControl = {
-    suspend(reason?: string, state?: AgentRunExecutionState, inputRequest?: AgentInputRequest): Promise<void>;
-};
-declare const ATTACH_AGENT: unique symbol;
-declare class Agent {
-    readonly id: AgentId;
-    readonly sessionId: string;
-    private readonly execution;
-    private readonly submitInput;
-    private constructor();
-    static [ATTACH_AGENT](id: AgentId, sessionId: string, execution: AgentExecution, submitInput: (input: AgentMessage) => Promise<AgentRun>): Agent;
-    static loadSkills(targetPath: string): Promise<AgentContext["skills"]>;
-    static loadPhases(targetPath: Parameters<typeof AgentExecution.loadPhases>[0]): Promise<PhaseRegistry>;
-    static loadExtensions(targetPath: string): Promise<LoadExtensionsResult>;
-    subscribe(listener: AgentEventListener): Unsubscribe;
-    flushEvents(): Promise<void>;
-    send(input: string | AgentMessage): Promise<AgentRun>;
+})>;
+type AgentRecord = Readonly<{
+    id: AgentId;
+    metadata?: Metadata;
+    currentConfigToken?: ConfigToken;
+    currentConfigIdentity?: string;
+    createdAt: string;
+    activatedAt?: string;
+    updatedAt: string;
+}>;
+type ExecutionToken = Readonly<{
+    runId: RunId;
+    ownerEpoch: number;
+    executionId: ExecutionId;
+}>;
+type ExecutionCheckpoint = Readonly<{
+    codec: string;
+    version: number;
+    data: JsonValue;
+}>;
+type InputRequest = Readonly<{
+    id: InputRequestId;
+    messageId: MessageId;
+    createdAt: string;
+}>;
+type OwnerLease = Readonly<{
+    ownerId: string;
+    token: OwnerToken;
+    epoch: number;
+    expiresAt: string;
+}>;
+type RunClaim = Readonly<{
+    run: RunRecord;
+    execution: ExecutionToken;
+    history: readonly Message[];
+}>;
+type InputRequiredCommit = Readonly<{
+    run: RunRecord;
+    prompt: AssistantMessage;
+    request: InputRequest;
+}>;
+type ToolCommit = Readonly<{
+    run: RunRecord;
+    toolCall: ToolCallSnapshot;
+}>;
+type RunRecord = Readonly<{
+    id: RunId;
+    agentId: AgentId;
+    agentSequence: number;
+    readySequence: number;
+    revision: number;
+    state: RunState;
+    input: UserInput;
+    metadata?: Metadata;
+    pinnedConfigToken?: ConfigToken;
+    checkpoint?: ExecutionCheckpoint;
+    openInputRequest?: InputRequest;
+    execution?: ExecutionToken;
+    outcome?: Outcome;
+    failure?: RunFailure;
+    cancellationReason?: string;
+    createdAt: string;
+    updatedAt: string;
+}>;
+type AgentSummary = Readonly<{
+    id: AgentId;
+    metadata?: Metadata;
+    currentConfigIdentity?: string;
+    createdAt: string;
+    activatedAt: string;
+    updatedAt: string;
+}>;
+type RunSummary = Readonly<{
+    id: RunId;
+    agentId: AgentId;
+    agentSequence: number;
+    state: RunState;
+    metadata?: Metadata;
+    createdAt: string;
+    updatedAt: string;
+}>;
+type Page<T, Cursor> = Readonly<{
+    items: readonly T[];
+    next?: Cursor;
+}>;
+type RunSnapshotBase = Readonly<{
+    runId: RunId;
+    agentId: AgentId;
+    agentSequence: number;
+    revision: number;
+    input: UserInput;
+    metadata?: Metadata;
+    messageCount: number;
+    toolCallCount: number;
+    createdAt: string;
+    updatedAt: string;
+    cursor: EventCursor;
+}>;
+type RunSnapshot = RunSnapshotBase & (Readonly<{
+    state: "queued" | "running";
+}> | Readonly<{
+    state: "input_required";
+    request: Readonly<{
+        id: InputRequestId;
+        prompt: AssistantMessage;
+    }>;
+}> | Readonly<{
+    state: "completed";
+    outcome: Outcome;
+    output?: AssistantMessage;
+}> | Readonly<{
+    state: "failed";
+    failure: RunFailure;
+}> | Readonly<{
+    state: "cancelled";
+    reason?: string;
+}>);
+type RunBoundary = Readonly<{
+    type: "input_required";
+    requestId: InputRequestId;
+    prompt: AssistantMessage;
+}> | Readonly<{
+    type: "completed";
+    outcome: Outcome;
+    output?: AssistantMessage;
+}> | Readonly<{
+    type: "failed";
+    failure: RunFailure;
+}> | Readonly<{
+    type: "cancelled";
+    reason?: string;
+}>;
+type ConfigResolution = Readonly<{
+    kind: "available";
+    config: AgentConfig;
+} | {
+    kind: "deferred";
+    retryAfterMs?: number;
+} | {
+    kind: "unavailable";
+    reason: string;
+}>;
+type ConfigPutResult = Readonly<{
+    kind: "stored";
+    token: string;
+} | {
+    kind: "identity_conflict";
+}>;
+interface ConfigProvider {
+    put(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        config: AgentConfig;
+        operationId: string;
+        signal: AbortSignal;
+    }): Promise<ConfigPutResult>;
+    resolve(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        token: ConfigToken;
+        signal: AbortSignal;
+    }): Promise<ConfigResolution>;
 }
-
-declare class InMemorySessionStore implements SessionManagerProvider {
-    private readonly sessions;
-    create(input: CreateSessionManagerInput): Promise<SessionManager>;
-    open(sessionId: string): Promise<SessionManager | undefined>;
-    list(): Promise<{
-        id: string;
-        title: string | undefined;
-        createdAt: string;
-        updatedAt: string;
-        messageCount: any;
-    }[]>;
-    delete(sessionId: string): Promise<boolean>;
+interface OwnedStore {
+    readonly lease: OwnerLease;
+    reserveAgent(input: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+        configIdentity?: string;
+    }): Promise<AgentRecord>;
+    activateAgent(agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
+    updateAgentConfigToken(input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): Promise<AgentRecord>;
+    createRun(input: {
+        agentId: AgentId;
+        input: UserInput;
+        metadata?: Metadata;
+        idempotencyKey: string;
+    }): Promise<RunRecord>;
+    claimRun(input: {
+        runId: RunId;
+        expectedRevision: number;
+        executionId?: ExecutionId;
+        messageId?: MessageId;
+        configToken?: ConfigToken;
+    }): Promise<RunClaim>;
+    failQueuedRun(input: {
+        runId: RunId;
+        expectedRevision: number;
+        failure: QueuedRunFailure;
+    }): Promise<RunRecord>;
+    commitInputRequired(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestId?: InputRequestId;
+        prompt: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+    }): Promise<InputRequiredCommit>;
+    answerInput(input: {
+        runId: RunId;
+        requestId: InputRequestId;
+        expectedRevision: number;
+        input: UserInput;
+        messageId?: MessageId;
+    }): Promise<RunRecord>;
+    commitOutcome(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        outcome?: Outcome;
+        failure?: RunFailure;
+        output?: AssistantMessage;
+    }): Promise<RunRecord>;
+    reserveToolCall(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        name: string;
+        args: JsonValue;
+        toolCallId?: ToolCallId;
+    }): Promise<ToolCommit>;
+    startToolCall(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
+    commitToolResult(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolExecutionResult;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+    }): Promise<ToolCommit>;
+    cancelRun(input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+    }): Promise<RunRecord>;
+    snapshotRun(runId: RunId): Promise<RunSnapshot>;
+    listAgents(): Promise<readonly AgentRecord[]>;
+    listRuns(input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+    }): Promise<readonly RunRecord[]>;
+    listEvents(input?: {
+        after?: EventCursor;
+    }): Promise<readonly DurableRunEvent[]>;
+    openConsumer(consumerId: string): Promise<ConsumerRegistration>;
+    advanceConsumerCheckpoint(input: {
+        consumerId: string;
+        cursor: EventCursor;
+    }): Promise<void>;
+    renewOwner(leaseMs: number): Promise<OwnerLease>;
+    sealAndReleaseOwner(): Promise<void>;
+}
+interface DurableStore {
+    openOwner(input: {
+        ownerId: string;
+        leaseMs: number;
+    }): Promise<OwnedStore>;
+}
+type AgentRuntimeOptions = Readonly<{
+    store: DurableStore;
+    configs?: ConfigProvider;
+    concurrency?: number;
+}>;
+type DurableConsumer = Readonly<{
+    caughtUp: Promise<void>;
+    done: Promise<void>;
+    stop(): void;
+}>;
+interface AgentRun {
+    readonly id: RunId;
+    snapshot(): Promise<RunSnapshot>;
+    observe(options?: {
+        after?: EventCursor;
+        signal?: AbortSignal;
+    }): AsyncIterable<DurableRunEvent>;
+    wait(options?: {
+        signal?: AbortSignal;
+    }): Promise<RunBoundary>;
+    respond(input: {
+        requestId: InputRequestId;
+        input: UserInput;
+    }): Promise<void>;
+    cancel(reason?: string): Promise<RunBoundary>;
 }
-declare class JsonlSessionStore implements SessionManagerProvider {
-    private readonly sessionsDir;
-    constructor(sessionsDir: string);
-    create(input: CreateSessionManagerInput): Promise<SessionManager>;
-    open(sessionId: string): Promise<SessionManager | undefined>;
-    list(): Promise<SessionListItem[]>;
-    delete(sessionId: string): Promise<boolean>;
+interface AgentRuntime$1 {
+    createAgent(config: AgentConfig, options?: {
+        idempotencyKey?: string;
+        metadata?: Metadata;
+    }): Promise<AgentId>;
+    updateAgentConfig(agentId: AgentId, config: AgentConfig, options: {
+        idempotencyKey: string;
+    }): Promise<void>;
+    start(agentId: AgentId, input: UserInput, options: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+    }): Promise<AgentRun>;
+    run(runId: RunId): AgentRun;
+    listAgents(input?: {
+        after?: AgentListCursor;
+        limit?: number;
+    }): Promise<Page<AgentSummary, AgentListCursor>>;
+    listRuns(input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+        after?: RunListCursor;
+        limit?: number;
+    }): Promise<Page<RunSummary, RunListCursor>>;
+    consume(input: {
+        consumerId: string;
+        signal: AbortSignal;
+        onEvent(event: DurableRunEvent, context: Readonly<{
+            signal: AbortSignal;
+        }>): void | Promise<void>;
+    }): Promise<DurableConsumer>;
+    close(): Promise<void>;
 }
+type ConsumerRegistration = Readonly<{
+    cursor?: EventCursor;
+    waterline: EventCursor;
+}>;
 
-type CoreToolContext = {
-    root?: string;
-    maxReadBytes?: number;
-    bashTimeoutMs?: number;
-    maxBashOutputBytes?: number;
-};
-declare function createCoreTools(input?: CoreToolContext): Tool[];
+declare class AgentRuntime implements AgentRuntime$1 {
+    private readonly concurrency;
+    private readonly owned;
+    private readonly commands;
+    private readonly storeIncarnation;
+    private readonly activeAgents;
+    private readonly executions;
+    private readonly consumers;
+    private heartbeat?;
+    private pumping;
+    private closed;
+    private constructor();
+    static init(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+    createAgent(config: AgentConfig, options?: {
+        idempotencyKey?: string;
+        metadata?: Metadata;
+    }): Promise<AgentId>;
+    updateAgentConfig(agentId: AgentId, config: AgentConfig, options: {
+        idempotencyKey: string;
+    }): Promise<void>;
+    start(agentId: AgentId, input: UserInput, options: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+    }): Promise<AgentRun>;
+    run(runId: RunId): AgentRun;
+    listAgents(input?: {
+        after?: AgentListCursor;
+        limit?: number;
+    }): Promise<Page<AgentSummary, AgentListCursor>>;
+    listRuns(input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+        after?: RunListCursor;
+        limit?: number;
+    }): Promise<Page<RunSummary, RunListCursor>>;
+    consume(input: {
+        consumerId: string;
+        signal: AbortSignal;
+        onEvent(event: DurableRunEvent, context: Readonly<{
+            signal: AbortSignal;
+        }>): void | Promise<void>;
+    }): Promise<DurableConsumer>;
+    close(): Promise<void>;
+    snapshot(runId: RunId): Promise<RunSnapshot>;
+    respond(runId: RunId, input: {
+        requestId: InputRequestId;
+        input: UserInput;
+    }): Promise<void>;
+    cancel(runId: RunId, reason?: string): Promise<RunBoundary>;
+    private pump;
+    private execute;
+    private failQueued;
+    private executeTool;
+    private requireAgent;
+    private runConsumer;
+    observe(runId: RunId, options?: {
+        after?: EventCursor;
+        signal?: AbortSignal;
+    }): AsyncIterable<DurableRunEvent>;
+    wait(runId: RunId, options?: {
+        signal?: AbortSignal;
+    }): Promise<RunBoundary>;
+    private assertOpen;
+    private startHeartbeat;
+}
 
-declare class InMemoryRuntimeStateStore implements RuntimeStateStore {
+type IdempotencyReceipt = {
+    payload: string;
+    result: unknown;
+};
+type InMemoryStoreState = Readonly<{
+    incarnation: string;
+    agents: readonly AgentRecord[];
+    runs: readonly RunRecord[];
+    messages: readonly Message[];
+    toolCalls: readonly ToolCallSnapshot[];
+    events: readonly DurableRunEvent[];
+    idempotency: readonly (readonly [string, IdempotencyReceipt])[];
+    operationReceipts: readonly (readonly [string, IdempotencyReceipt])[];
+    consumerCheckpoints: readonly (readonly [string, EventCursor])[];
+    nextAgentSequence: readonly (readonly [AgentId, number])[];
+    nextReadySequence: readonly (readonly [AgentId, number])[];
+    eventSequence: number;
+}>;
+declare class InMemoryStore implements DurableStore {
+    private readonly incarnation;
     private readonly agents;
-    private readonly messages;
     private readonly runs;
+    private readonly messages;
     private readonly toolCalls;
     private readonly events;
-    private readonly eventCheckpoints;
-    createAgent(input: CreateAgentInput): Promise<AgentRecord>;
-    getAgent(agentId: AgentId): Promise<AgentRecord | undefined>;
-    getAgentBySessionId(sessionId: string): Promise<AgentRecord | undefined>;
-    listAgents(): Promise<AgentRecord[]>;
-    setAgentState(agentId: AgentId, state: AgentRecord["state"]): Promise<AgentRecord>;
-    setAgentLifecycleState(agentId: AgentId, state: AgentRecord["lifecycleState"]): Promise<AgentRecord>;
-    deleteAgentData(agentId: AgentId): Promise<void>;
-    enqueueAgentInput(input: EnqueueAgentInput): Promise<EnqueuedAgentInput>;
-    private enqueueAgentInputState;
-    getMessage(messageId: RuntimeMessageId): Promise<RuntimeMessage | undefined>;
-    getRun(runId: AgentRunId): Promise<AgentRunRecord | undefined>;
-    listRuns(input?: ListRunsInput): Promise<AgentRunRecord[]>;
-    listActiveRuns(): Promise<AgentRunRecord[]>;
-    leaseRun(input: LeaseRunInput): Promise<LeasedRun>;
-    renewLease(input: RenewLeaseInput): Promise<RuntimeLease>;
-    suspendRun(input: SuspendRunInput): Promise<AgentRunRecord>;
-    completeRun(input: CompleteRunInput): Promise<AgentRunRecord>;
-    retryRun(input: RetryRunInput): Promise<AgentRunRecord>;
-    exhaustRun(input: ExhaustRunInput): Promise<AgentRunRecord>;
-    abortRun(input: AbortRunInput): Promise<AgentRunRecord>;
-    recoverExpiredLeases(input?: Date): Promise<AgentRunRecord[]>;
-    recoverLeases(): Promise<AgentRunRecord[]>;
-    createToolCall(input: CreateToolCallInput): Promise<RuntimeToolCall>;
-    startToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall>;
-    completeToolCall(input: CompleteToolCallInput): Promise<RuntimeToolCall>;
-    markToolCallIndeterminate(input: IndeterminateToolCallInput): Promise<RuntimeToolCall>;
-    getToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall | undefined>;
-    listEvents(cursor?: RuntimeEventCursor): Promise<RuntimeEvent[]>;
-    recordEvent(input: RecordRuntimeEventInput | RuntimeEventKind, related?: Pick<RuntimeEvent, "agentId" | "messageId" | "runId" | "toolCallId">, payload?: unknown): Promise<RuntimeEvent>;
-    getEventCheckpoint(consumerId: string): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEvent(consumerId: string, eventId: RuntimeEventId): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEventAndEnqueueAgentInput(input: AcknowledgeEventAndEnqueueAgentInput): Promise<AcknowledgeEventAndEnqueueAgentInputResult>;
+    private readonly idempotency;
+    private readonly operationReceipts;
+    private readonly consumerCheckpoints;
+    private readonly nextAgentSequence;
+    private readonly nextReadySequence;
+    private owner?;
+    private ownerEpoch;
+    private eventSequence;
+    constructor(options?: {
+        incarnation?: string;
+    });
+    static fromState(state: InMemoryStoreState): InMemoryStore;
+    exportState(): InMemoryStoreState;
+    attachOwner(lease: OwnerLease): void;
+    interruptOwner(ownerEpoch: number, message?: string): void;
+    openOwner(input: {
+        ownerId: string;
+        leaseMs: number;
+    }): Promise<OwnedStore>;
+    assertOwner(lease: OwnerLease): void;
+    renewOwner(lease: OwnerLease, leaseMs: number): OwnerLease;
+    releaseOwner(lease: OwnerLease): void;
+    reserveAgent(lease: OwnerLease, input: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+        configIdentity?: string;
+    }): AgentRecord;
+    activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): AgentRecord;
+    updateAgentConfigToken(lease: OwnerLease, input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): AgentRecord;
+    createRun(lease: OwnerLease, input: {
+        agentId: AgentId;
+        input: UserInput;
+        metadata?: Metadata;
+        idempotencyKey: string;
+    }): RunRecord;
+    claimRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        executionId?: ExecutionId;
+        messageId?: MessageId;
+        configToken?: ConfigToken;
+    }): RunClaim;
+    failQueuedRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        failure: Extract<RunFailure, {
+            code: "configuration_unavailable" | "checkpoint_incompatible";
+        }>;
+    }): RunRecord;
+    commitInputRequired(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestId?: InputRequestId;
+        prompt: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+    }): InputRequiredCommit;
+    answerInput(lease: OwnerLease, input: {
+        runId: RunId;
+        requestId: InputRequestId;
+        expectedRevision: number;
+        input: UserInput;
+        messageId?: MessageId;
+    }): RunRecord;
+    reserveToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        name: string;
+        args: JsonValue;
+        toolCallId?: ToolCallId;
+    }): ToolCommit;
+    startToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): ToolCommit;
+    commitToolResult(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolExecutionResult;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+    }): ToolCommit;
+    commitOutcome(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        outcome?: Outcome;
+        failure?: RunFailure;
+        output?: AssistantMessage;
+    }): RunRecord;
+    cancelRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+    }): RunRecord;
+    snapshotRun(lease: OwnerLease, runId: RunId): RunSnapshot;
+    listAgents(lease: OwnerLease): readonly AgentRecord[];
+    listRuns(lease: OwnerLease, input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+    }): readonly RunRecord[];
+    listEvents(lease: OwnerLease, input?: {
+        after?: EventCursor;
+    }): readonly DurableRunEvent[];
+    openConsumer(lease: OwnerLease, consumerId: string): ConsumerRegistration;
+    advanceConsumerCheckpoint(lease: OwnerLease, input: {
+        consumerId: string;
+        cursor: EventCursor;
+    }): void;
+    private replay;
+    private writeReceipt;
+    private replayOperation;
+    private writeOperationReceipt;
     private requireAgent;
-    private requireMessage;
     private requireRun;
     private requireToolCall;
-    private recordEventInternal;
+    private assertNoOpenTools;
+    private interruptToolCall;
+    private assertState;
+    private assertRevision;
+    private assertExecution;
+    private nextSequence;
+    private nextReady;
+    private nextMessageSequence;
+    private messagesForRun;
+    private history;
+    private appendMessage;
+    private appendTransition;
+    private appendToolTransition;
+    private baseEvent;
+    private cursorForRun;
+    private parseCursor;
 }
 
-declare class SqliteRuntimeStateStore implements RuntimeStateStore {
+declare class SqliteStore implements DurableStore {
     private readonly database;
+    private closed;
+    private configured;
     constructor(filename?: string);
+    openOwner(input: {
+        ownerId: string;
+        leaseMs: number;
+    }): Promise<OwnedStore>;
     close(): void;
-    createAgent(input: CreateAgentInput): Promise<AgentRecord>;
-    getAgent(agentId: AgentId): Promise<AgentRecord | undefined>;
-    getAgentBySessionId(sessionId: string): Promise<AgentRecord | undefined>;
-    listAgents(): Promise<AgentRecord[]>;
-    setAgentState(agentId: AgentId, state: AgentRecord["state"]): Promise<AgentRecord>;
-    setAgentLifecycleState(agentId: AgentId, state: AgentRecord["lifecycleState"]): Promise<AgentRecord>;
-    deleteAgentData(agentId: AgentId): Promise<void>;
-    enqueueAgentInput(input: EnqueueAgentInput): Promise<EnqueuedAgentInput>;
-    private enqueueAgentInputState;
-    getMessage(messageId: RuntimeMessageId): Promise<RuntimeMessage | undefined>;
-    getRun(runId: AgentRunId): Promise<AgentRunRecord | undefined>;
-    listRuns(input?: ListRunsInput): Promise<AgentRunRecord[]>;
-    listActiveRuns(): Promise<AgentRunRecord[]>;
-    leaseRun(input: LeaseRunInput): Promise<LeasedRun>;
-    renewLease(input: RenewLeaseInput): Promise<RuntimeLease>;
-    suspendRun(input: SuspendRunInput): Promise<AgentRunRecord>;
-    completeRun(input: CompleteRunInput): Promise<AgentRunRecord>;
-    retryRun(input: RetryRunInput): Promise<AgentRunRecord>;
-    exhaustRun(input: ExhaustRunInput): Promise<AgentRunRecord>;
-    abortRun(input: AbortRunInput): Promise<AgentRunRecord>;
-    recoverExpiredLeases(input?: Date): Promise<AgentRunRecord[]>;
-    recoverLeases(): Promise<AgentRunRecord[]>;
-    createToolCall(input: CreateToolCallInput): Promise<RuntimeToolCall>;
-    startToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall>;
-    completeToolCall(input: CompleteToolCallInput): Promise<RuntimeToolCall>;
-    markToolCallIndeterminate(input: IndeterminateToolCallInput): Promise<RuntimeToolCall>;
-    getToolCall(toolCallId: RuntimeToolCallId): Promise<RuntimeToolCall | undefined>;
-    listEvents(cursor?: RuntimeEventCursor): Promise<RuntimeEvent[]>;
-    recordEvent(input: RecordRuntimeEventInput | RuntimeEventKind, related?: Pick<RuntimeEvent, "agentId" | "messageId" | "runId" | "toolCallId">, payload?: unknown): Promise<RuntimeEvent>;
-    getEventCheckpoint(consumerId: string): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEvent(consumerId: string, eventId: RuntimeEventId): Promise<RuntimeEventCheckpoint>;
-    acknowledgeEventAndEnqueueAgentInput(input: AcknowledgeEventAndEnqueueAgentInput): Promise<AcknowledgeEventAndEnqueueAgentInputResult>;
-    private acknowledgeEventState;
-    private insertMessage;
-    private agentFromRow;
-    private messageFromRow;
-    private runFromRow;
-    private eventFromRow;
-    private toolCallFromRow;
-    private messageRow;
-    private runRow;
-    private requireAgent;
-    private requireMessage;
-    private requireRun;
-    private requireToolCall;
-    private requireEvent;
-    private eventCheckpoint;
-    private recordEventInternal;
+    reserveAgent(lease: OwnerLease, input: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+        configIdentity?: string;
+    }): Promise<AgentRecord>;
+    activateAgent(lease: OwnerLease, agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
+    updateAgentConfigToken(lease: OwnerLease, input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): Promise<AgentRecord>;
+    createRun(lease: OwnerLease, input: {
+        agentId: AgentId;
+        input: UserInput;
+        metadata?: Metadata;
+        idempotencyKey: string;
+    }): Promise<RunRecord>;
+    claimRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        executionId?: ExecutionId;
+        messageId?: MessageId;
+        configToken?: ConfigToken;
+    }): Promise<RunClaim>;
+    failQueuedRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision: number;
+        failure: Extract<RunFailure, {
+            code: "configuration_unavailable" | "checkpoint_incompatible";
+        }>;
+    }): Promise<RunRecord>;
+    commitInputRequired(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestId?: InputRequestId;
+        prompt: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+    }): Promise<InputRequiredCommit>;
+    answerInput(lease: OwnerLease, input: {
+        runId: RunId;
+        requestId: InputRequestId;
+        expectedRevision: number;
+        input: UserInput;
+        messageId?: MessageId;
+    }): Promise<RunRecord>;
+    commitOutcome(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        outcome?: Outcome;
+        failure?: RunFailure;
+        output?: AssistantMessage;
+    }): Promise<RunRecord>;
+    reserveToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        name: string;
+        args: JsonValue;
+        toolCallId?: ToolCallId;
+    }): Promise<ToolCommit>;
+    startToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
+    commitToolResult(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolExecutionResult;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+    }): Promise<ToolCommit>;
+    cancelRun(lease: OwnerLease, input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+    }): Promise<RunRecord>;
+    snapshotRun(lease: OwnerLease, runId: RunId): Promise<RunSnapshot>;
+    listAgents(lease: OwnerLease): Promise<readonly AgentRecord[]>;
+    listRuns(lease: OwnerLease, input?: {
+        agentId?: AgentId;
+        states?: readonly RunState[];
+    }): Promise<readonly RunRecord[]>;
+    listEvents(lease: OwnerLease, input?: {
+        after?: EventCursor;
+    }): Promise<readonly DurableRunEvent[]>;
+    openConsumer(lease: OwnerLease, consumerId: string): Promise<ConsumerRegistration>;
+    advanceConsumerCheckpoint(lease: OwnerLease, input: {
+        consumerId: string;
+        cursor: EventCursor;
+    }): Promise<void>;
+    renewOwner(lease: OwnerLease, leaseMs: number): Promise<OwnerLease>;
+    sealAndReleaseOwner(lease: OwnerLease): Promise<void>;
+    private invoke;
+    private ensureSchema;
+    private isCurrentSchema;
+    private configure;
+    private catalog;
+    private readOwner;
+    private writeOwner;
+    private readState;
+    private writeState;
+    private persistState;
+    private requireMatchingOwner;
+    private immediateTransaction;
+    private assertOpen;
+}
+
+/** A deterministic provider for tests and embedded hosts without a separate registry. */
+declare class InMemoryConfigProvider implements ConfigProvider {
+    private readonly entries;
+    private readonly operations;
+    put(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        config: AgentConfig;
+        operationId: string;
+        signal: AbortSignal;
+    }): Promise<ConfigPutResult>;
+    resolve(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        token: ConfigToken;
+        signal: AbortSignal;
+    }): Promise<ConfigResolution>;
 }
+declare function brandConfigToken(raw: unknown): ConfigToken;
+
+type RuntimeErrorCode = "invalid_argument" | "runtime_closed" | "runtime_already_owned" | "runtime_ownership_lost" | "agent_not_found" | "run_not_found" | "run_state_conflict" | "input_request_conflict" | "idempotency_conflict" | "configuration_unavailable" | "checkpoint_incompatible" | "consumer_already_active" | "invalid_cursor" | "store_unavailable" | "unsupported_store_version";
+type RuntimeErrorDetails = {
+    invalid_argument: Readonly<{
+        argument: string;
+        reason: string;
+    }>;
+    runtime_closed: null;
+    runtime_already_owned: Readonly<{
+        expiresAt: string;
+        retryAfterMs: number;
+    }>;
+    runtime_ownership_lost: Readonly<{
+        reason: "expired" | "released" | "epoch_advanced";
+        expectedEpoch: number;
+        actualEpoch: number;
+        expiresAt?: string;
+    }>;
+    agent_not_found: Readonly<{
+        agentId: AgentId;
+    }>;
+    run_not_found: Readonly<{
+        runId: RunId;
+    }>;
+    run_state_conflict: Readonly<{
+        runId: RunId;
+        expected: readonly RunState[];
+        actual: RunState;
+    }>;
+    input_request_conflict: Readonly<{
+        runId: RunId;
+        requestId: InputRequestId;
+        reason: "not_found" | "wrong_run" | "different_answer";
+    }>;
+    idempotency_conflict: Readonly<{
+        scope: "create_agent" | "update_agent_config" | "start_run";
+        idempotencyKey: string;
+    }>;
+    configuration_unavailable: Readonly<{
+        agentId: AgentId;
+        runId?: RunId;
+        retryable: boolean;
+        reason: string;
+    }>;
+    checkpoint_incompatible: Readonly<{
+        runId: RunId;
+        expected: Readonly<{
+            codec: string;
+            versions: readonly number[];
+        }>;
+        actual: Readonly<{
+            codec: string;
+            version: number;
+        }>;
+    }>;
+    consumer_already_active: Readonly<{
+        consumerId: string;
+    }>;
+    invalid_cursor: Readonly<{
+        cursorType: "agent_list" | "run_list" | "event";
+        reason: "malformed" | "wrong_store" | "wrong_collection" | "filter_mismatch" | "beyond_waterline";
+    }>;
+    store_unavailable: Readonly<{
+        operation: string;
+        retryable: boolean;
+        reason: string;
+    }>;
+    unsupported_store_version: Readonly<{
+        found: string | null;
+        supported: string;
+    }>;
+};
+type AnyRuntimeError = {
+    [Code in RuntimeErrorCode]: RuntimeError<Code>;
+}[RuntimeErrorCode];
+declare class RuntimeError<Code extends RuntimeErrorCode = RuntimeErrorCode> extends Error {
+    readonly code: Code;
+    readonly details: RuntimeErrorDetails[Code];
+    constructor(code: Code, details: RuntimeErrorDetails[Code], message?: Code);
+}
+declare function isRuntimeError(value: unknown): value is AnyRuntimeError;
+
+declare function loadSkills(targetPath: string): Promise<Skill[]>;
+
+/**
+ * Load all phases from the target directory.
+ *
+ * Scans for subdirectories containing PHASE.md files.
+ * Returns PhaseRegistry with entryPhaseId:
+ * - null by default (caller must explicitly set to start from a specific phase)
+ * - Set to a specific phase name to start from that phase
+ *
+ * When entryPhaseId is null, Agent normalizes the registry to start from its default phase.
+ */
+declare function loadPhases(targetPath: string): Promise<PhaseRegistry>;
+
+/**
+ * Extension loader — discovers and loads extensions from the filesystem.
+ *
+ * Uses the new LoadedExtension type that works with ExtensionRunner.
+ */
+
+/**
+ * Load extensions from the exact target path.
+ *
+ * If the target is a directory with its own extension entry, load that extension.
+ * Otherwise, scan its immediate children for extension packages/files.
+ */
+declare function loadExtensionsFromPath(path: string): Promise<{
+    extensions: LoadedExtension[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}>;
+
+declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-export { type AfterToolCall, Agent, type AgentContext, type AgentId, type AgentInputRequest, type AgentOptions, AgentRun, type AgentRunExecutionState, type AgentRunId, type AgentRunListener, type AgentRunMetadata, type AgentRunRecord, type AgentRunState, AgentRuntime, type AgentRuntimeOptions, type BeforeToolCall, type CoreToolContext, type ExecutionTurn, type ExtensionAPI, type ExtensionFactory, type HookEvent, type HookEventType, type HookHandler, InMemoryRuntimeStateStore, InMemorySessionStore, JsonlSessionStore, type LoadExtensionsResult, type LoadedExtension, type LoopMetrics, type ModelTranscript, type Phase, type PhaseContext, type PhaseExecution, type PhaseInvocation, type PhaseOutput, type PhaseRegistration, type PhaseRegistry, type PhaseState, type RuntimeEvent, type RuntimeEventConsumer, type RuntimeEventCursor, type RuntimeEventDisposition, type RuntimeEventKind, type RuntimeEventListener, type RuntimeMessage, type RuntimeMessageId, type RuntimeSessionSummary, type RuntimeToolCall, type RuntimeToolCallId, type SessionLifecycleState, type SessionManagerProvider, SqliteRuntimeStateStore, type Tool, type ToolContext, type ToolDefinition, type ToolExecutionMode, type ToolExecutionResult, type ToolRuntimePolicy, type Unsubscribe, createCoreTools, createMessage };
+export { type AfterToolCall, type AgentConfig, type AgentDefinitionContext, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type CoreToolContext, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionFactory, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageId, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseState, type RunBoundary, type RunClaim, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunSummary, type RunTransitioned, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhases, loadSkills };