@rowan-agent/agent 0.12.1 → 0.13.1

package/dist/index.d.ts

@@ -83,7 +83,8 @@ type ExecutionState = {
     metrics: LoopMetrics;
     status: "idle" | "running" | "suspended" | "completed" | "aborted" | "failed";
     continuation?: ExecutionContinuationState;
-    phaseInteractions?: PhaseInteractionState;
+    runInteractions?: RunInteractionState;
+    phaseInteractions?: RunInteractionState;
 };
 type ExecutionContinuationState = {
     isContinuing: boolean;
@@ -96,36 +97,46 @@ type ExecutionContinuationState = {
     previousPhaseMessageId?: string;
 };
 
-type PhaseInteractionKind = "user_input" | "permission" | "elicitation" | "confirmation";
-type PhaseInteractionStatus = "pending" | "answered" | "denied" | "cancelled" | "expired";
-type PhaseInteractionOrigin = "tool_call" | "phase";
-type PhaseInteraction = Readonly<{
+type RunInteractionKind = "user_input" | "permission" | "elicitation" | "confirmation";
+type RunInteractionStatus = "pending" | "answered" | "replied" | "cancelled";
+type RunInteraction = Readonly<{
     id: string;
     phase: string;
-    kind: PhaseInteractionKind;
+    kind: RunInteractionKind;
     prompt: string;
     payload?: JsonValue;
     createdAt: string;
-    status: PhaseInteractionStatus;
-    origin?: PhaseInteractionOrigin;
+    status: RunInteractionStatus;
+    answer?: JsonValue;
+    reply?: string;
+    toolCallId?: string;
+    result?: Readonly<{
+        answered?: string;
+        replied?: string;
+        cancelled?: string;
+    }>;
+}>;
+type RunInteractionRequest = Readonly<{
+    id?: string;
+    kind: RunInteractionKind;
+    prompt: string;
+    payload?: JsonValue;
     toolCallId?: string;
+    result?: Readonly<{
+        answered?: string;
+        replied?: string;
+        cancelled?: string;
+    }>;
 }>;
-type PhaseInteractionState = Readonly<{
-    requests: readonly PhaseInteraction[];
+type RunInteractionState = Readonly<{
+    requests: readonly RunInteraction[];
     answers: Readonly<Record<string, JsonValue>>;
     checkpoint?: JsonValue;
 }>;
-type PhaseInteractionDriver = Readonly<{
+type RunInteractionDriver = Readonly<{
     signal: AbortSignal;
-    request(input: Readonly<{
-        id?: string;
-        kind: PhaseInteractionKind;
-        prompt: string;
-        payload?: JsonValue;
-        origin?: PhaseInteractionOrigin;
-        toolCallId?: string;
-    }>): PhaseInteraction;
-    pending(): readonly PhaseInteraction[];
+    request(input: RunInteractionRequest): RunInteraction;
+    pending(): readonly RunInteraction[];
     answers(): ReadonlyMap<string, JsonValue>;
     checkpoint(): JsonValue | undefined;
     clearCheckpoint(): void;
@@ -133,18 +144,16 @@ type PhaseInteractionDriver = Readonly<{
         checkpoint?: JsonValue;
     }>): never;
 }>;
-declare class PhaseInteractionCancelledError extends Error {
-    readonly code: "phase_interaction_cancelled";
+declare class RunInteractionCancelledError extends Error {
+    readonly code: "run_interaction_cancelled";
     constructor();
 }
-declare class PhaseInteractionBoundary extends Error {
+declare class RunInteractionBoundary extends Error {
     readonly state: ExecutionState;
-    readonly interactions: readonly PhaseInteraction[];
-    constructor(state: ExecutionState, interactions: readonly PhaseInteraction[]);
+    readonly interactions: readonly RunInteraction[];
+    constructor(state: ExecutionState, interactions: readonly RunInteraction[]);
 }
 
-/** 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;
@@ -152,7 +161,6 @@ type OpaqueId<Kind extends string> = string & {
 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">;
@@ -236,7 +244,23 @@ type ToolMessage = MessageBase & Readonly<{
     role: "tool";
     content: ToolMessageContent;
 }>;
-type Message = UserMessage | AssistantMessage | ToolMessage;
+type InteractionRecord = MessageBase & Readonly<{
+    role: "interaction";
+    interactionId: string;
+    kind: "user_input" | "permission" | "elicitation" | "confirmation";
+    prompt: string;
+    phase: string;
+    status: "answered" | "replied" | "cancelled";
+    answer?: JsonValue;
+    reply?: string;
+    toolCallId?: ToolCallId;
+    result?: Readonly<{
+        answered?: string;
+        replied?: string;
+        cancelled?: string;
+    }>;
+}>;
+type Message = UserMessage | AssistantMessage | ToolMessage | InteractionRecord;
 type Outcome = Readonly<{
     id: OutcomeId;
     message: string;
@@ -325,6 +349,12 @@ type DurableEventBase = Readonly<{
     metadata?: Metadata;
     createdAt: string;
 }>;
+type PhaseEntered = DurableEventBase & Readonly<{
+    kind: "phase_entered";
+    executionId: ExecutionId;
+    phaseId: string;
+    visit: number;
+}>;
 type MessageCommitted = DurableEventBase & Readonly<{
     kind: "message_committed";
     message: Message;
@@ -353,12 +383,7 @@ type RunStateChanged = DurableEventBase & (Readonly<{
     kind: "run_state_changed";
     from: "running";
     to: "input_required";
-    request?: Readonly<{
-        id: InputRequestId;
-        phase: string;
-        prompt?: AssistantMessage;
-    }>;
-    interactions: readonly PhaseInteraction[];
+    interactions: readonly RunInteraction[];
     answers: Readonly<Record<string, JsonValue>>;
 }> | Readonly<{
     kind: "run_state_changed";
@@ -409,6 +434,24 @@ type ToolStateChanged = DurableEventBase & (Readonly<{
     toolCall: Extract<ToolCallSnapshot, {
         state: "failed";
     }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "running";
+        to: "pending";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "pending";
+    }>;
+}> | Readonly<{
+    kind: "tool_state_changed";
+    transition: Readonly<{
+        from: "running";
+        to: "pending";
+    }>;
+    toolCall: Extract<ToolCallSnapshot, {
+        state: "pending";
+    }>;
 }> | Readonly<{
     kind: "tool_state_changed";
     transition: Readonly<{
@@ -437,7 +480,7 @@ type ToolStateChanged = DurableEventBase & (Readonly<{
         state: "indeterminate";
     }>;
 }>);
-type DurableRunEvent = MessageCommitted | MessageRevised | RunStateChanged | ToolStateChanged;
+type DurableRunEvent = PhaseEntered | MessageCommitted | MessageRevised | RunStateChanged | ToolStateChanged;
 type MessageDelta = Readonly<{
     kind: "message_delta";
     durability: "transient";
@@ -500,7 +543,7 @@ type PhaseExecution = {
     reportStatus(status: PhaseStatus): Promise<void>;
     executeTool(context: AgentContext, toolCall: ToolCall): Promise<ToolResult>;
     executeTools(context: AgentContext, toolCalls: readonly ToolCall[]): Promise<readonly ToolResult[]>;
-    interaction: PhaseInteractionDriver;
+    interaction: RunInteractionDriver;
     /** Message lifecycle manager for streaming updates from programmatic phases */
     messages: PhaseMessageManager;
 };
@@ -522,131 +565,108 @@ type PhaseMessageManager = {
     discard(messageId: string): void;
 };
 
-/**
- * Extension types — simplified for the new hook-based system.
- */
-
-interface SourceInfo {
-    source: string;
-    baseDir?: string;
-    displayName?: string;
-}
-/** Register a Phase by directory path or Phase object; PHASE.md and direct child Skills are loaded atomically when a path is supplied. */
-type PhaseRegistration = string | Phase;
-/**
- * Tool definition for registering LLM-callable tools via `api.tool.register()`.
- *
- * @example
- * ```typescript
- * api.tool.register({
- *   name: "search_docs",
- *   description: "Search documentation",
- *   parameters: { type: "object", properties: { query: { type: "string" } } },
- *   execute: async (args, ctx) => {
- *     return { content: [{ type: "text", text: "result" }] };
- *   },
- * });
- * ```
- */
-interface ToolDefinition {
-    /** Tool name (used in LLM tool calls) */
+type PhaseRegistrySelection = Readonly<{
+    entryPhaseId: string | null;
+    phaseIds: readonly string[];
+}>;
+type AgentDefinition = Readonly<{
     name: string;
-    /** Description for LLM */
     description: string;
-    /** Parameter schema (JSON Schema) */
-    parameters: Record<string, unknown>;
-    /** Execute the tool */
-    execute: (args: unknown, signal?: AbortSignal) => Promise<ToolExecutionResult>;
-    /** Optional: per-tool execution mode override */
-    executionMode?: "sequential" | "parallel";
-}
-/**
- * Result from tool execution.
- */
-interface ToolExecutionResult {
-    /** Content blocks to return to the LLM */
-    content: Array<{
-        type: string;
-        text?: string;
-        [key: string]: unknown;
-    }>;
-    /** Whether this is an error result */
-    isError?: boolean;
-}
-/**
- * Registered tool with source metadata.
- */
-interface RegisteredTool {
-    definition: ToolDefinition;
-    sourceInfo: SourceInfo;
-}
-/**
- * Structured extension error with attribution.
- */
-interface ExtensionError {
-    /** Path of the extension that caused the error */
-    extensionPath: string;
-    /** Event or operation that caused the error */
-    event: string;
-    /** Error message */
-    error: string;
-    /** Optional stack trace */
-    stack?: string;
+    prompt: string;
+    tools?: readonly string[];
+    skills?: readonly string[];
+    /** Host-supplied Skills private to this Agent Definition/Bundle. */
+    bundledSkills?: readonly Skill[];
+    phases?: PhaseRegistrySelection;
+    contexts?: readonly string[];
+    model?: ModelRef;
+}>;
+/** Parse one Markdown definition using the same frontmatter vocabulary as Phase resources. */
+declare function parseAgentDefinition(raw: string): AgentDefinition;
+
+type ResourceKind = "agent" | "tool" | "skill" | "phase";
+type ResourceSourceId = string;
+/** Rowan-native contribution aliases. Hosts may adapt their domain handlers to
+ * these existing Tool/Phase lifecycles without importing host Scope types. */
+type ToolContribution = Tool$1;
+type PhaseContribution = Phase;
+type ResourceView = Readonly<{
+    agents: readonly ResourceSourceId[];
+    tools: readonly ResourceSourceId[];
+    skills: readonly ResourceSourceId[];
+    phases: readonly ResourceSourceId[];
+}>;
+type ResourceRef = Readonly<{
+    kind: ResourceKind;
+    sourceId: ResourceSourceId;
+    name: string;
+}>;
+type ResourceDiagnostic = Readonly<{
+    kind: "invalid" | "missing" | "collision";
+    sourceId: ResourceSourceId;
+    message: string;
+    path?: string;
+}>;
+type LoadResult = Readonly<{
+    revision: string;
+    registered: readonly ResourceRef[];
+    skipped: readonly ResourceDiagnostic[];
+}>;
+type LoadInput<T> = Readonly<{
+    sourceId: ResourceSourceId;
+    directory?: string;
+    values?: readonly T[];
+}>;
+type ResolvedResourceView = Readonly<{
+    agents: readonly AgentDefinition[];
+    tools: readonly Tool$1[];
+    skills: readonly Skill[];
+    phases: readonly Phase[];
+    revisions: Readonly<Record<ResourceKind, readonly string[]>>;
+    refs: Readonly<Record<ResourceKind, readonly ResourceRef[]>>;
+}>;
+type ResourceRegistryErrorCode = "invalid_source_id" | "invalid_resource_name" | "resource_collision" | "resource_input_missing" | "resource_directory_not_supported" | "unknown_resource_source" | "implicit_source_protected";
+declare class ResourceRegistryError extends Error {
+    readonly code: ResourceRegistryErrorCode;
+    constructor(code: ResourceRegistryErrorCode, message: string);
 }
-/** Error listener callback type. */
-type ExtensionErrorListener = (error: ExtensionError) => void;
-type ExecOptions = {
-    /** Working directory for the command. Defaults to cwd passed to runtime. */
-    cwd?: string;
-    /** Environment variables to add/override. */
-    env?: Record<string, string>;
-    /** Timeout in milliseconds. */
-    timeout?: number;
-    /** AbortSignal for cancellation. */
-    signal?: AbortSignal;
-};
-type ExecResult = {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-};
+type RegistryValue = AgentDefinition | Tool$1 | Skill | Phase;
 /**
- * Shared runtime state created by loader, used during registration and runtime.
- * All ExtensionAPI instances reference this shared state.
+ * Runtime Resource Registry source transaction and view resolver.
  *
- * It only owns the lifetime guard shared by captured Extension API objects.
- */
-interface ExtensionRuntime {
-    /** Throws when this extension instance is stale after runtime replacement. */
-    assertActive: () => void;
-    /** Marks this extension instance as stale after runtime replacement or reload. */
-    invalidate: (message?: string) => void;
-}
-/**
- * Result of loading extensions from filesystem.
- * The runner takes these and creates Extension tracking objects.
- */
-type LoadExtensionsResult = {
-    extensions: LoadedExtension[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-};
-/**
- * Pre-initialization extension form — factory + metadata.
- * Runner.loadExtensions() calls the factory and creates the full Extension object.
+ * Directory normalization is intentionally added by the typed loader slice;
+ * this first module owns only the atomic source/revision/collision semantics.
  */
-interface LoadedExtension {
-    path: string;
-    name: string;
-    factory: ExtensionFactory;
-    manifest?: ExtensionManifest;
-}
-/** Extension manifest from package.json `rowan` field. */
-interface ExtensionManifest {
-    entry?: string;
-    name?: string;
+declare class ResourceRegistry {
+    private readonly sources;
+    /** Sources registered by the bootstrap boundary (currently Extensions). */
+    private readonly implicitSources;
+    private revisionSequence;
+    loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
+    loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
+    loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
+    loadTools(input: Readonly<{
+        sourceId: ResourceSourceId;
+        values: readonly ToolContribution[];
+    }>): Promise<LoadResult>;
+    unload(input: Readonly<{
+        kind: ResourceKind;
+        sourceId: ResourceSourceId;
+    }>): Promise<LoadResult>;
+    resolveView(view: ResourceView): ResolvedResourceView;
+    /** Mark one already-loaded source as implicit for every Resource View. */
+    protected markImplicit(kind: ResourceKind, sourceId: ResourceSourceId): void;
+    /** Bootstrap-only helper for replacing an implicit contribution source. */
+    protected replaceImplicit<T extends RegistryValue>(kind: ResourceKind, sourceId: ResourceSourceId, values: readonly T[]): Promise<LoadResult>;
+    protected hasImplicit(kind: ResourceKind, sourceId: ResourceSourceId): boolean;
+    private withImplicit;
+    private collect;
+    private commit;
+    private resolveKind;
+    private resolveRevisions;
+    private resolveRefs;
+    private sourcesFor;
+    private nextRevision;
 }
 
 /**
@@ -772,1332 +792,1331 @@ interface ExtensionUtils {
 }
 
 /**
- * Extension API object passed to extension factory function.
+ * Extension runner — manages extension loading and hook execution.
  *
- * @example
- * ```typescript
- * export default function(api: ExtensionAPI) {
- *   // api provides all extension APIs
- * }
+ * Architecture reference: PI's ExtensionRunner
+ * - Per-extension tracking via Extension objects
+ * - Shared ExtensionRuntime with invalidate/assertActive
+ * - Direct `on()` API for hook registration
+ * - Error listener pattern for structured error handling
+ * - Tool registration support
+ */
+
+type ExtensionRunnerOptions = {
+    entryPhaseId?: string | null;
+    cwd?: string;
+};
+/**
+ * Manages extensions and provides hooks for the agent loop.
+ *
+ * Features:
+ * - Per-extension tracking (handlers, tools, phases)
+ * - Shared runtime with lifecycle protection (invalidate/assertActive)
+ * - Error listener pattern for structured error handling
+ * - Direct hook API and extension-loaded hook API
+ * - Tool registration for LLM-callable tools
+ * - EventBus for inter-extension communication
+ *
+ * @example
+ * ```ts
+ * const runner = createExtensionRunner();
+ *
+ * // Direct hook registration
+ * const unsub = runner.on("before_tool_call", (event) => {
+ *   return { allow: false, reason: "Blocked" };
+ * });
+ *
+ * // Error handling
+ * runner.onError((error) => {
+ *   console.error(`Extension error in ${error.extensionPath}:`, error.error);
+ * });
+ *
+ * // Load extensions
+ * await runner.loadExtensions(extensions);
+ * runner.bind();
  * ```
  */
-interface ExtensionAPI {
+declare class ExtensionRunner {
+    readonly hooks: HooksManager;
+    readonly runtime: ExtensionRuntime;
+    readonly events: EventBus;
+    private readonly cwd;
+    private readonly abortController;
+    private _idle;
+    private readonly extensions;
+    private readonly phases;
+    private _phaseCache;
+    private readonly pendingProviders;
+    private bound;
+    private readonly errorListeners;
+    /** Current agent context — set by the agent before each phase */
+    currentContext?: AgentContext;
+    constructor(options?: ExtensionRunnerOptions);
+    /** Whether the agent is currently idle (not streaming). */
+    get isIdle(): boolean;
+    /** Set idle state — called by the agent loop. */
+    setIdle(idle: boolean): void;
+    /** Abort signal for the current runner instance. */
+    get signal(): AbortSignal;
+    /** Abort the current runner operation. */
+    abort(): void;
     /**
-     * Subscribe to a hook event.
+     * Register an error listener.
+     * Returns an unsubscribe function.
+     */
+    onError(listener: ExtensionErrorListener): () => void;
+    /**
+     * Emit a structured extension error to all listeners.
+     */
+    emitError(error: ExtensionError): void;
+    /**
+     * Mark all extension contexts as stale.
+     * After calling this, any captured ExtensionAPI or ExtensionContext will throw
+     * on use. Used during runtime replacement or reload.
+     */
+    invalidate(message?: string): void;
+    /**
+     * Subscribe to a specific hook event type.
+     * Returns an unsubscribe function.
      *
-     * @param eventType - Hook type, e.g. "before_tool_call"
-     * @param handler - Hook handler, can return result to modify behavior
+     * @example
+     * ```ts
+     * const unsub = runner.on("before_tool_call", (event) => {
+     *   return { allow: false, reason: "Blocked" };
+     * });
+     * unsub(); // Cancel subscription
+     * ```
      */
-    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    /** Unsubscribe from a hook event. */
-    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    /** Tool capabilities — register and unregister custom tools. */
-    tool: {
-        /** Register a custom LLM-callable tool. */
-        register(tool: ToolDefinition): void;
-        /** Unregister a previously registered tool by name. */
-        unregister(toolName: string): void;
-    };
-    /** Register a model provider. */
-    registerProvider(config: _rowan_agent_models.ProviderConfig): void;
-    /** Unregister a model provider. */
-    unregisterProvider(name: string): void;
-    /** Extension manifest from package.json `rowan` field. */
-    manifest?: ExtensionManifest;
-    /** Utility functions. */
-    utils: ExtensionUtils;
-    /** Runtime context — cwd, signal, exec, message access, etc. */
-    context: ExtensionContext;
-    /** Shared event bus for inter-extension communication. */
-    events: EventBus;
-    /** Phase execution capabilities — provides Phase In/Out, phase identity, phase routing, and registration. */
-    phase: {
-        /** Register a Phase directory bundle or Phase object. */
-        register(phase: PhaseRegistration): Promise<void>;
-        /** Unregister a previously registered phase by name. */
-        unregister(phaseName: string): void;
-        /** Phase In: get payload from previous phase */
-        getPayload(): unknown;
-        /** Phase Out: set payload for next phase */
-        setPayload(payload: unknown): void;
-        /** Phase Out: set outcome message */
-        setMessage(message: string): void;
-        /** Get current phase name */
-        getCurrentPhase(): string;
-        /** Set next phase (lower priority than PHASE.md target) */
-        setNextPhase(phaseName: string): void;
-        /** Get the next phase set by setNextPhase */
-        getNextPhase(): string | undefined;
-        /** Get the message set by setMessage */
-        getMessage(): string | undefined;
-        /** Phase Settings contributions registered by the Phase extension. */
-        settings: {
-            register(provider: PhaseSettingsProvider): void;
-        };
-    };
+    on<K extends HookEventType>(type: K, handler: HookHandler<K>): () => void;
+    /**
+     * Load and initialize extensions.
+     * Creates Extension tracking objects and calls each factory with an ExtensionAPI.
+     */
+    loadExtensions(extensions: LoadedExtension[]): Promise<void>;
+    /** Dispose all active Extensions in reverse activation order. */
+    close(): Promise<void>;
+    /** Get all registered tools from all extensions. */
+    getAllRegisteredTools(): RegisteredTool[];
+    /**
+     * Get a tool definition by name. Returns undefined if not found.
+     */
+    getToolDefinition(toolName: string): RegisteredTool["definition"] | undefined;
+    getPhase(name: string): Phase | undefined;
+    getPhases(): Phase[];
+    createPhaseRegistry(input?: {
+        entryPhaseId?: string | null;
+    }): PhaseRegistry;
+    /** Adapt an extension RegisteredPhase to the core Phase type. */
+    private adaptToPhase;
+    /**
+     * Bind the runner — flushes pending provider registrations and
+     * replaces runtime stubs with real implementations.
+     */
+    bind(): void;
+    /**
+     * Generic emit — fire-and-forget for any event type.
+     */
+    emit<K extends HookEventType>(eventType: K, event: Parameters<HookHandler<K>>[0]): Promise<void>;
+    /**
+     * Unified hook emission — returns the first non-undefined result.
+     */
+    private emitHook;
+    emitBeforePhase(phaseId: string, input: PhaseContext): Promise<{
+        abort?: any;
+        skip?: any;
+        input?: PhaseContext;
+    }>;
+    emitAfterPhase(phaseId: string, output: PhaseOutput): Promise<{
+        abort?: any;
+        retry?: PhaseContext;
+        output?: PhaseOutput;
+    }>;
+    emitBeforePrompt(phaseId: string, input: PhaseContext): Promise<PhaseContext>;
+    emitBeforeToolCall(tool: Tool, args: unknown, context?: {
+        runId?: string;
+        agentId?: string;
+        toolCallId?: string;
+        metadata?: Readonly<Record<string, unknown>>;
+        answer?: unknown;
+    }): Promise<BeforeToolCallResult>;
+    emitAfterToolCall(tool: Tool, result: ToolResult, context?: {
+        runId?: string;
+        agentId?: string;
+        toolCallId?: string;
+        metadata?: Readonly<Record<string, unknown>>;
+    }): Promise<ToolResult>;
+    /**
+     * Create an ExtensionAPI for a specific extension.
+     * Registration methods write to the extension tracking object.
+     * Action methods delegate to the shared runtime.
+     */
+    private createExtensionAPI;
+    private registerTool;
+    private unregisterTool;
+    private registerPhase;
+    private registerPhaseDefinition;
+    private unregisterPhase;
+    private loadRegisteredPhase;
+    private registerProvider;
+    private unregisterProvider;
+    private flushPendingProviders;
+    private getRegisteredPhase;
+    private collectRegisteredPhases;
+    private rollbackExtension;
+    private disposeExtension;
 }
-/**
- * Extension factory function.
- * Receives ExtensionAPI for registering hooks, phases, and providers.
- */
-type ExtensionDisposer = () => void | Promise<void>;
-type ExtensionFactoryResult = void | ExtensionDisposer;
-type ExtensionFactory = (api: ExtensionAPI) => ExtensionFactoryResult | Promise<ExtensionFactoryResult>;
 
-type PhaseStatusState = "running" | "completed";
-/** Normalized status event exposed to Runtime consumers. */
-type PhaseStatus = Readonly<{
-    state: PhaseStatusState;
-    /** Stable consumer-facing status identifier, e.g. `compacting`. */
-    kind: string;
-    /** Optional human-readable detail for UI/status consumers. */
-    message?: string;
-    /** Structured status payload. */
-    payload?: unknown;
+type ExtensionContribution = LoadedExtension;
+type ExtensionLoadInput = LoadInput<ExtensionContribution>;
+type ExtensionActivationError = Readonly<{
+    path: string;
+    error: string;
 }>;
-/** Unified phase output — model-driven routing is optional; programmatic phases may normalize omission to stop. */
-type PhaseOutput = {
-    /** User-visible assistant message. */
-    message?: string;
-    /** Final status update for non-conversational consumers. */
-    status?: PhaseStatus;
-    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end. Undefined means no model route. */
-    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;
-};
-/** Durable identity of the Run execution currently invoking a Phase. */
-type PhaseExecutionIdentity = Readonly<{
-    agentId: string;
-    runId: string;
-    executionId: string;
-    /** Original durable Run input, before any Phase-local interpretation. */
-    input?: UserContent;
-    /** Opaque metadata captured at the durable boundary; Rowan does not decode it. */
-    agentMetadata?: Readonly<Record<string, unknown>>;
-    runMetadata?: Readonly<Record<string, unknown>>;
+type ExtensionActivationResult = Readonly<{
+    active: readonly string[];
+    errors: readonly ExtensionActivationError[];
+    revision?: string;
+    registered?: readonly string[];
+    skipped?: readonly ResourceDiagnostic[];
 }>;
-/** Everything a phase needs to execute */
-interface PhaseContext {
-    systemPrompt: string;
-    messages: AgentMessage[];
-    /** Phase-filtered tools */
-    tools: Tool$1[];
-    /** Phase-filtered skills */
-    skills: Skill[];
-    /** Phase machine state */
-    state: PhaseState;
-    /** Identity and dispatch metadata for this phase execution */
-    readonly invocation: PhaseInvocation;
-    /** Durable Run identity for cross-store integrations and idempotent commands. */
-    readonly execution: PhaseExecutionIdentity;
-    /** Additional guideline bullets appended to the system prompt */
-    promptGuidelines?: string[];
-    /** Text to append after the system prompt */
-    appendSystemPrompt?: string;
-}
-/** JSON-safe structural defaults declared by a Phase's `input` mapping. */
-type PhaseInput = Readonly<Record<string, JsonValue>>;
-/** JSON-safe option metadata exposed by a Phase to a host Settings surface. */
-interface PhaseSettingsOption {
-    value: string;
-    label: string;
-    description?: string;
-    disabled?: boolean;
+type ExtensionLifetimeErrorCode = "extensions_frozen" | "extensions_closed";
+declare class ExtensionLifetimeError extends Error {
+    readonly code: ExtensionLifetimeErrorCode;
+    constructor(code: ExtensionLifetimeErrorCode, message: string);
 }
-interface PhaseSettingsBadge {
-    label: string;
-    tone?: "neutral" | "success" | "review" | "danger";
+/** Runtime-global Extension activation and lifetime boundary. */
+declare class RuntimeExtensionLifetime {
+    private readonly runner;
+    private frozen;
+    private closed;
+    constructor(options?: {
+        cwd?: string;
+    });
+    activate(extensions: readonly LoadedExtension[]): Promise<ExtensionActivationResult>;
+    tools(): readonly RegisteredTool[];
+    phases(): readonly Phase[];
+    get extensionRunner(): ExtensionRunner;
+    close(): Promise<void>;
 }
-interface PhaseSettingsItem {
-    id: string;
-    title: string;
-    description?: string;
-    badges?: readonly PhaseSettingsBadge[];
+/** Bootstrap-only Registry facade; its Extension method disappears after init. */
+declare class RuntimeBootstrapRegistry extends ResourceRegistry {
+    private readonly extensions;
+    private readonly extensionSourceId;
+    constructor(extensions?: RuntimeExtensionLifetime);
+    /** Install Rowan-owned implicit resources before any host source is read. */
+    ensureCoreResources(): Promise<void>;
+    loadExtensions(input: readonly LoadedExtension[] | ExtensionLoadInput): Promise<ExtensionActivationResult>;
+    get extensionRunner(): ExtensionRunner;
+    get extensionTools(): readonly RegisteredTool[];
+    get extensionPhases(): readonly Phase[];
+    closeExtensions(): Promise<void>;
 }
-type PhaseSettingsControl = {
-    type: "boolean";
-    path: string;
-    label: string;
-    description?: string;
-} | {
-    type: "number";
-    path: string;
-    label: string;
-    description?: string;
-    min?: number;
-    max?: number;
-    step?: number;
-    unit?: string;
-    scale?: number;
-} | {
-    type: "select";
-    path: string;
-    label: string;
-    description?: string;
-    options: readonly PhaseSettingsOption[];
-} | {
-    type: "text";
-    path: string;
-    label: string;
-    description?: string;
-    placeholder?: string;
-    format?: "string" | "string-array" | "key-value";
-    multiline?: boolean;
-} | {
-    type: "collection";
-    path: string;
-    label: string;
+
+type DefinitionLayer = Readonly<{
     description?: string;
-    items: readonly PhaseSettingsItem[];
-    fields: readonly PhaseSettingsControl[];
-    add?: {
-        label: string;
-        idLabel?: string;
-        fields: readonly PhaseSettingsControl[];
-    };
-    removeLabel?: string;
-};
-interface PhaseSettingsSection {
+    prompt?: string;
+    model?: ModelRef;
+    tools?: readonly string[];
+    skills?: readonly string[];
+    phases?: PhaseRegistrySelection;
+}>;
+type AgentConfiguration = Readonly<{
+    identity: string;
+    definition: Readonly<{
+        name: string;
+        layer?: DefinitionLayer;
+    }>;
+    resourceView: ResourceView;
+    contexts?: readonly ContextCandidate[];
+    /** Trusted Host-owned Contexts rendered as durable user messages. */
+    additionalContexts?: readonly ContextCandidate[];
+    cwd?: string;
+    maxAttempts?: number;
+    model: ModelConfig | ModelRef;
+    stream?: StreamFn;
+}>;
+type ConfigurationSnapshot = Readonly<{
+    identity: string;
+    definition: AgentDefinition;
+    resources: Readonly<{
+        tools: readonly Tool$1[];
+        skills: readonly Skill[];
+        phases?: PhaseRegistry;
+        revisions: Readonly<Record<ResourceKind, readonly string[]>>;
+        refs: Readonly<Record<ResourceKind, readonly ResourceRef[]>>;
+    }>;
+    contexts: readonly ContextCandidate[];
+    additionalContexts: readonly ContextCandidate[];
+    resourceView: ResourceView;
+    cwd?: string;
+    maxAttempts?: number;
+    model: ModelConfig | ModelRef;
+    stream?: StreamFn;
+}>;
+/** Resolve one Definition request into one immutable, source-qualified snapshot. */
+declare function resolveConfigurationSnapshot(registry: ResourceRegistry, input: AgentConfiguration): ConfigurationSnapshot;
+/** Whether one stored configuration is already a resolved snapshot. A snapshot
+ * is used as it stands; a request is resolved against the current sources. */
+declare function isConfigurationSnapshot(config: AgentConfiguration | ConfigurationSnapshot): config is ConfigurationSnapshot;
+
+type UserInput = string | Readonly<{
+    content: UserContent;
+    metadata?: Metadata;
+}>;
+type HistorySeed = readonly Message[];
+type ContextStatus = Readonly<{
+    tokens: number;
+    contextWindow: number;
+    percent: number;
+    thresholdTokens: number;
+    estimated: boolean;
+    coveredThrough?: Readonly<{
+        messageId: MessageId;
+        sequence: number;
+    }>;
+}>;
+type ContextCompactionRecord = Readonly<{
     id: string;
-    title: string;
-    description?: string;
-    controls: readonly PhaseSettingsControl[];
-}
-/** Declarative, host-neutral Settings surface contributed by a Phase. */
-interface PhaseSettingsDefinition {
-    description?: string;
-    sections: readonly PhaseSettingsSection[];
-}
-/** Host context is intentionally opaque beyond the effective configuration. */
-interface PhaseSettingsContext {
-    configuration: Readonly<Record<string, unknown>>;
-    metadata?: Readonly<Record<string, unknown>>;
-}
-type PhaseSettingsProvider = (context: PhaseSettingsContext) => PhaseSettingsDefinition | Promise<PhaseSettingsDefinition>;
-/**
- * Loaded Phase object
- */
-interface Phase {
-    /** Unique phase identity and display name. */
+    agentId: AgentId;
+    summary: string;
+    coveredThrough?: Readonly<{
+        messageId: MessageId;
+        sequence: number;
+    }>;
+    instructions?: string;
+    createdAt: string;
+}>;
+/** Who is calling which tool, without the ability to ask or suspend. Hosts that
+ * describe a call before it runs (for example to build a confirmation) only
+ * have this much. */
+type ToolCallContext = Readonly<{
+    agentId: AgentId;
+    runId: RunId;
+    /** Opaque JSON metadata captured from the Agent and Run records. Rowan does
+     * not interpret host/domain fields. */
+    agentMetadata?: Metadata;
+    runMetadata?: Metadata;
+    toolCallId: ToolCallId;
+    reportProgress(progress: JsonValue): void;
+}>;
+type ToolInvocationContext = ToolCallContext & Readonly<{
+    interaction: RunInteractionDriver;
+}>;
+type Tool$1 = Readonly<{
     name: string;
-    /** Rowan-owned built-in Phase; built-ins are never filtered or disabled. */
-    core?: boolean;
-    /** Description */
-    description: string;
-    /** Restricted tools (undefined = all tools available) */
-    tools?: string[];
-    /** Skills bundled directly inside this phase directory. Inline phases may omit this (equivalent to []). */
-    skills?: Skill[];
-    /** Forced next phase */
-    target?: string;
-    /** Structural JSON-safe input defaults */
-    input?: PhaseInput;
-    /** 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;
-    /** Do not automatically inject this Phase into the model route catalog/context. */
-    disableAutoInvocation?: boolean;
-    /** Do not expose this Phase to direct user invocation. */
-    disableImplicitInvocation?: boolean;
-    /** ExtensionAPI factory function used for registration or programmatic execution. */
-    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 ToolCallInteractionKind = PhaseInteractionKind;
-interface ToolCallInteractionRequest$1 {
-    id?: string;
-    kind: ToolCallInteractionKind;
-    prompt: string;
-    payload?: JsonValue;
-}
-interface BeforePhaseEvent {
-    type: "before_phase";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface AfterPhaseEvent {
-    type: "after_phase";
-    phaseId: string;
-    output: PhaseOutput;
-}
-interface BeforePromptEvent {
-    type: "before_prompt";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface BeforeToolCallEvent {
-    type: "before_tool_call";
-    tool: Tool$1;
-    args: unknown;
-    readonly runId?: string;
-    readonly agentId?: string;
-    readonly toolCallId?: string;
-    readonly metadata?: Readonly<Record<string, unknown>>;
-    readonly answer?: unknown;
-}
-interface AfterToolCallEvent {
-    type: "after_tool_call";
-    tool: Tool$1;
-    result: ToolResult;
-    readonly runId?: string;
-    readonly agentId?: string;
-    readonly toolCallId?: string;
-    readonly metadata?: Readonly<Record<string, unknown>>;
-}
-type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
-interface BeforePhaseResult {
-    abort?: Outcome$1;
-    skip?: {
-        route: string;
-        message: string;
-    };
-    input?: PhaseContext;
-}
-interface AfterPhaseResult {
-    abort?: Outcome$1;
-    retry?: PhaseContext;
-    output?: PhaseOutput;
-}
-interface BeforePromptResult {
-    input?: PhaseContext;
-}
-interface BeforeToolCallResult {
-    allow?: boolean;
-    reason?: string;
-    interaction?: ToolCallInteractionRequest$1;
-}
-interface AfterToolCallResult {
-    result?: ToolResult;
-}
-interface HookResultMap {
-    before_phase: BeforePhaseResult | undefined;
-    after_phase: AfterPhaseResult | undefined;
-    before_prompt: BeforePromptResult | undefined;
-    before_tool_call: BeforeToolCallResult | undefined;
-    after_tool_call: AfterToolCallResult | undefined;
-}
-type HookEventType = HookEvent["type"];
-type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
-    type: K;
-}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
-declare class HooksManager {
-    private handlers;
-    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<void>;
-    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<HookResultMap[K] | undefined>;
-}
-
-type ToolContext = Pick<AgentContext, "skills"> & {
-    toolCallId: string;
-};
-type ToolExecutionMode = "sequential" | "parallel";
-type Tool$1<TArgs = unknown> = {
-    name: string;
-    /** Rowan-owned Core Tool; Core Tools bypass Phase filtering. */
+    /** Rowan-owned Core Tool; Core Tools bypass Definition/Phase filtering. */
     core?: boolean;
     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$1[];
-    /** Skills available for this run. */
-    skills: Skill[];
-    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
-    phases?: PhaseRegistry;
-};
-
-/**
- * `root` anchors relative paths and the Bash working directory. It is not a
- * filesystem sandbox: core Tools use the permissions of the host process.
- */
-type CoreToolContext = {
-    root?: string;
-    /** Directory for complete Tool Result spill files. */
-    archiveDir?: string;
-    maxReadBytes?: number;
-    maxReadLines?: number;
-    bashTimeoutMs?: number;
-    maxBashOutputBytes?: number;
-};
-
-type PhaseRegistrySelection = Readonly<{
-    entryPhaseId: string | null;
-    phaseIds: readonly string[];
+    execute(args: JsonValue, context: ToolInvocationContext, signal: AbortSignal): Promise<ToolExecutionResult$1>;
 }>;
-type AgentDefinition = Readonly<{
+type ContextCandidate = Readonly<{
     name: string;
-    description: string;
-    prompt: string;
-    tools?: readonly string[];
-    skills?: readonly string[];
-    /** Host-supplied Skills private to this Agent Definition/Bundle. */
-    bundledSkills?: readonly Skill[];
-    phases?: PhaseRegistrySelection;
-    contexts?: readonly string[];
-    model?: ModelRef;
+    value: JsonValue;
 }>;
-/** Parse one Markdown definition using the same frontmatter vocabulary as Phase resources. */
-declare function parseAgentDefinition(raw: string): AgentDefinition;
-
-type ResourceKind = "agent" | "tool" | "skill" | "phase";
-type ResourceSourceId = string;
-/** Rowan-native contribution aliases. Hosts may adapt their domain handlers to
- * these existing Tool/Phase lifecycles without importing host Scope types. */
-type ToolContribution = Tool;
-type PhaseContribution = Phase;
-type ResourceView = Readonly<{
-    agents: readonly ResourceSourceId[];
-    tools: readonly ResourceSourceId[];
-    skills: readonly ResourceSourceId[];
-    phases: readonly ResourceSourceId[];
+type BeforeToolCallDecision = Readonly<{
+    allow: true;
+}> | Readonly<{
+    allow: false;
+    reason: string;
+}> | Readonly<{
+    interaction: RunInteractionRequest;
 }>;
-type ResourceRef = Readonly<{
-    kind: ResourceKind;
-    sourceId: ResourceSourceId;
+type BeforeToolCall = (input: Readonly<{
+    tool: Tool$1;
+    args: JsonValue;
+    context: ToolInvocationContext;
+    signal: AbortSignal;
+    answer?: JsonValue;
+}>) => BeforeToolCallDecision | Promise<BeforeToolCallDecision>;
+type AfterToolCall = (input: Readonly<{
+    tool: Tool$1;
+    result: ToolExecutionResult$1;
+    context: ToolInvocationContext;
+    signal: AbortSignal;
+}>) => ToolExecutionResult$1 | Promise<ToolExecutionResult$1>;
+type InvocationSource = "auto" | "implicit" | "external";
+type InvocationCatalogEntry = Readonly<{
+    kind: "phase" | "skill";
     name: string;
+    description: string;
+    input?: Phase["input"];
+    core?: boolean;
+    disableAutoInvocation: boolean;
+    disableImplicitInvocation: boolean;
+    filePath: string;
 }>;
-type ResourceDiagnostic = Readonly<{
-    kind: "invalid" | "missing" | "collision";
-    sourceId: ResourceSourceId;
-    message: string;
-    path?: string;
+type AgentRecord = Readonly<{
+    id: AgentId;
+    metadata?: Metadata;
+    currentConfigToken?: ConfigToken;
+    currentConfigIdentity?: string;
+    createdAt: string;
+    activatedAt?: string;
+    updatedAt: string;
 }>;
-type LoadResult = Readonly<{
-    revision: string;
-    registered: readonly ResourceRef[];
-    skipped: readonly ResourceDiagnostic[];
+type AgentDeletionRequest = Readonly<{
+    agentId: AgentId;
+    expectedRunIds: readonly RunId[];
+    confirmation: "agent-delete-v1";
 }>;
-type LoadInput<T> = Readonly<{
-    sourceId: ResourceSourceId;
-    directory?: string;
-    values?: readonly T[];
+type ExecutionToken = Readonly<{
+    runId: RunId;
+    ownerEpoch: number;
+    executionId: ExecutionId;
 }>;
-type ResolvedResourceView = Readonly<{
-    agents: readonly AgentDefinition[];
-    tools: readonly Tool[];
-    skills: readonly Skill[];
-    phases: readonly Phase[];
-    revisions: Readonly<Record<ResourceKind, readonly string[]>>;
-    refs: Readonly<Record<ResourceKind, readonly ResourceRef[]>>;
+type ExecutionCheckpoint = Readonly<{
+    codec: string;
+    version: number;
+    data: JsonValue;
 }>;
-type ResourceRegistryErrorCode = "invalid_source_id" | "invalid_resource_name" | "resource_collision" | "resource_input_missing" | "resource_directory_not_supported" | "unknown_resource_source" | "implicit_source_protected";
-declare class ResourceRegistryError extends Error {
-    readonly code: ResourceRegistryErrorCode;
-    constructor(code: ResourceRegistryErrorCode, message: string);
-}
-type RegistryValue = AgentDefinition | Tool | Skill | Phase;
-/**
- * Runtime Resource Registry source transaction and view resolver.
- *
- * Directory normalization is intentionally added by the typed loader slice;
- * this first module owns only the atomic source/revision/collision semantics.
- */
-declare class ResourceRegistry {
-    private readonly sources;
-    /** Sources registered by the bootstrap boundary (currently Extensions). */
-    private readonly implicitSources;
-    private revisionSequence;
-    loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
-    loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
-    loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
-    loadTools(input: Readonly<{
-        sourceId: ResourceSourceId;
-        values: readonly ToolContribution[];
-    }>): Promise<LoadResult>;
-    unload(input: Readonly<{
-        kind: ResourceKind;
-        sourceId: ResourceSourceId;
-    }>): Promise<LoadResult>;
-    resolveView(view: ResourceView): ResolvedResourceView;
-    /** Mark one already-loaded source as implicit for every Resource View. */
-    protected markImplicit(kind: ResourceKind, sourceId: ResourceSourceId): void;
-    /** Bootstrap-only helper for replacing an implicit contribution source. */
-    protected replaceImplicit<T extends RegistryValue>(kind: ResourceKind, sourceId: ResourceSourceId, values: readonly T[]): Promise<LoadResult>;
-    protected hasImplicit(kind: ResourceKind, sourceId: ResourceSourceId): boolean;
-    private withImplicit;
-    private collect;
-    private commit;
-    private resolveKind;
-    private resolveRevisions;
-    private resolveRefs;
-    private sourcesFor;
-    private nextRevision;
-}
-
-/**
- * Extension runner — manages extension loading and hook execution.
- *
- * Architecture reference: PI's ExtensionRunner
- * - Per-extension tracking via Extension objects
- * - Shared ExtensionRuntime with invalidate/assertActive
- * - Direct `on()` API for hook registration
- * - Error listener pattern for structured error handling
- * - Tool registration support
- */
-
-type ExtensionRunnerOptions = {
-    entryPhaseId?: string | null;
-    cwd?: string;
-};
-/**
- * Manages extensions and provides hooks for the agent loop.
- *
- * Features:
- * - Per-extension tracking (handlers, tools, phases)
- * - Shared runtime with lifecycle protection (invalidate/assertActive)
- * - Error listener pattern for structured error handling
- * - Direct hook API and extension-loaded hook API
- * - Tool registration for LLM-callable tools
- * - EventBus for inter-extension communication
- *
- * @example
- * ```ts
- * const runner = createExtensionRunner();
- *
- * // Direct hook registration
- * const unsub = runner.on("before_tool_call", (event) => {
- *   return { allow: false, reason: "Blocked" };
- * });
- *
- * // Error handling
- * runner.onError((error) => {
- *   console.error(`Extension error in ${error.extensionPath}:`, error.error);
- * });
- *
- * // Load extensions
- * await runner.loadExtensions(extensions);
- * runner.bind();
- * ```
- */
-declare class ExtensionRunner {
-    readonly hooks: HooksManager;
-    readonly runtime: ExtensionRuntime;
-    readonly events: EventBus;
-    private readonly cwd;
-    private readonly abortController;
-    private _idle;
-    private readonly extensions;
-    private readonly phases;
-    private _phaseCache;
-    private readonly pendingProviders;
-    private bound;
-    private readonly errorListeners;
-    /** Current agent context — set by the agent before each phase */
-    currentContext?: AgentContext;
-    constructor(options?: ExtensionRunnerOptions);
-    /** Whether the agent is currently idle (not streaming). */
-    get isIdle(): boolean;
-    /** Set idle state — called by the agent loop. */
-    setIdle(idle: boolean): void;
-    /** Abort signal for the current runner instance. */
-    get signal(): AbortSignal;
-    /** Abort the current runner operation. */
-    abort(): void;
-    /**
-     * Register an error listener.
-     * Returns an unsubscribe function.
-     */
-    onError(listener: ExtensionErrorListener): () => void;
-    /**
-     * Emit a structured extension error to all listeners.
-     */
-    emitError(error: ExtensionError): void;
-    /**
-     * Mark all extension contexts as stale.
-     * After calling this, any captured ExtensionAPI or ExtensionContext will throw
-     * on use. Used during runtime replacement or reload.
-     */
-    invalidate(message?: string): void;
-    /**
-     * Subscribe to a specific hook event type.
-     * Returns an unsubscribe function.
-     *
-     * @example
-     * ```ts
-     * const unsub = runner.on("before_tool_call", (event) => {
-     *   return { allow: false, reason: "Blocked" };
-     * });
-     * unsub(); // Cancel subscription
-     * ```
-     */
-    on<K extends HookEventType>(type: K, handler: HookHandler<K>): () => void;
-    /**
-     * Load and initialize extensions.
-     * Creates Extension tracking objects and calls each factory with an ExtensionAPI.
-     */
-    loadExtensions(extensions: LoadedExtension[]): Promise<void>;
-    /** Dispose all active Extensions in reverse activation order. */
-    close(): Promise<void>;
-    /** Get all registered tools from all extensions. */
-    getAllRegisteredTools(): RegisteredTool[];
-    /**
-     * Get a tool definition by name. Returns undefined if not found.
-     */
-    getToolDefinition(toolName: string): RegisteredTool["definition"] | undefined;
-    getPhase(name: string): Phase | undefined;
-    getPhases(): Phase[];
-    createPhaseRegistry(input?: {
-        entryPhaseId?: string | null;
-    }): PhaseRegistry;
-    /** Adapt an extension RegisteredPhase to the core Phase type. */
-    private adaptToPhase;
-    /**
-     * Bind the runner — flushes pending provider registrations and
-     * replaces runtime stubs with real implementations.
-     */
-    bind(): void;
-    /**
-     * Generic emit — fire-and-forget for any event type.
-     */
-    emit<K extends HookEventType>(eventType: K, event: Parameters<HookHandler<K>>[0]): Promise<void>;
-    /**
-     * Unified hook emission — returns the first non-undefined result.
-     */
-    private emitHook;
-    emitBeforePhase(phaseId: string, input: PhaseContext): Promise<{
-        abort?: any;
-        skip?: any;
-        input?: PhaseContext;
-    }>;
-    emitAfterPhase(phaseId: string, output: PhaseOutput): Promise<{
-        abort?: any;
-        retry?: PhaseContext;
-        output?: PhaseOutput;
-    }>;
-    emitBeforePrompt(phaseId: string, input: PhaseContext): Promise<PhaseContext>;
-    emitBeforeToolCall(tool: Tool$1, args: unknown, context?: {
-        runId?: string;
-        agentId?: string;
-        toolCallId?: string;
-        metadata?: Readonly<Record<string, unknown>>;
-        answer?: unknown;
-    }): Promise<BeforeToolCallResult>;
-    emitAfterToolCall(tool: Tool$1, result: ToolResult, context?: {
-        runId?: string;
-        agentId?: string;
-        toolCallId?: string;
-        metadata?: Readonly<Record<string, unknown>>;
-    }): Promise<ToolResult>;
-    /**
-     * Create an ExtensionAPI for a specific extension.
-     * Registration methods write to the extension tracking object.
-     * Action methods delegate to the shared runtime.
-     */
-    private createExtensionAPI;
-    private registerTool;
-    private unregisterTool;
-    private registerPhase;
-    private registerPhaseDefinition;
-    private unregisterPhase;
-    private loadRegisteredPhase;
-    private registerProvider;
-    private unregisterProvider;
-    private flushPendingProviders;
-    private getRegisteredPhase;
-    private collectRegisteredPhases;
-    private rollbackExtension;
-    private disposeExtension;
-}
-
-type ExtensionContribution = LoadedExtension;
-type ExtensionLoadInput = LoadInput<ExtensionContribution>;
-type ExtensionActivationError = Readonly<{
-    path: string;
-    error: string;
-}>;
-type ExtensionActivationResult = Readonly<{
-    active: readonly string[];
-    errors: readonly ExtensionActivationError[];
-    revision?: string;
-    registered?: readonly string[];
-    skipped?: readonly ResourceDiagnostic[];
-}>;
-type ExtensionLifetimeErrorCode = "extensions_frozen" | "extensions_closed";
-declare class ExtensionLifetimeError extends Error {
-    readonly code: ExtensionLifetimeErrorCode;
-    constructor(code: ExtensionLifetimeErrorCode, message: string);
-}
-/** Runtime-global Extension activation and lifetime boundary. */
-declare class RuntimeExtensionLifetime {
-    private readonly runner;
-    private frozen;
-    private closed;
-    constructor(options?: {
-        cwd?: string;
-    });
-    activate(extensions: readonly LoadedExtension[]): Promise<ExtensionActivationResult>;
-    tools(): readonly RegisteredTool[];
-    phases(): readonly Phase[];
-    get extensionRunner(): ExtensionRunner;
-    close(): Promise<void>;
-}
-/** Bootstrap-only Registry facade; its Extension method disappears after init. */
-declare class RuntimeBootstrapRegistry extends ResourceRegistry {
-    private readonly extensions;
-    private readonly extensionSourceId;
-    constructor(extensions?: RuntimeExtensionLifetime);
-    /** Install Rowan-owned implicit resources before any host source is read. */
-    ensureCoreResources(): Promise<void>;
-    loadExtensions(input: readonly LoadedExtension[] | ExtensionLoadInput): Promise<ExtensionActivationResult>;
-    get extensionRunner(): ExtensionRunner;
-    get extensionTools(): readonly RegisteredTool[];
-    get extensionPhases(): readonly Phase[];
-    closeExtensions(): Promise<void>;
-}
-
-type DefinitionLayer = Readonly<{
-    description?: string;
-    prompt?: string;
-    model?: ModelRef;
-    tools?: readonly string[];
-    skills?: readonly string[];
-    phases?: PhaseRegistrySelection;
+type OwnerLease = Readonly<{
+    ownerId: string;
+    token: OwnerToken;
+    epoch: number;
+    expiresAt: string;
 }>;
-type AgentConfiguration = Readonly<{
-    identity: string;
-    definition: Readonly<{
-        name: string;
-        layer?: DefinitionLayer;
-    }>;
-    resourceView: ResourceView;
-    contexts?: readonly ContextCandidate[];
-    /** Trusted Host-owned Contexts rendered as durable user messages. */
-    additionalContexts?: readonly ContextCandidate[];
-    cwd?: string;
-    maxAttempts?: number;
-    model: ModelConfig | ModelRef;
-    stream?: StreamFn;
+type RunClaim = Readonly<{
+    run: RunRecord;
+    execution: ExecutionToken;
+    history: readonly Message[];
 }>;
-type ConfigurationSnapshot = Readonly<{
-    identity: string;
-    definition: AgentDefinition;
-    resources: Readonly<{
-        tools: readonly Tool[];
-        skills: readonly Skill[];
-        phases?: PhaseRegistry;
-        revisions: Readonly<Record<ResourceKind, readonly string[]>>;
-        refs: Readonly<Record<ResourceKind, readonly ResourceRef[]>>;
-    }>;
-    contexts: readonly ContextCandidate[];
-    additionalContexts: readonly ContextCandidate[];
-    resourceView: ResourceView;
-    cwd?: string;
-    maxAttempts?: number;
-    model: ModelConfig | ModelRef;
-    stream?: StreamFn;
+type ToolCallReservation = Readonly<{
+    providerToolCallId: string;
+    name: string;
+    args: JsonValue;
+    toolCallId?: ToolCallId;
 }>;
-/** Resolve one Definition request into one immutable, source-qualified snapshot. */
-declare function resolveConfigurationSnapshot(registry: ResourceRegistry, input: AgentConfiguration): ConfigurationSnapshot;
-/** Whether one stored configuration is already a resolved snapshot. A snapshot
- * is used as it stands; a request is resolved against the current sources. */
-declare function isConfigurationSnapshot(config: AgentConfiguration | ConfigurationSnapshot): config is ConfigurationSnapshot;
-
-type UserInput = string | Readonly<{
-    content: UserContent;
-    metadata?: Metadata;
+type ToolCommit = Readonly<{
+    run: RunRecord;
+    toolCall: ToolCallSnapshot;
 }>;
-type HistorySeed = readonly Message[];
-type ContextStatus = Readonly<{
-    tokens: number;
-    contextWindow: number;
-    percent: number;
-    thresholdTokens: number;
-    estimated: boolean;
-    coveredThrough?: Readonly<{
-        messageId: MessageId;
-        sequence: number;
-    }>;
+type ToolBatchCommit = Readonly<{
+    run: RunRecord;
+    toolCalls: readonly ToolCallSnapshot[];
 }>;
-type ContextCompactionRecord = Readonly<{
-    id: string;
+type RunRecord = Readonly<{
+    id: RunId;
     agentId: AgentId;
-    summary: string;
-    coveredThrough?: Readonly<{
+    agentSequence: number;
+    readySequence: number;
+    revision: number;
+    state: RunState;
+    input: UserInput;
+    initialMessageId?: MessageId;
+    invalidatedBy?: Readonly<{
         messageId: MessageId;
-        sequence: number;
+        messageRevision: number;
     }>;
-    instructions?: string;
-    createdAt: string;
-}>;
-type ToolInvocationContext = Readonly<{
-    agentId: AgentId;
-    runId: RunId;
-    /** Opaque JSON metadata captured from the Agent and Run records. Rowan does
-     * not interpret host/domain fields. */
-    agentMetadata?: Metadata;
-    runMetadata?: Metadata;
-    toolCallId: ToolCallId;
-    reportProgress(progress: JsonValue): void;
-}>;
-type Tool = Readonly<{
-    name: string;
-    /** Rowan-owned Core Tool; Core Tools bypass Definition/Phase filtering. */
-    core?: boolean;
-    description: string;
-    parameters: Type.TSchema;
-    execute(args: JsonValue, context: ToolInvocationContext, signal: AbortSignal): Promise<ToolExecutionResult$1>;
-}>;
-type ContextCandidate = Readonly<{
-    name: string;
-    value: JsonValue;
-}>;
-type ToolCallInteractionRequest = Readonly<{
-    id?: string;
-    kind: PhaseInteractionKind;
-    prompt: string;
-    payload?: JsonValue;
-}>;
-type BeforeToolCallDecision = Readonly<{
-    allow: true;
-}> | Readonly<{
-    allow: false;
-    reason: string;
-}> | Readonly<{
-    interaction: ToolCallInteractionRequest;
-}>;
-type BeforeToolCall = (input: Readonly<{
-    tool: Tool;
-    args: JsonValue;
-    context: ToolInvocationContext;
-    signal: AbortSignal;
-    answer?: JsonValue;
-}>) => BeforeToolCallDecision | Promise<BeforeToolCallDecision>;
-type AfterToolCall = (input: Readonly<{
-    tool: Tool;
-    result: ToolExecutionResult$1;
-    context: ToolInvocationContext;
-    signal: AbortSignal;
-}>) => ToolExecutionResult$1 | Promise<ToolExecutionResult$1>;
-type InvocationSource = "auto" | "implicit" | "external";
-type InvocationCatalogEntry = Readonly<{
-    kind: "phase" | "skill";
-    name: string;
-    description: string;
-    input?: Phase["input"];
-    core?: boolean;
-    disableAutoInvocation: boolean;
-    disableImplicitInvocation: boolean;
-    filePath: string;
+    metadata?: Metadata;
+    pinnedConfigToken?: ConfigToken;
+    checkpoint?: ExecutionCheckpoint;
+    currentPhaseId?: string;
+    openInteractions?: readonly RunInteraction[];
+    interactionAnswers?: Readonly<Record<string, JsonValue>>;
+    execution?: ExecutionToken;
+    outcome?: Outcome;
+    failure?: RunFailure;
+    cancellationReason?: string;
+    createdAt: string;
+    updatedAt: string;
 }>;
-type AgentRecord = Readonly<{
+type MessageRevisionResult = Readonly<{
+    message: UserMessage & Readonly<{
+        messageRevision: number;
+    }>;
+    replacementRun: RunRecord;
+    invalidatedRunIds: readonly RunId[];
+    affectedToolCallIds: readonly ToolCallId[];
+    effectDigest?: string;
+}>;
+type RetentionResult = Readonly<{
+    deletedRunIds: readonly RunId[];
+    deletedToolCallIds: readonly ToolCallId[];
+    deletedEventCount: number;
+    retentionFloor: EventCursor;
+    skipped?: "active_consumers" | "no_eligible_events";
+}>;
+type AgentSummary = Readonly<{
     id: AgentId;
     metadata?: Metadata;
-    currentConfigToken?: ConfigToken;
     currentConfigIdentity?: string;
     createdAt: string;
-    activatedAt?: string;
+    activatedAt: string;
     updatedAt: string;
 }>;
-type AgentDeletionRequest = Readonly<{
+type RunSummary = Readonly<{
+    id: RunId;
     agentId: AgentId;
-    expectedRunIds: readonly RunId[];
-    confirmation: "agent-delete-v1";
-}>;
-type ExecutionToken = Readonly<{
-    runId: RunId;
-    ownerEpoch: number;
-    executionId: ExecutionId;
+    agentSequence: number;
+    state: RunState;
+    metadata?: Metadata;
+    createdAt: string;
+    updatedAt: string;
 }>;
-type ExecutionCheckpoint = Readonly<{
-    codec: string;
-    version: number;
-    data: JsonValue;
+type Page<T, Cursor> = Readonly<{
+    items: readonly T[];
+    next?: Cursor;
 }>;
-type InputRequest = Readonly<{
-    id: InputRequestId;
-    phase: string;
-    messageId?: MessageId;
+type RunSnapshotBase = Readonly<{
+    runId: RunId;
+    agentId: AgentId;
+    agentSequence: number;
+    revision: number;
+    input: UserInput;
+    metadata?: Metadata;
+    messageCount: number;
+    toolCallCount: number;
+    currentPhaseId?: string;
     createdAt: string;
+    updatedAt: string;
+    cursor: EventCursor;
 }>;
-type OwnerLease = Readonly<{
-    ownerId: string;
-    token: OwnerToken;
-    epoch: number;
-    expiresAt: string;
-}>;
-type RunClaim = Readonly<{
-    run: RunRecord;
-    execution: ExecutionToken;
-    history: readonly Message[];
+type RunSnapshot = RunSnapshotBase & (Readonly<{
+    state: "queued" | "running";
+    currentPhaseId?: string;
+}> | Readonly<{
+    state: "input_required";
+    interactions: readonly RunInteraction[];
+    answers: Readonly<Record<string, JsonValue>>;
+}> | Readonly<{
+    state: "completed";
+    outcome: Outcome;
+    output?: AssistantMessage;
+}> | Readonly<{
+    state: "failed";
+    failure: RunFailure;
+}> | Readonly<{
+    state: "cancelled";
+    reason?: string;
+}>);
+type RunBoundary = Readonly<{
+    type: "input_required";
+    interactions: readonly RunInteraction[];
+    answers: Readonly<Record<string, JsonValue>>;
+}> | Readonly<{
+    type: "completed";
+    outcome: Outcome;
+    output?: AssistantMessage;
+}> | Readonly<{
+    type: "failed";
+    failure: RunFailure;
+}> | Readonly<{
+    type: "cancelled";
+    reason?: string;
 }>;
-type InputRequiredCommit = Readonly<{
-    run: RunRecord;
-    prompt?: AssistantMessage;
-    request: InputRequest;
-    interactions: readonly PhaseInteraction[];
+type ConfigResolution = Readonly<{
+    kind: "available";
+    config: AgentConfiguration | ConfigurationSnapshot;
+} | {
+    kind: "deferred";
+    retryAfterMs?: number;
+} | {
+    kind: "unavailable";
+    reason: string;
 }>;
-type ToolCallReservation = Readonly<{
-    providerToolCallId: string;
-    name: string;
-    args: JsonValue;
-    toolCallId?: ToolCallId;
+type ConfigPutResult = Readonly<{
+    kind: "stored";
+    token: string;
+} | {
+    kind: "identity_conflict";
 }>;
-type ToolCommit = Readonly<{
-    run: RunRecord;
-    toolCall: ToolCallSnapshot;
+interface ConfigProvider {
+    put(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        config: AgentConfiguration | ConfigurationSnapshot;
+        operationId: string;
+        signal: AbortSignal;
+    }): Promise<ConfigPutResult>;
+    resolve(input: {
+        agentId: AgentId;
+        agentMetadata?: Metadata;
+        token: ConfigToken;
+        signal: AbortSignal;
+    }): Promise<ConfigResolution>;
+}
+interface OwnedStore {
+    readonly lease: OwnerLease;
+    reserveAgent(input: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+        configIdentity?: string;
+        historySeed?: HistorySeed;
+    }): Promise<AgentRecord>;
+    activateAgent(agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
+    updateAgentConfigToken(input: {
+        agentId: AgentId;
+        token: ConfigToken;
+        configIdentity?: string;
+        idempotencyKey: string;
+    }): Promise<AgentRecord>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    reviseMessage(input: {
+        agentId: AgentId;
+        messageId: MessageId;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
+    contextStatus(agentId: AgentId, contextWindow: number): Promise<ContextStatus>;
+    contextMessages(agentId: AgentId, recentTokenBudget?: number): Promise<readonly Message[]>;
+    commitContextCompaction(record: ContextCompactionRecord): Promise<ContextCompactionRecord>;
+    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>;
+    commitPhaseEntered(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phaseId: string;
+        visit: number;
+    }): Promise<RunRecord>;
+    commitInputRequired(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phase: string;
+        prompt?: AssistantMessage;
+        checkpoint: ExecutionCheckpoint;
+        interactions?: readonly RunInteraction[];
+        interactionAnswers?: Readonly<Record<string, JsonValue>>;
+        pendingToolCallIds?: readonly ToolCallId[];
+    }): Promise<RunRecord>;
+    answerInteraction(input: {
+        runId: RunId;
+        interactionId: string;
+        expectedRevision: number;
+        input?: JsonValue;
+        cancel?: boolean;
+    }): 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;
+        providerToolCallId?: string;
+    }): Promise<ToolCommit>;
+    reserveToolCalls(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly ToolCallReservation[];
+    }): Promise<ToolBatchCommit>;
+    startToolCall(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
+    suspendToolCall(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
+    commitToolResult(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+        result: ToolExecutionResult$1;
+        state: "completed" | "failed" | "indeterminate";
+        reason?: string;
+    }): Promise<ToolCommit>;
+    cancelRun(input: {
+        runId: RunId;
+        expectedRevision?: number;
+        reason?: string;
+        output?: AssistantMessage;
+    }): Promise<RunRecord>;
+    snapshotRun(runId: RunId): Promise<RunSnapshot>;
+    history(agentId: AgentId): Promise<readonly Message[]>;
+    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;
+    bootstrap?: (registry: RuntimeBootstrapRegistry) => void | Promise<void>;
 }>;
-type ToolBatchCommit = Readonly<{
-    run: RunRecord;
-    toolCalls: readonly ToolCallSnapshot[];
+type DurableConsumer = Readonly<{
+    caughtUp: Promise<void>;
+    done: Promise<void>;
+    stop(): void;
 }>;
-type RunRecord = Readonly<{
-    id: RunId;
-    agentId: AgentId;
-    agentSequence: number;
-    readySequence: number;
-    revision: number;
-    state: RunState;
-    input: UserInput;
-    initialMessageId?: MessageId;
-    invalidatedBy?: Readonly<{
+interface AgentRun {
+    readonly id: RunId;
+    snapshot(): Promise<RunSnapshot>;
+    observe(options?: {
+        after?: EventCursor;
+        signal?: AbortSignal;
+    }): AsyncIterable<RunEvent>;
+    wait(options?: {
+        signal?: AbortSignal;
+    }): Promise<RunBoundary>;
+    respondInteraction(input: {
+        interactionId: string;
+        input?: JsonValue;
+        cancel?: boolean;
+    }): Promise<void>;
+    cancel(reason?: string): Promise<RunBoundary>;
+}
+interface AgentRuntime$1 {
+    loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
+    loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
+    loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
+    loadTools(input: Readonly<{
+        sourceId: string;
+        values: readonly Tool$1[];
+    }>): Promise<LoadResult>;
+    unload(input: Readonly<{
+        kind: ResourceKind;
+        sourceId: string;
+    }>): Promise<LoadResult>;
+    createAgent(config: AgentConfiguration, options?: {
+        idempotencyKey?: string;
+        metadata?: Metadata;
+        historySeed?: HistorySeed;
+    }): Promise<AgentId>;
+    updateAgentConfig(agentId: AgentId, config: AgentConfiguration, options: {
+        idempotencyKey: string;
+    }): Promise<void>;
+    deleteAgent(input: AgentDeletionRequest): Promise<void>;
+    revise(agentId: AgentId, input: {
         messageId: MessageId;
-        messageRevision: number;
-    }>;
-    metadata?: Metadata;
-    pinnedConfigToken?: ConfigToken;
-    checkpoint?: ExecutionCheckpoint;
-    openInputRequest?: InputRequest;
-    openInteractions?: readonly PhaseInteraction[];
-    interactionAnswers?: Readonly<Record<string, JsonValue>>;
-    execution?: ExecutionToken;
-    outcome?: Outcome;
-    failure?: RunFailure;
-    cancellationReason?: string;
-    createdAt: string;
-    updatedAt: string;
+        expectedMessageRevision: number;
+        content: UserContent;
+        operationId: string;
+        effectDigestConfirmation?: string;
+    }): Promise<MessageRevisionResult>;
+    compact(input?: {
+        now?: string;
+        retentionMs?: number;
+    }): Promise<RetentionResult>;
+    start(agentId: AgentId, input: UserInput, options: {
+        idempotencyKey: string;
+        metadata?: Metadata;
+    }): Promise<AgentRun>;
+    run(runId: RunId): AgentRun;
+    contextStatus(agentId: AgentId, options?: {
+        contextWindow?: number;
+    }): Promise<ContextStatus>;
+    compactContext(agentId: AgentId, options?: {
+        input?: UserInput;
+        instructions?: string;
+        idempotencyKey?: string;
+    }): Promise<AgentRun>;
+    listInvocations(agentId: AgentId, options: {
+        source: InvocationSource;
+    }): Promise<readonly InvocationCatalogEntry[]>;
+    history(agentId: AgentId): Promise<readonly Message[]>;
+    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 MessageRevisionResult = Readonly<{
-    message: UserMessage & Readonly<{
-        messageRevision: number;
+
+interface SourceInfo {
+    source: string;
+    baseDir?: string;
+    displayName?: string;
+}
+/** Register a Phase by directory path or Phase object; PHASE.md and direct child Skills are loaded atomically when a path is supplied. */
+type PhaseRegistration = string | Phase;
+/**
+ * Tool definition for registering LLM-callable tools via `api.tool.register()`.
+ *
+ * @example
+ * ```typescript
+ * api.tool.register({
+ *   name: "search_docs",
+ *   description: "Search documentation",
+ *   parameters: { type: "object", properties: { query: { type: "string" } } },
+ *   execute: async (args, ctx) => {
+ *     return { content: [{ type: "text", text: "result" }] };
+ *   },
+ * });
+ * ```
+ */
+interface ToolDefinition {
+    /** Tool name (used in LLM tool calls) */
+    name: string;
+    /** Description for LLM */
+    description: string;
+    /** Parameter schema (JSON Schema) */
+    parameters: Record<string, unknown>;
+    /** Execute the tool */
+    execute: (args: unknown, context: ToolInvocationContext, signal?: AbortSignal) => Promise<ToolExecutionResult>;
+    /** Optional: per-tool execution mode override */
+    executionMode?: "sequential" | "parallel";
+}
+/**
+ * Result from tool execution.
+ */
+interface ToolExecutionResult {
+    /** Content blocks to return to the LLM */
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
     }>;
-    replacementRun: RunRecord;
-    invalidatedRunIds: readonly RunId[];
-    affectedToolCallIds: readonly ToolCallId[];
-    effectDigest?: string;
-}>;
-type RetentionResult = Readonly<{
-    deletedRunIds: readonly RunId[];
-    deletedToolCallIds: readonly ToolCallId[];
-    deletedEventCount: number;
-    retentionFloor: EventCursor;
-    skipped?: "active_consumers" | "no_eligible_events";
-}>;
-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;
+    /** Whether this is an error result */
+    isError?: boolean;
+}
+/**
+ * Registered tool with source metadata.
+ */
+interface RegisteredTool {
+    definition: ToolDefinition;
+    sourceInfo: SourceInfo;
+}
+/**
+ * Structured extension error with attribution.
+ */
+interface ExtensionError {
+    /** Path of the extension that caused the error */
+    extensionPath: string;
+    /** Event or operation that caused the error */
+    event: string;
+    /** Error message */
+    error: string;
+    /** Optional stack trace */
+    stack?: string;
+}
+/** Error listener callback type. */
+type ExtensionErrorListener = (error: ExtensionError) => void;
+type ExecOptions = {
+    /** Working directory for the command. Defaults to cwd passed to runtime. */
+    cwd?: string;
+    /** Environment variables to add/override. */
+    env?: Record<string, string>;
+    /** Timeout in milliseconds. */
+    timeout?: number;
+    /** AbortSignal for cancellation. */
+    signal?: AbortSignal;
+};
+type ExecResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * Shared runtime state created by loader, used during registration and runtime.
+ * All ExtensionAPI instances reference this shared state.
+ *
+ * It only owns the lifetime guard shared by captured Extension API objects.
+ */
+interface ExtensionRuntime {
+    /** Throws when this extension instance is stale after runtime replacement. */
+    assertActive: () => void;
+    /** Marks this extension instance as stale after runtime replacement or reload. */
+    invalidate: (message?: string) => void;
+}
+/**
+ * Result of loading extensions from filesystem.
+ * The runner takes these and creates Extension tracking objects.
+ */
+type LoadExtensionsResult = {
+    extensions: LoadedExtension[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+};
+/**
+ * Pre-initialization extension form — factory + metadata.
+ * Runner.loadExtensions() calls the factory and creates the full Extension object.
+ */
+interface LoadedExtension {
+    path: string;
+    name: string;
+    factory: ExtensionFactory;
+    manifest?: ExtensionManifest;
+}
+/** Extension manifest from package.json `rowan` field. */
+interface ExtensionManifest {
+    entry?: string;
+    name?: string;
+}
+
+/**
+ * Extension API object passed to extension factory function.
+ *
+ * @example
+ * ```typescript
+ * export default function(api: ExtensionAPI) {
+ *   // api provides all extension APIs
+ * }
+ * ```
+ */
+interface ExtensionAPI {
+    /**
+     * Subscribe to a hook event.
+     *
+     * @param eventType - Hook type, e.g. "before_tool_call"
+     * @param handler - Hook handler, can return result to modify behavior
+     */
+    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    /** Unsubscribe from a hook event. */
+    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    /** Tool capabilities — register and unregister custom tools. */
+    tool: {
+        /** Register a custom LLM-callable tool. */
+        register(tool: ToolDefinition): void;
+        /** Unregister a previously registered tool by name. */
+        unregister(toolName: string): void;
+    };
+    /** Register a model provider. */
+    registerProvider(config: _rowan_agent_models.ProviderConfig): void;
+    /** Unregister a model provider. */
+    unregisterProvider(name: string): void;
+    /** Extension manifest from package.json `rowan` field. */
+    manifest?: ExtensionManifest;
+    /** Utility functions. */
+    utils: ExtensionUtils;
+    /** Runtime context — cwd, signal, exec, message access, etc. */
+    context: ExtensionContext;
+    /** Shared event bus for inter-extension communication. */
+    events: EventBus;
+    /** Phase execution capabilities — provides Phase In/Out, phase identity, phase routing, and registration. */
+    phase: {
+        /** Register a Phase directory bundle or Phase object. */
+        register(phase: PhaseRegistration): Promise<void>;
+        /** Unregister a previously registered phase by name. */
+        unregister(phaseName: string): void;
+        /** Phase In: get payload from previous phase */
+        getPayload(): unknown;
+        /** Phase Out: set payload for next phase */
+        setPayload(payload: unknown): void;
+        /** Phase Out: set outcome message */
+        setMessage(message: string): void;
+        /** Get current phase name */
+        getCurrentPhase(): string;
+        /** Set next phase (lower priority than PHASE.md target) */
+        setNextPhase(phaseName: string): void;
+        /** Get the next phase set by setNextPhase */
+        getNextPhase(): string | undefined;
+        /** Get the message set by setMessage */
+        getMessage(): string | undefined;
+        /** Phase Settings contributions registered by the Phase extension. */
+        settings: {
+            register(provider: PhaseSettingsProvider): void;
+        };
+    };
+}
+/**
+ * Extension factory function.
+ * Receives ExtensionAPI for registering hooks, phases, and providers.
+ */
+type ExtensionDisposer = () => void | Promise<void>;
+type ExtensionFactoryResult = void | ExtensionDisposer;
+type ExtensionFactory = (api: ExtensionAPI) => ExtensionFactoryResult | Promise<ExtensionFactoryResult>;
+
+type PhaseStatusState = "running" | "completed";
+/** Normalized status event exposed to Runtime consumers. */
+type PhaseStatus = Readonly<{
+    state: PhaseStatusState;
+    /** Stable consumer-facing status identifier, e.g. `compacting`. */
+    kind: string;
+    /** Optional human-readable detail for UI/status consumers. */
+    message?: string;
+    /** Structured status payload. */
+    payload?: unknown;
 }>;
-type RunSnapshot = RunSnapshotBase & (Readonly<{
-    state: "queued" | "running";
-}> | Readonly<{
-    state: "input_required";
-    request: Readonly<{
-        id: InputRequestId;
-        phase: string;
-        prompt?: AssistantMessage;
+/** Unified phase output — model-driven routing is optional; programmatic phases may normalize omission to stop. */
+type PhaseOutput = {
+    /** User-visible assistant message. */
+    message?: string;
+    /** Final status update for non-conversational consumers. */
+    status?: PhaseStatus;
+    /** Route to next phase, or "continue" to re-execute current phase, or "stop" to end. Undefined means no model route. */
+    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;
     }>;
-    interactions: readonly PhaseInteraction[];
-    answers: Readonly<Record<string, JsonValue>>;
-}> | 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;
-    phase: string;
-    prompt?: AssistantMessage;
-    interactions: readonly PhaseInteraction[];
-    answers: Readonly<Record<string, JsonValue>>;
-}> | Readonly<{
-    type: "completed";
-    outcome: Outcome;
-    output?: AssistantMessage;
-}> | Readonly<{
-    type: "failed";
-    failure: RunFailure;
-}> | Readonly<{
-    type: "cancelled";
-    reason?: string;
+    /** 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;
+};
+/** Durable identity of the Run execution currently invoking a Phase. */
+type PhaseExecutionIdentity = Readonly<{
+    agentId: string;
+    runId: string;
+    executionId: string;
+    /** Original durable Run input, before any Phase-local interpretation. */
+    input?: UserContent;
+    /** Opaque metadata captured at the durable boundary; Rowan does not decode it. */
+    agentMetadata?: Readonly<Record<string, unknown>>;
+    runMetadata?: Readonly<Record<string, unknown>>;
 }>;
-type ConfigResolution = Readonly<{
-    kind: "available";
-    config: AgentConfiguration | ConfigurationSnapshot;
+/** Everything a phase needs to execute */
+interface PhaseContext {
+    systemPrompt: string;
+    messages: AgentMessage[];
+    /** Phase-filtered tools */
+    tools: Tool[];
+    /** Phase-filtered skills */
+    skills: Skill[];
+    /** Phase machine state */
+    state: PhaseState;
+    /** Identity and dispatch metadata for this phase execution */
+    readonly invocation: PhaseInvocation;
+    /** Durable Run identity for cross-store integrations and idempotent commands. */
+    readonly execution: PhaseExecutionIdentity;
+    /** Additional guideline bullets appended to the system prompt */
+    promptGuidelines?: string[];
+    /** Text to append after the system prompt */
+    appendSystemPrompt?: string;
+}
+/** JSON-safe structural defaults declared by a Phase's `input` mapping. */
+type PhaseInput = Readonly<Record<string, JsonValue>>;
+/** JSON-safe option metadata exposed by a Phase to a host Settings surface. */
+interface PhaseSettingsOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface PhaseSettingsBadge {
+    label: string;
+    tone?: "neutral" | "success" | "review" | "danger";
+}
+interface PhaseSettingsItem {
+    id: string;
+    title: string;
+    description?: string;
+    badges?: readonly PhaseSettingsBadge[];
+}
+type PhaseSettingsControl = {
+    type: "boolean";
+    path: string;
+    label: string;
+    description?: string;
 } | {
-    kind: "deferred";
-    retryAfterMs?: number;
+    type: "number";
+    path: string;
+    label: string;
+    description?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    scale?: number;
 } | {
-    kind: "unavailable";
-    reason: string;
-}>;
-type ConfigPutResult = Readonly<{
-    kind: "stored";
-    token: string;
+    type: "select";
+    path: string;
+    label: string;
+    description?: string;
+    options: readonly PhaseSettingsOption[];
 } | {
-    kind: "identity_conflict";
-}>;
-interface ConfigProvider {
-    put(input: {
-        agentId: AgentId;
-        agentMetadata?: Metadata;
-        config: AgentConfiguration | ConfigurationSnapshot;
-        operationId: string;
-        signal: AbortSignal;
-    }): Promise<ConfigPutResult>;
-    resolve(input: {
-        agentId: AgentId;
-        agentMetadata?: Metadata;
-        token: ConfigToken;
-        signal: AbortSignal;
-    }): Promise<ConfigResolution>;
+    type: "text";
+    path: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    format?: "string" | "string-array" | "key-value";
+    multiline?: boolean;
+} | {
+    type: "collection";
+    path: string;
+    label: string;
+    description?: string;
+    items: readonly PhaseSettingsItem[];
+    fields: readonly PhaseSettingsControl[];
+    add?: {
+        label: string;
+        idLabel?: string;
+        fields: readonly PhaseSettingsControl[];
+    };
+    removeLabel?: string;
+};
+interface PhaseSettingsSection {
+    id: string;
+    title: string;
+    description?: string;
+    controls: readonly PhaseSettingsControl[];
 }
-interface OwnedStore {
-    readonly lease: OwnerLease;
-    reserveAgent(input: {
-        idempotencyKey: string;
-        metadata?: Metadata;
-        configIdentity?: string;
-        historySeed?: HistorySeed;
-    }): Promise<AgentRecord>;
-    activateAgent(agentId: AgentId, configToken?: ConfigToken, configIdentity?: string): Promise<AgentRecord>;
-    updateAgentConfigToken(input: {
-        agentId: AgentId;
-        token: ConfigToken;
-        configIdentity?: string;
-        idempotencyKey: string;
-    }): Promise<AgentRecord>;
-    deleteAgent(input: AgentDeletionRequest): Promise<void>;
-    reviseMessage(input: {
-        agentId: AgentId;
-        messageId: MessageId;
-        expectedMessageRevision: number;
-        content: UserContent;
-        operationId: string;
-        effectDigestConfirmation?: string;
-    }): Promise<MessageRevisionResult>;
-    compact(input?: {
-        now?: string;
-        retentionMs?: number;
-    }): Promise<RetentionResult>;
-    contextStatus(agentId: AgentId, contextWindow: number): Promise<ContextStatus>;
-    contextMessages(agentId: AgentId, recentTokenBudget?: number): Promise<readonly Message[]>;
-    commitContextCompaction(record: ContextCompactionRecord): Promise<ContextCompactionRecord>;
-    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;
-        phase: string;
-        prompt?: AssistantMessage;
-        checkpoint: ExecutionCheckpoint;
-        interactions?: readonly PhaseInteraction[];
-        interactionAnswers?: Readonly<Record<string, JsonValue>>;
-    }): Promise<InputRequiredCommit>;
-    answerInput(input: {
-        runId: RunId;
-        requestId: InputRequestId;
-        expectedRevision: number;
-        input: UserInput;
-        messageId?: MessageId;
-    }): Promise<RunRecord>;
-    answerInteraction(input: {
-        runId: RunId;
-        interactionId: string;
-        expectedRevision: number;
-        input: JsonValue;
-    }): 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;
-        providerToolCallId?: string;
-    }): Promise<ToolCommit>;
-    reserveToolCalls(input: {
-        runId: RunId;
-        execution: ExecutionToken;
-        expectedRevision: number;
-        requestMessageId: MessageId;
-        calls: readonly ToolCallReservation[];
-    }): Promise<ToolBatchCommit>;
-    startToolCall(input: {
-        runId: RunId;
-        execution: ExecutionToken;
-        expectedRevision: number;
-        toolCallId: ToolCallId;
-    }): Promise<ToolCommit>;
-    commitToolResult(input: {
-        runId: RunId;
-        execution: ExecutionToken;
-        expectedRevision: number;
-        toolCallId: ToolCallId;
-        result: ToolExecutionResult$1;
-        state: "completed" | "failed" | "indeterminate";
-        reason?: string;
-    }): Promise<ToolCommit>;
-    cancelRun(input: {
-        runId: RunId;
-        expectedRevision?: number;
-        reason?: string;
-        output?: AssistantMessage;
-    }): Promise<RunRecord>;
-    snapshotRun(runId: RunId): Promise<RunSnapshot>;
-    history(agentId: AgentId): Promise<readonly Message[]>;
-    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>;
+/** Declarative, host-neutral Settings surface contributed by a Phase. */
+interface PhaseSettingsDefinition {
+    description?: string;
+    sections: readonly PhaseSettingsSection[];
+}
+/** Host context is intentionally opaque beyond the effective configuration. */
+interface PhaseSettingsContext {
+    configuration: Readonly<Record<string, unknown>>;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+type PhaseSettingsProvider = (context: PhaseSettingsContext) => PhaseSettingsDefinition | Promise<PhaseSettingsDefinition>;
+/**
+ * Loaded Phase object
+ */
+interface Phase {
+    /** Unique phase identity and display name. */
+    name: string;
+    /** Rowan-owned built-in Phase; built-ins are never filtered or disabled. */
+    core?: boolean;
+    /** Description */
+    description: string;
+    /** Restricted tools (undefined = all tools available) */
+    tools?: string[];
+    /** Skills bundled directly inside this phase directory. Inline phases may omit this (equivalent to []). */
+    skills?: Skill[];
+    /** Forced next phase */
+    target?: string;
+    /** Structural JSON-safe input defaults */
+    input?: PhaseInput;
+    /** 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;
+    /** Do not automatically inject this Phase into the model route catalog/context. */
+    disableAutoInvocation?: boolean;
+    /** Do not expose this Phase to direct user invocation. */
+    disableImplicitInvocation?: boolean;
+    /** ExtensionAPI factory function used for registration or programmatic execution. */
+    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;
 }
-interface DurableStore {
-    openOwner(input: {
-        ownerId: string;
-        leaseMs: number;
-    }): Promise<OwnedStore>;
+
+interface BeforePhaseEvent {
+    type: "before_phase";
+    phaseId: string;
+    input: PhaseContext;
 }
-type AgentRuntimeOptions = Readonly<{
-    store: DurableStore;
-    configs?: ConfigProvider;
-    concurrency?: number;
-    bootstrap?: (registry: RuntimeBootstrapRegistry) => void | Promise<void>;
-}>;
-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<RunEvent>;
-    wait(options?: {
-        signal?: AbortSignal;
-    }): Promise<RunBoundary>;
-    respond(input: {
-        requestId: InputRequestId;
-        input: UserInput;
-    }): Promise<void>;
-    respondInteraction(input: {
-        interactionId: string;
-        input: JsonValue;
-    }): Promise<void>;
-    cancel(reason?: string): Promise<RunBoundary>;
+interface AfterPhaseEvent {
+    type: "after_phase";
+    phaseId: string;
+    output: PhaseOutput;
 }
-interface AgentRuntime$1 {
-    loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
-    loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
-    loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
-    loadTools(input: Readonly<{
-        sourceId: string;
-        values: readonly Tool[];
-    }>): Promise<LoadResult>;
-    unload(input: Readonly<{
-        kind: ResourceKind;
-        sourceId: string;
-    }>): Promise<LoadResult>;
-    createAgent(config: AgentConfiguration, options?: {
-        idempotencyKey?: string;
-        metadata?: Metadata;
-        historySeed?: HistorySeed;
-    }): Promise<AgentId>;
-    updateAgentConfig(agentId: AgentId, config: AgentConfiguration, options: {
-        idempotencyKey: string;
-    }): Promise<void>;
-    deleteAgent(input: AgentDeletionRequest): Promise<void>;
-    revise(agentId: AgentId, input: {
-        messageId: MessageId;
-        expectedMessageRevision: number;
-        content: UserContent;
-        operationId: string;
-        effectDigestConfirmation?: string;
-    }): Promise<MessageRevisionResult>;
-    compact(input?: {
-        now?: string;
-        retentionMs?: number;
-    }): Promise<RetentionResult>;
-    start(agentId: AgentId, input: UserInput, options: {
-        idempotencyKey: string;
-        metadata?: Metadata;
-    }): Promise<AgentRun>;
-    run(runId: RunId): AgentRun;
-    contextStatus(agentId: AgentId, options?: {
-        contextWindow?: number;
-    }): Promise<ContextStatus>;
-    compactContext(agentId: AgentId, options?: {
-        input?: UserInput;
-        instructions?: string;
-        idempotencyKey?: string;
-    }): Promise<AgentRun>;
-    listInvocations(agentId: AgentId, options: {
-        source: InvocationSource;
-    }): Promise<readonly InvocationCatalogEntry[]>;
-    history(agentId: AgentId): Promise<readonly Message[]>;
-    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>;
+interface BeforePromptEvent {
+    type: "before_prompt";
+    phaseId: string;
+    input: PhaseContext;
 }
-type ConsumerRegistration = Readonly<{
-    cursor?: EventCursor;
-    waterline: EventCursor;
-}>;
+interface BeforeToolCallEvent {
+    type: "before_tool_call";
+    tool: Tool;
+    args: unknown;
+    readonly runId?: string;
+    readonly agentId?: string;
+    readonly toolCallId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly answer?: unknown;
+}
+interface AfterToolCallEvent {
+    type: "after_tool_call";
+    tool: Tool;
+    result: ToolResult;
+    readonly runId?: string;
+    readonly agentId?: string;
+    readonly toolCallId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
+interface BeforePhaseResult {
+    abort?: Outcome$1;
+    skip?: {
+        route: string;
+        message: string;
+    };
+    input?: PhaseContext;
+}
+interface AfterPhaseResult {
+    abort?: Outcome$1;
+    retry?: PhaseContext;
+    output?: PhaseOutput;
+}
+interface BeforePromptResult {
+    input?: PhaseContext;
+}
+interface BeforeToolCallResult {
+    allow?: boolean;
+    reason?: string;
+    interaction?: RunInteractionRequest;
+}
+interface AfterToolCallResult {
+    result?: ToolResult;
+}
+interface HookResultMap {
+    before_phase: BeforePhaseResult | undefined;
+    after_phase: AfterPhaseResult | undefined;
+    before_prompt: BeforePromptResult | undefined;
+    before_tool_call: BeforeToolCallResult | undefined;
+    after_tool_call: AfterToolCallResult | undefined;
+}
+type HookEventType = HookEvent["type"];
+type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
+    type: K;
+}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
+declare class HooksManager {
+    private handlers;
+    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<void>;
+    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<HookResultMap[K] | undefined>;
+}
+
+type ToolContext = Pick<AgentContext, "skills"> & {
+    toolCallId: string;
+    interaction?: RunInteractionDriver;
+};
+type ToolExecutionMode = "sequential" | "parallel";
+type Tool<TArgs = unknown> = {
+    name: string;
+    /** Rowan-owned Core Tool; Core Tools bypass Phase filtering. */
+    core?: boolean;
+    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[];
+    /** Custom phases for this run. Agent normalizes this with the built-in default phase. */
+    phases?: PhaseRegistry;
+};
+
+/**
+ * `root` anchors relative paths and the Bash working directory. It is not a
+ * filesystem sandbox: core Tools use the permissions of the host process.
+ */
+type CoreToolContext = {
+    root?: string;
+    /** Directory for complete Tool Result spill files. */
+    archiveDir?: string;
+    maxReadBytes?: number;
+    maxReadLines?: number;
+    bashTimeoutMs?: number;
+    maxBashOutputBytes?: number;
+};
 
 declare class AgentRuntime implements AgentRuntime$1 {
     private readonly concurrency;
@@ -2123,7 +2142,7 @@ declare class AgentRuntime implements AgentRuntime$1 {
     loadPhases(input: LoadInput<Phase>): Promise<LoadResult>;
     loadTools(input: Readonly<{
         sourceId: string;
-        values: readonly Tool[];
+        values: readonly Tool$1[];
     }>): Promise<LoadResult>;
     unload(input: Readonly<{
         kind: ResourceKind;
@@ -2191,13 +2210,10 @@ declare class AgentRuntime implements AgentRuntime$1 {
     close(): Promise<void>;
     snapshot(runId: RunId): Promise<RunSnapshot>;
     history(agentId: AgentId): Promise<readonly Message[]>;
-    respond(runId: RunId, input: {
-        requestId: InputRequestId;
-        input: UserInput;
-    }): Promise<void>;
     respondInteraction(runId: RunId, input: {
         interactionId: string;
-        input: JsonValue;
+        input?: JsonValue;
+        cancel?: boolean;
     }): Promise<void>;
     cancel(runId: RunId, reason?: string): Promise<RunBoundary>;
     private pump;
@@ -2206,6 +2222,7 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private resolveContextWindow;
     private executeTool;
     private executeToolBatch;
+    private foldToolInteractionRecords;
     private requireAgent;
     private archiveDirFor;
     private runConsumer;
@@ -2298,6 +2315,7 @@ declare class InMemoryStore implements DurableStore {
         operationId: string;
         effectDigestConfirmation?: string;
     }): MessageRevisionResult;
+    private commitInteractionRecord;
     createRun(lease: OwnerLease, input: {
         agentId: AgentId;
         input: UserInput;
@@ -2318,29 +2336,30 @@ declare class InMemoryStore implements DurableStore {
             code: "configuration_unavailable" | "checkpoint_incompatible";
         }>;
     }): RunRecord;
+    commitPhaseEntered(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phaseId: string;
+        visit: number;
+    }): RunRecord;
     commitInputRequired(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
         expectedRevision: number;
-        requestId?: InputRequestId;
         phase: string;
         prompt?: AssistantMessage;
         checkpoint: ExecutionCheckpoint;
-        interactions?: readonly PhaseInteraction[];
+        interactions?: readonly RunInteraction[];
         interactionAnswers?: Readonly<Record<string, JsonValue>>;
-    }): InputRequiredCommit;
-    answerInput(lease: OwnerLease, input: {
-        runId: RunId;
-        requestId: InputRequestId;
-        expectedRevision: number;
-        input: UserInput;
-        messageId?: MessageId;
+        pendingToolCallIds?: readonly ToolCallId[];
     }): RunRecord;
     answerInteraction(lease: OwnerLease, input: {
         runId: RunId;
         interactionId: string;
         expectedRevision: number;
-        input: JsonValue;
+        input?: JsonValue;
+        cancel?: boolean;
     }): RunRecord;
     reserveToolCall(lease: OwnerLease, input: {
         runId: RunId;
@@ -2370,6 +2389,12 @@ declare class InMemoryStore implements DurableStore {
         expectedRevision: number;
         toolCallId: ToolCallId;
     }): ToolCommit;
+    suspendToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): ToolCommit;
     commitToolResult(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -2514,29 +2539,30 @@ declare class SqliteStore implements DurableStore {
             code: "configuration_unavailable" | "checkpoint_incompatible";
         }>;
     }): Promise<RunRecord>;
+    commitPhaseEntered(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        phaseId: string;
+        visit: number;
+    }): Promise<RunRecord>;
     commitInputRequired(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
         expectedRevision: number;
-        requestId?: InputRequestId;
         phase: string;
         prompt?: AssistantMessage;
         checkpoint: ExecutionCheckpoint;
-        interactions?: readonly PhaseInteraction[];
+        interactions?: readonly RunInteraction[];
         interactionAnswers?: Readonly<Record<string, JsonValue>>;
-    }): Promise<InputRequiredCommit>;
-    answerInput(lease: OwnerLease, input: {
-        runId: RunId;
-        requestId: InputRequestId;
-        expectedRevision: number;
-        input: UserInput;
-        messageId?: MessageId;
+        pendingToolCallIds?: readonly ToolCallId[];
     }): Promise<RunRecord>;
     answerInteraction(lease: OwnerLease, input: {
         runId: RunId;
         interactionId: string;
         expectedRevision: number;
-        input: JsonValue;
+        input?: JsonValue;
+        cancel?: boolean;
     }): Promise<RunRecord>;
     commitOutcome(lease: OwnerLease, input: {
         runId: RunId;
@@ -2574,6 +2600,12 @@ declare class SqliteStore implements DurableStore {
         expectedRevision: number;
         toolCallId: ToolCallId;
     }): Promise<ToolCommit>;
+    suspendToolCall(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        toolCallId: ToolCallId;
+    }): Promise<ToolCommit>;
     commitToolResult(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -2699,7 +2731,8 @@ type RuntimeErrorDetails = {
     }>;
     input_request_conflict: Readonly<{
         runId: RunId;
-        requestId: InputRequestId;
+        interactionId?: string;
+        requestId?: string;
         reason: "not_found" | "wrong_run" | "different_answer";
     }>;
     idempotency_conflict: Readonly<{
@@ -2816,6 +2849,6 @@ interface FrontmatterResult<T = Record<string, unknown>> {
  */
 declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): FrontmatterResult<T>;
 
-declare function createCoreTools(input?: CoreToolContext): Tool[];
+declare function createCoreTools(input?: CoreToolContext): Tool$1[];
 
-export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInteraction, PhaseInteractionBoundary, PhaseInteractionCancelledError, type PhaseInteractionDriver, type PhaseInteractionKind, type PhaseInteractionOrigin, type PhaseInteractionState, type PhaseInteractionStatus, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool, type ToolCallId, type ToolCallInteractionRequest, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InteractionRecord, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunInteraction, RunInteractionBoundary, RunInteractionCancelledError, type RunInteractionDriver, type RunInteractionKind, type RunInteractionRequest, type RunInteractionState, type RunInteractionStatus, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool$1 as Tool, type ToolCallContext, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };