@kodax-ai/kodax 0.7.71 → 0.7.72

package/dist/types-chunks/{types.d-CRCaLt_s.d.ts → types.d-DH1mvdcl.d.ts}

@@ -1,5 +1,235 @@
 import { k as KodaXMessage, a1 as KodaXToolDefinition, F as KodaXReasoningMode, a9 as KodaXWireReasoningEffort, a3 as KodaXToolResultContentItem, Y as KodaXThinkingBlock, I as KodaXRedactedThinkingBlock } from './types.d-Cqaw71Ax.js';
 
+type AgentActorState = 'running' | 'idle' | 'closed';
+type AgentTurnState = 'accepted' | 'running' | 'completed' | 'failed' | 'interrupted';
+type AgentExecutionKind = 'native' | 'constructed' | 'workflow' | 'external';
+type AgentForkTurns = 'all' | 'none' | number;
+type AgentDataClassification = 'public' | 'internal' | 'sensitive';
+type AgentProgressKind = 'status' | 'tool' | 'assistant';
+type AgentInterruptScope = 'turn' | 'subtree';
+type AgentMetadataValue = string | number | boolean | null | readonly AgentMetadataValue[] | {
+    readonly [key: string]: AgentMetadataValue;
+};
+interface AgentCapabilities {
+    readonly tools: readonly string[];
+    readonly filesystem: 'none' | 'read' | 'write';
+    readonly network: boolean;
+    readonly providers: readonly string[];
+    readonly canAskUser: boolean;
+    /** Backend operation support. Omitted means the complete native contract. */
+    readonly control?: {
+        readonly followup: boolean;
+        readonly interrupt: boolean;
+        readonly streaming: boolean;
+        readonly artifacts: boolean;
+    };
+}
+interface AgentActor {
+    readonly path: string;
+    readonly taskName: string;
+    readonly parentPath?: string;
+    readonly kind: AgentExecutionKind;
+    readonly state: AgentActorState;
+    readonly capabilities: AgentCapabilities;
+    readonly turnIds: readonly string[];
+    readonly currentTurnId?: string;
+    readonly mailboxCursor: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly revision: number;
+}
+/** Executor-neutral artifact metadata retained beside the legacy string reference. */
+interface AgentArtifactDescriptor {
+    readonly name: string;
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly size?: number;
+    readonly hash?: string;
+    readonly provenance?: string;
+    readonly producingAgentId?: string;
+    readonly remoteTaskId?: string;
+}
+interface AgentTurn {
+    readonly turnId: string;
+    readonly actorPath: string;
+    readonly sequence: number;
+    readonly state: AgentTurnState;
+    readonly objective: string;
+    readonly forkTurns: AgentForkTurns;
+    readonly metadata?: Readonly<Record<string, AgentMetadataValue>>;
+    readonly createdAt: string;
+    readonly startedAt?: string;
+    readonly completedAt?: string;
+    readonly output?: string;
+    readonly artifacts?: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly structured?: AgentMetadataValue;
+    readonly error?: string;
+    /** Bounded Runtime-owned activity projection; full transcripts remain executor-owned. */
+    readonly progress?: readonly AgentProgressItem[];
+    readonly revision: number;
+}
+interface AgentProgressUpdate {
+    readonly kind: AgentProgressKind;
+    readonly summary: string;
+}
+interface AgentProgressItem extends AgentProgressUpdate {
+    readonly sequence: number;
+    readonly createdAt: string;
+}
+interface AgentMailboxMessage {
+    readonly messageId: string;
+    readonly sequence: number;
+    readonly senderPath: string;
+    readonly recipientPath: string;
+    readonly turnId?: string;
+    readonly kind: 'message' | 'followup' | 'completion';
+    readonly classification: AgentDataClassification;
+    /** Canonical actors that handled this chain; absent only on pre-hardening schema-v1 snapshots. */
+    readonly lineage?: readonly string[];
+    readonly forwardedMessageId?: string;
+    readonly content: string;
+    readonly createdAt: string;
+}
+type AgentEventKind = 'actor_spawned' | 'turn_started' | 'message_delivered' | 'turn_progress' | 'turn_completed' | 'turn_failed' | 'turn_interrupted' | 'actor_closed';
+interface AgentEvent {
+    readonly sequence: number;
+    readonly kind: AgentEventKind;
+    readonly actorPath: string;
+    readonly turnId?: string;
+    readonly parentPath?: string;
+    readonly progress?: AgentProgressItem;
+    readonly createdAt: string;
+}
+interface AgentSpawnInput {
+    readonly taskName: string;
+    readonly objective: string;
+    readonly kind?: AgentExecutionKind;
+    readonly forkTurns?: AgentForkTurns;
+    readonly capabilities?: Partial<AgentCapabilities>;
+    readonly metadata?: Readonly<Record<string, AgentMetadataValue>>;
+}
+interface AgentTurnRef {
+    readonly actorPath: string;
+    readonly turnId: string;
+    readonly state: 'accepted' | 'running';
+}
+interface AgentFollowupResult {
+    readonly delivery: 'started_turn' | 'current_turn';
+    readonly turn: AgentTurnRef;
+}
+interface AgentTreeSnapshot {
+    readonly rootPath: '/root';
+    readonly actors: readonly AgentListEntry[];
+    readonly activeNonRootTurns: number;
+    readonly maxConcurrentThreads: number;
+    readonly revision: number;
+}
+interface AgentTurnSummary {
+    readonly turnId: string;
+    readonly state: AgentTurnState;
+    readonly summary: string;
+    readonly summaryTruncated: boolean;
+    readonly recentActivity: readonly AgentProgressItem[];
+}
+interface AgentListEntry extends AgentActor {
+    readonly latestTurn?: AgentTurnSummary;
+}
+interface AgentDetail {
+    readonly actor: AgentActor;
+    readonly turns: readonly AgentTurn[];
+    readonly mailbox: readonly AgentMailboxMessage[];
+}
+interface AgentOutput {
+    readonly actorPath: string;
+    readonly turnId: string;
+    readonly state: AgentTurnState;
+    readonly output?: string;
+    readonly outputTruncated?: boolean;
+    readonly artifacts: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly progress: readonly AgentProgressItem[];
+    readonly structured?: AgentMetadataValue;
+    readonly error?: string;
+}
+interface AgentLimitReached {
+    readonly code: 'agent_limit_reached';
+    readonly maxConcurrentThreads: number;
+    readonly activeNonRootTurns: number;
+    readonly availableNonRootSlots: 0;
+    readonly retryable: true;
+}
+interface AgentBudgetExhausted {
+    readonly code: 'agent_budget_exhausted';
+    readonly retryable: false;
+    readonly reason: string;
+}
+interface AgentBudgetAdmissionInput {
+    readonly actorPath: string;
+    readonly parentPath: string;
+    readonly turnId: string;
+    readonly kind: AgentExecutionKind;
+    readonly units: 1;
+}
+type AgentBudgetAdmission = {
+    readonly admitted: true;
+} | {
+    readonly admitted: false;
+    readonly fact: AgentBudgetExhausted;
+};
+interface AgentBudgetPort {
+    admit(input: AgentBudgetAdmissionInput): Promise<AgentBudgetAdmission>;
+    refund?(turnId: string): Promise<void>;
+    snapshot?(): unknown;
+}
+interface AgentExecutionInput {
+    readonly actor: AgentActor;
+    readonly turn: AgentTurn;
+    readonly priorTurns: readonly AgentTurn[];
+    readonly signal: AbortSignal;
+    drainMailbox(): Promise<readonly AgentMailboxMessage[]>;
+    reportProgress(update: AgentProgressUpdate): Promise<void>;
+}
+interface AgentExecutionResult {
+    readonly output: string;
+    readonly artifacts?: readonly string[];
+    readonly artifactDetails?: readonly AgentArtifactDescriptor[];
+    readonly structured?: AgentMetadataValue;
+}
+interface AgentMutationOptions {
+    /** Optimistic Actor revision checked inside the serialized durable mutation. */
+    readonly expectedRevision?: number;
+}
+interface AgentTurnExecutor {
+    execute(input: AgentExecutionInput): Promise<AgentExecutionResult>;
+}
+interface AgentActorSnapshot {
+    readonly schemaVersion: 1;
+    readonly revision: number;
+    readonly maxConcurrentThreads: number;
+    readonly actors: readonly AgentActor[];
+    readonly turns: readonly AgentTurn[];
+    readonly mailboxes: Readonly<Record<string, readonly AgentMailboxMessage[]>>;
+    readonly events: readonly AgentEvent[];
+}
+interface AgentActorStore {
+    load(): Promise<AgentActorSnapshot | undefined>;
+    save(snapshot: AgentActorSnapshot, expectedRevision: number): Promise<void>;
+}
+/** Runtime-bound actor control surface. The caller path is minted by Runtime. */
+interface AgentActorClient {
+    readonly callerPath: string;
+    spawn(input: AgentSpawnInput): Promise<AgentTurnRef>;
+    send(targetPath: string, content: string, classification?: AgentDataClassification, forwardedMessageId?: string): Promise<AgentMailboxMessage>;
+    followup(targetPath: string, objective: string, metadata?: Readonly<Record<string, AgentMetadataValue>>, options?: AgentMutationOptions): Promise<AgentFollowupResult>;
+    interrupt(targetPath: string, reason?: string, scope?: AgentInterruptScope): Promise<void>;
+    list(): AgentTreeSnapshot;
+    get(targetPath: string): AgentDetail;
+    output(targetPath: string, turnId?: string): AgentOutput;
+    eventSnapshot(afterSequence?: number): readonly AgentEvent[];
+    wait(afterSequence?: number, timeoutMs?: number, signal?: AbortSignal): Promise<AgentEvent | undefined>;
+}
+
 /**
  * @kodax-ai/agent Types
  *
@@ -230,6 +460,8 @@ type KodaXSessionUiHistoryItemType = KodaXSessionUiTextHistoryItemType | 'tool_g
 interface KodaXSessionUiTextHistoryItem {
     type: KodaXSessionUiTextHistoryItemType;
     text: string;
+    /** Original UI event time in epoch milliseconds. Absent on older sessions. */
+    timestamp?: number;
     icon?: string;
     compactText?: string;
 }
@@ -249,6 +481,8 @@ interface KodaXSessionUiToolCall {
 }
 interface KodaXSessionUiToolGroupHistoryItem {
     type: 'tool_group';
+    /** Original UI event time in epoch milliseconds. Absent on older sessions. */
+    timestamp?: number;
     tools: KodaXSessionUiToolCall[];
 }
 type KodaXSessionUiHistoryItem = KodaXSessionUiTextHistoryItem | KodaXSessionUiToolGroupHistoryItem;
@@ -273,7 +507,7 @@ interface KodaXSessionRuntimeInfo {
     reasoningMode?: string;
     /** Permission mode active at session start, e.g. `'auto'` | `'plan'`. */
     permissionMode?: string;
-    /** Agent mode active at session start, e.g. `'sa'` | `'ama'` | `'amaw'`. */
+    /** Agent mode active at session start, e.g. `'sa'` | `'ama'`. */
     agentMode?: string;
 }
 interface KodaXSessionData {
@@ -290,6 +524,8 @@ interface KodaXSessionData {
     extensionRecords?: KodaXExtensionSessionRecord[];
     lineage?: KodaXSessionLineage;
     artifactLedger?: KodaXSessionArtifactLedgerEntry[];
+    /** Runtime-owned F270 Actor tree snapshot; persisted with the session owner. */
+    actorSnapshot?: AgentActorSnapshot;
 }
 interface KodaXSessionMeta {
     _type: 'meta';
@@ -305,6 +541,8 @@ interface KodaXSessionMeta {
     extensionState?: KodaXExtensionSessionState;
     extensionRecordCount?: number;
     artifactLedgerCount?: number;
+    /** Runtime-owned F270 Actor tree snapshot; absent on pre-v0.7.72 sessions. */
+    actorSnapshot?: AgentActorSnapshot;
     lineageVersion?: 2;
     activeEntryId?: string | null;
     lineageEntryCount?: number;
@@ -481,7 +719,7 @@ interface Guardrail {
  *     the caller exits. Mirrors the Scout → Generator upgrade path.
  *   - `as-tool`: `target` is invoked like a tool from within the caller loop;
  *     only the generated input is passed, and control returns on completion.
- *     Mirrors FEATURE_067 `dispatch_child_task`.
+ *     Mirrors the bounded handoff used by an Actor Turn.
  *
  * `inputFilter` is applied to the visible history before the target runs;
  * default is no filtering.
@@ -512,8 +750,8 @@ interface Agent<TContext = unknown> {
     readonly guardrails?: readonly Guardrail[];
     /**
      * FEATURE_191 — one-sentence human-readable summary surfaced to
-     * other agents that may dispatch this one (e.g., via the
-     * `dispatch_child_task(subagent_type=<name>)` Worker SP block). The
+     * other agents that may select this one (e.g., via
+     * `spawn_agent(agent_id=<name>)`). The
      * field propagates from `AgentContent.description` when the agent is
      * built via the construction substrate; built-in / SDK-created
      * agents may set it directly. Optional for backward compatibility
@@ -1441,8 +1679,8 @@ interface SessionDispatchResult {
  *     functions of the immutable event payload + read-only context.
  *   - `assertTerminal` must be called exactly once at run end. The
  *     Runner is responsible for honoring this.
- *   - The session is single-run; spawning a sub-run (handoff /
- *     dispatch_child_task) creates a fresh session for the target.
+ *   - The session is single-run; spawning a sub-run (handoff / Actor Turn)
+ *     creates a fresh session for the target.
  *
  * The session is never exposed across module boundaries — it lives in
  * the Runner closure and dies when the run ends. WeakMap is overkill
@@ -2263,154 +2501,6 @@ interface KodaXVideoInputArtifact {
 }
 type KodaXInputArtifact = KodaXImageInputArtifact | KodaXFileInputArtifact | KodaXVideoInputArtifact;
 
-/**
- * Child task registry primitive — generic fan-out tracking.
- *
- * FEATURE_120 v0.7.39 Step 0 (package-attribution migration, ADR-021).
- * Lifted from `@kodax-ai/coding`'s `KodaXToolExecutionContext.childTaskRegistry`
- * field + inline cleanup chain in `tools/dispatch-child-tasks.ts`. The
- * coding side now consumes this primitive specialized to its
- * `KodaXChildExecutionResult` type; any other agent-flavor downstream
- * can specialize on its own child-result type without re-implementing
- * the cleanup contract.
- *
- * The shape is intentionally minimal: a Map plus a `register` helper
- * that bundles the v0.7.38 FEATURE_155 Bug A hotfix (`c1bdaf4e`)
- * cleanup chain into a single call site. The helper exists because
- * the cleanup is **not optional** — without it, every settled promise
- * stays in the registry forever, gets re-wrapped by the next
- * idle-yield `waitForWakeEvent` call, and fires spurious
- * `child-completed` wakes (production symptom: Evaluator gets
- * bombarded by duplicate `<task-completed>` notifications, consuming
- * an LLM turn each up to `IDLE_YIELD_MAX_ITERATIONS=64`).
- */
-/**
- * Map of `task_id` → in-flight child-execution promise. Generic over
- * the child-result type so the agent layer doesn't depend on any
- * specific agent flavor's result shape.
- *
- * Mutation contract:
- *   - Owned by the runner's per-turn execution context. The dispatch
- *     tool writes via `registerChildTask`; the idle-yield outer loop
- *     reads via `Map.prototype.entries()` / `.size`.
- *   - **Never delete entries manually** — call `registerChildTask`
- *     and the cleanup chain it installs will run on settle.
- */
-type ChildTaskRegistry<T> = Map<string, Promise<T>>;
-/**
- * Register an in-flight child-execution promise in the registry and
- * install the cleanup chain that removes the entry once the promise
- * settles (success or failure).
- *
- * The cleanup chain is two stages:
- *   1. `.finally(() => registry.delete(childId))` — runs on settle
- *      regardless of outcome, removing the entry before the next
- *      idle-yield outer-loop iteration observes the registry.
- *   2. `.catch(() => {})` — swallows the rejection on the cleanup
- *      chain so a child that crashes before any consumer awaits it
- *      doesn't surface as `unhandledRejection` on Node. Must come
- *      AFTER `.finally` because `.finally` returns a NEW promise
- *      that rejects with the same reason.
- *
- * The original `promise` argument is **not** returned — the helper's
- * value-add is the cleanup side-effect, not promise transformation.
- * Callers that need to await the result read from `registry.get(id)`
- * or hold their own reference.
- *
- * @throws Error when `childId` already exists in the registry. Caller
- *   should report this to the LLM as a tool-error (duplicate task_id);
- *   the helper does NOT swallow the conflict because that would
- *   silently overwrite an in-flight child's tracking entry.
- */
-declare function registerChildTask<T>(registry: ChildTaskRegistry<T>, childId: string, promise: Promise<T>): void;
-
-/**
- * Generic per-task abort primitive — `requestTaskStop`.
- *
- * FEATURE_120 v0.7.39 Phase 3a (ADR-021). Coordinator-style agents need
- * to request that a specific in-flight child task exit gracefully. The
- * @kodax-ai/agent layer owns the abort-controller registry shape and
- * the abort-dispatch decision; agent-flavor wrappers (e.g. the coding
- * `task_stop` tool, Phase 3b) layer in domain framing such as the
- * `<coordinator-stop-request>` message tag.
- *
- * What this primitive owns:
- *   - A `TaskAbortRegistry` type alias = `Map<string, AbortController>`.
- *     The map is owned + mutated by the caller; the primitive only
- *     reads it. Callers use `registry.set(id, controller)` /
- *     `registry.delete(id)` directly — the standard `Map` mutators
- *     are simple enough that wrapping them adds no value.
- *   - `requestTaskStop({taskId, registry, reason?})` — looks up the
- *     controller, decides whether to abort, calls `controller.abort`,
- *     returns a structured outcome.
- *
- * Abort semantics (matches the existing FEATURE_115 soft-pause
- * principle): aborting fires the signal but does NOT interrupt any
- * synchronous tool that's already executing. The child's next abort
- * check (`signal.throwIfAborted()` or an `signal.aborted` poll)
- * surfaces the abort. This matches Node's AbortController contract.
- *
- * What this primitive does NOT do (deliberate):
- *   - Enqueue a coordinator-stop-request message — that's a
- *     coding-flavor convenience and uses the existing
- *     `routeMessage` primitive at the tool layer.
- *   - Track abort lifecycle / auto-cleanup the registry — the
- *     controller's lifetime is tied to its owning task's Promise;
- *     the caller removes the registry entry when the task settles
- *     (typically in a `.finally` chain alongside the child-task
- *     registry cleanup).
- *   - Time-out enforcement / retry — orthogonal concerns owned at
- *     higher layers if needed.
- */
-/**
- * Registry mapping task ids to their owning AbortController.
- * Lifetime: created per parent-run, populated at child dispatch,
- * cleared when the child Promise settles.
- */
-type TaskAbortRegistry = Map<string, AbortController>;
-interface RequestTaskStopOptions {
-    /** Target task id. Must exist as a key in `registry`. */
-    readonly taskId: string;
-    /** Registry of in-flight task abort controllers. */
-    readonly registry: ReadonlyMap<string, AbortController>;
-    /**
-     * Optional cause forwarded to `AbortController.abort(reason)`.
-     *   - Error → passed through verbatim (preserves stack / custom
-     *     subclasses).
-     *   - string → wrapped in `new Error(reason)`.
-     *   - undefined → a default Error mentioning the taskId is
-     *     fabricated so the child receives a non-empty signal.reason.
-     */
-    readonly reason?: string | Error;
-}
-type RequestTaskStopResult = {
-    readonly ok: true;
-    readonly taskId: string;
-} | {
-    readonly ok: false;
-    readonly reason: 'unknown-target';
-    readonly taskId: string;
-} | {
-    readonly ok: false;
-    readonly reason: 'already-aborted';
-    readonly taskId: string;
-};
-/**
- * Look up `taskId` in `registry`. If found and not yet aborted, abort
- * the controller with the supplied reason. Returns a discriminated
- * outcome so callers can render success / error UX without string
- * matching.
- *
- * `already-aborted` is reported separately from success because the
- * first-abort `signal.reason` is preserved verbatim — debugging
- * chains depend on the original cause not being overwritten by
- * subsequent stop requests.
- *
- * Synchronous: `AbortController.abort` is synchronous; no async work
- * is performed by this primitive.
- */
-declare function requestTaskStop(opts: RequestTaskStopOptions): RequestTaskStopResult;
-
 /**
  * FEATURE_125 (v0.7.41) — Team Mode Layer 1: per-instance state broadcast.
  *
@@ -3189,6 +3279,8 @@ interface WorkflowTaskResult {
      *  spawn carried `outputSchema` and a JSON value was parsed from the child's
      *  output. The workflow script consumes it directly (e.g. `result.structured`). */
     readonly structured?: unknown;
+    /** Durable artifacts produced by this Agent turn. */
+    readonly artifacts?: readonly string[];
     /** Short user-facing digest, separate from the full finalText used for synthesis/audit. */
     readonly digest?: string;
     /** True when a digest was attempted but failed (error/timeout/empty); the UI then labels the excerpt fallback. */
@@ -3293,7 +3385,7 @@ interface WorkflowApi {
     /** Snapshot a (possibly running) agent.
      *  @deprecated Prefer `snapshot(taskId)`; `output` is kept as a compatibility alias. */
     output(taskId: string): Promise<WorkflowTaskSnapshot>;
-    /** Send a message to a running agent (via MessageQueue routing). */
+    /** Send a message to a running Agent through its Actor mailbox. */
     send(taskId: string, content: string): Promise<void>;
     /** Stop a running agent (graceful abort). */
     stop(taskId: string, reason: string): Promise<void>;
@@ -3372,14 +3464,11 @@ interface WorkflowModule<TArgs = unknown, TResult = unknown> {
     readonly meta: WorkflowMeta;
     readonly run: WorkflowRun<TArgs, TResult>;
 }
-/**
- * Injected execution backend. The coding layer implements this over its
- * child-dispatch substrate (ChildTaskRegistry / childProgressSnapshots /
- * MessageQueue / executeChildAgents); tests inject a fake. The agent
- * runtime depends ONLY on this interface — never on coding.
- */
+/** Injected execution backend over the host's Runtime-owned Actor plane. */
 interface WorkflowAgentBackend {
     spawn(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskHandle>;
+    /** Wait until the global Actor scheduler can admit a step. False means no slot can ever exist. */
+    waitForAgentCapacity?(signal?: AbortSignal): Promise<boolean>;
     wait(taskId: string, opts?: WorkflowWaitOptions): Promise<WorkflowTaskResult>;
     output(taskId: string): Promise<WorkflowTaskSnapshot>;
     send(taskId: string, content: string): Promise<void>;
@@ -3392,11 +3481,42 @@ interface WorkflowAgentBackend {
     writeArtifact?(name: string, value: unknown): Promise<WorkflowArtifactRef>;
 }
 type WorkflowRunStatus = 'running' | 'completed' | 'failed' | 'stopped';
+type WorkflowOutcomeStatus = 'completed' | 'partial' | 'failed' | 'interrupted';
+interface WorkflowOutcomeResult {
+    readonly taskId: string;
+    readonly name: string;
+    readonly status: WorkflowTaskStatus;
+    readonly summary: string;
+    readonly structured?: unknown;
+    readonly artifacts: readonly string[];
+    readonly usage?: WorkflowTaskUsage;
+}
+interface WorkflowOutcomeError {
+    readonly taskId?: string;
+    readonly name?: string;
+    readonly message: string;
+}
+interface WorkflowOutcomeUsage extends WorkflowTaskUsage {
+    readonly totalSpawned: number;
+}
+/** Stable terminal payload exposed through the Workflow protocol owner's Agent output. */
+interface WorkflowOutcome {
+    readonly runId: string;
+    readonly status: WorkflowOutcomeStatus;
+    readonly summary: string;
+    readonly results: readonly WorkflowOutcomeResult[];
+    readonly artifacts: readonly WorkflowArtifactRef[];
+    readonly coverage: readonly string[];
+    readonly unresolved: readonly string[];
+    readonly errors: readonly WorkflowOutcomeError[];
+    readonly usage: WorkflowOutcomeUsage;
+}
 /** Immutable snapshot of a workflow run's accumulated state. */
 interface WorkflowRunState {
     readonly runId: string;
     readonly status: WorkflowRunStatus;
     readonly totalSpawned: number;
+    readonly results: readonly WorkflowTaskResult[];
     readonly events: readonly WorkflowEvent[];
     readonly artifacts: readonly WorkflowArtifactRef[];
 }
@@ -3412,7 +3532,7 @@ type WorkflowProcessItemKind = 'phase' | 'agent' | 'step' | 'artifact';
  */
 type WorkflowProcessItemOrigin = 'ran' | 'replayed-from-cache';
 type WorkflowProcessSummaryStatus = 'pending' | 'result' | 'notice' | 'unavailable';
-type WorkflowProcessSource = 'command' | 'amaw' | 'review' | 'sdk' | 'capsule' | 'extension' | 'automation';
+type WorkflowProcessSource = 'command' | 'review' | 'sdk' | 'capsule' | 'extension' | 'automation';
 interface WorkflowProcessItem {
     readonly id: string;
     readonly title: string;
@@ -3928,5 +4048,5 @@ interface CreateAgentExecutorPlaneOptions {
     readonly closeTimeoutMs?: number;
 }
 
-export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, InvariantSession as aK, DEFAULT_SYSTEM_CAP as al, MAX_TOOL_LOOP_ITERATIONS as by, SpanImpl as cQ, Runner as cu, buildAssistantMessageFromLlmResult as d$, Tracer as d6, _resetAdmittedAgentBindings as dX, _resetPresetDispatchers as dY, asSingleSelection as dZ, attachRunnerRecoveryTranscript as d_, WorkflowEventRecorder as dh, buildSystemPrompt as e0, buildToolResultMessage as e1, createAgent as e2, createHandoff as e3, createInMemorySession as e4, createInvariantSessionForAgent as e5, createStateWriter as e6, createTrace as e7, createWorkflowProcessTracker as e8, defaultTracer as e9, detectInstructionsInjection as ea, discoverInstances as eb, executeRunnerToolCall as ec, extractAssistantTextFromMessage as ed, getActiveUserInteraction as ee, getAdmittedAgentBindings as ef, hashMemoryIdentityComponent as eg, isAskUserCustomInputAnswer as eh, isFinalWorkflowProcessStatus as ei, isRunnableTool as ej, isRunnerLlmResult as ek, matchesMemoryApplicability as el, memoryApplicabilityFingerprint as em, normalizeHostMetadata as en, readRunnerRecoveryTranscript as eo, registerChildTask as ep, registerPresetDispatcher as eq, requestTaskStop as er, runAdmissionAudit as es, setActiveUserInteraction as et, setAdmittedAgentBindings as eu };
-export type { AgentTaskService as $, AgentExecutorPlaneBackgroundErrorContext as B, AgentExecutorPlaneBackgroundErrorHandler as C, AgentExecutorPlaneBinding as D, AgentExecutorPlaneStore as E, AgentExecutorPreflightResult as F, AgentExecutorProtocol as G, AgentExecutorTaskReference as H, AgentExecutorTaskSnapshot as I, AgentJsonObject as J, AgentJsonValue as K, AgentManifest as L, AgentMessage as M, AgentMiddlewareDeclaration as N, AgentPreflightInput as O, AgentPreflightResult as P, AgentReasoningProfile as Q, AgentRegistrationEnabledMutationOptions as R, AgentRegistrationMutationOptions as S, AgentRegistrationService as T, AgentSpanData as U, AgentTaskCancellation as V, AgentTaskCorrelation as W, AgentTaskEvent as X, AgentTaskFilter as Y, AgentTaskProgress as Z, AgentTaskRegistrationSnapshot as _, KodaXMemoryOutcomeDigest as a$, AgentTaskSnapshot as a0, AgentTaskStartInput as a1, AgentTaskState as a2, AgentTaskUsage as a3, AgentTool as a4, AskUserAnswer as a5, AskUserCustomInputAnswer as a6, AskUserMultiOptions as a7, AskUserQuestionItem as a8, AskUserQuestionOptions as a9, FileOperations as aA, GenerationSpanData as aB, Guardrail as aC, GuardrailSpanData as aD, Handoff as aE, HandoffSpanData as aF, InMemorySessionOptions as aG, InstanceDiscoveryFs as aH, InvariantId as aI, InvariantResult as aJ, KodaXCompactMemoryProgress as aL, KodaXCompactMemorySeed as aM, KodaXExtensionSessionRecord as aN, KodaXExtensionSessionState as aO, KodaXExtensionStore as aP, KodaXExtensionStoreEntry as aQ, KodaXFileInputArtifact as aR, KodaXGoalEventType as aS, KodaXGoalState as aT, KodaXGoalStatus as aU, KodaXImageInputArtifact as aV, KodaXImageMediaType as aW, KodaXInputArtifact as aX, KodaXInputArtifactSource as aY, KodaXJsonValue as aZ, KodaXMemoryInfluenceRef as a_, AskUserSelectionAnswer as aa, CapabilitySupport as ab, ChildTaskRegistry as ac, CompactionAnchor as ad, CompactionConfig as ae, CompactionDetails as af, CompactionResult as ag, CompactionSpanData as ah, CompactionUpdate as ai, CreateAgentExecutorPlaneOptions as aj, CurrentTodoSummary as ak, Deliverable as am, DiscoveredInstance as an, DiscoveryOptions as ao, DispatchableAgentDescriptor as ap, DispatchableAgentListing as aq, DispatchableAgentOrigin as ar, DispatchableAgentQuery as as, EvidenceSpanData as at, ExternalAgentEffectDeclaration as au, ExternalAgentHealth as av, ExternalAgentProtocol as aw, ExternalAgentRegistration as ax, ExternalAgentRegistrationSummary as ay, FanoutSpanData as az, AdmissionAuditOptions as b, MemoryRefFilter as b$, KodaXMemoryOutcomeEvidence as b0, KodaXSessionArchiveMarkerEntry as b1, KodaXSessionArtifactLedgerEntry as b2, KodaXSessionBranchSummaryEntry as b3, KodaXSessionClientNoticeEntry as b4, KodaXSessionCompactionEntry as b5, KodaXSessionData as b6, KodaXSessionEntry as b7, KodaXSessionEntryBase as b8, KodaXSessionGoalEntry as b9, MemoryActionProposal as bA, MemoryApplicability as bB, MemoryApplyPreview as bC, MemoryApplyResult as bD, MemoryApproval as bE, MemoryAuthority as bF, MemoryAutoCuratorInput as bG, MemoryAutoCuratorResult as bH, MemoryBodySnapshot as bI, MemoryClaimKind as bJ, MemoryContextIdentity as bK, MemoryController as bL, MemoryCuratorInput as bM, MemoryDecisionTraceReceipt as bN, MemoryEpisodeReviewResult as bO, MemoryEvent as bP, MemoryGovernanceFinding as bQ, MemoryGovernanceFindingKind as bR, MemoryGovernanceReport as bS, MemoryItemRef as bT, MemoryLifecycle as bU, MemoryLifecycleOperationResult as bV, MemoryPack as bW, MemoryPackHint as bX, MemoryPackInput as bY, MemoryPackTraceMetadata as bZ, MemoryProposalAction as b_, KodaXSessionLabelEntry as ba, KodaXSessionLineage as bb, KodaXSessionMemoryOutcomeDigestEntry as bc, KodaXSessionMemoryReviewReceiptEntry as bd, KodaXSessionMessageEntry as be, KodaXSessionMeta as bf, KodaXSessionNavigationOptions as bg, KodaXSessionRewindMarkerEntry as bh, KodaXSessionRuntimeInfo as bi, KodaXSessionScope as bj, KodaXSessionStorage as bk, KodaXSessionTreeNode as bl, KodaXSessionUiHistoryItem as bm, KodaXSessionUiHistoryItemType as bn, KodaXSessionUiTextHistoryItem as bo, KodaXSessionUiTextHistoryItemType as bp, KodaXSessionUiToolCall as bq, KodaXSessionUiToolCallStatus as br, KodaXSessionUiToolGroupHistoryItem as bs, KodaXSessionWorkspaceKind as bt, KodaXVideoInputArtifact as bu, KodaXVideoMediaType as bv, LocalAgentTaskInput as bw, LocalAgentTaskUpdate as bx, ManifestPatch as bz, AdmissionCtx as c, TaskAbortRegistry as c$, MemoryRefKind as c0, MemoryRejectResult as c1, MemoryReviewCandidateRef as c2, MemoryReviewDraftAction as c3, MemoryReviewInput as c4, MemoryReviewModelInput as c5, MemoryReviewPersistenceDecision as c6, MemoryReviewPersistenceKind as c7, MemoryReviewPlan as c8, MemoryReviewRunner as c9, RunnerToolContext as cA, RunnerToolObserver as cB, RunnerToolResult as cC, RunnerToolResultBatch as cD, RunnerToolResultBatchTransform as cE, Session as cF, SessionDispatchResult as cG, SessionEntry as cH, SessionErrorMetadata as cI, SessionExtension as cJ, SessionForkOptions as cK, SessionMeta as cL, SessionStateSnapshot as cM, Span as cN, SpanData as cO, SpanError as cP, SpanImplOptions as cR, StartTraceOptions as cS, StateWriter as cT, StateWriterFs as cU, StateWriterOptions as cV, StopHookContext as cW, StopHookFn as cX, StopHookResult as cY, StopHookSpanData as cZ, SystemCap as c_, MemoryReviewTrigger as ca, MemoryScope as cb, MemorySourceAdapter as cc, MemoryVisibility as cd, MessageEntry as ce, ObserveCtx as cf, PersistedSessionState as cg, PresetDispatcher as ch, PresetTracingContext as ci, QualityInvariant as cj, ReadonlyMutationTracker as ck, ReadonlyRecorder as cl, ReasoningDepth as cm, RecentlyModifiedFile as cn, RequestTaskStopOptions as co, RequestTaskStopResult as cp, RunEvent as cq, RunOptions as cr, RunResult as cs, RunnableTool as ct, RunnerEvent as cv, RunnerLlmResult as cw, RunnerLlmReturn as cx, RunnerRecoveryTranscriptCarrier as cy, RunnerToolCall as cz, AdmissionVerdict as d, TerminalCtx as d0, ToolCallSpanData as d1, ToolCapability as d2, ToolPermission as d3, Trace as d4, TraceOptions as d5, TracerOptions as d7, UserInteraction as d8, WorkflowAgentBackend as d9, WorkflowProcessSource as dA, WorkflowProcessStatus as dB, WorkflowProcessSummaryStatus as dC, WorkflowProcessTokenUsage as dD, WorkflowProcessTracker as dE, WorkflowProcessTrackerOptions as dF, WorkflowRun as dG, WorkflowRunState as dH, WorkflowRunStatus as dI, WorkflowSpawnAgentInput as dJ, WorkflowSynthesis as dK, WorkflowSynthesizeInput as dL, WorkflowTaskHandle as dM, WorkflowTaskResult as dN, WorkflowTaskSnapshot as dO, WorkflowTaskStatus as dP, WorkflowTaskSummaryEventUpdate as dQ, WorkflowTaskSummaryKind as dR, WorkflowTaskSummaryUpdate as dS, WorkflowTaskUsage as dT, WorkflowTaskVerification as dU, WorkflowTaskVerificationResult as dV, WorkflowWaitOptions as dW, WorkflowApi as da, WorkflowApproval as db, WorkflowApprovalSummary as dc, WorkflowArtifactRef as dd, WorkflowBudget as de, WorkflowEvent as df, WorkflowEventCorrelation as dg, WorkflowEventType as di, WorkflowIsolation as dj, WorkflowLimits as dk, WorkflowLogEvent as dl, WorkflowMeta as dm, WorkflowModelHint as dn, WorkflowModule as dp, WorkflowParallelOptions as dq, WorkflowProcessArtifact as dr, WorkflowProcessCounts as ds, WorkflowProcessEvent as dt, WorkflowProcessItem as du, WorkflowProcessItemKind as dv, WorkflowProcessItemOrigin as dw, WorkflowProcessItemStatus as dx, WorkflowProcessProgress as dy, WorkflowProcessSnapshot as dz, AdmittedHandle as e, Agent as f, AgentArtifactPolicy as g, AgentArtifactPolicyDecision as h, AgentArtifactPolicyInput as i, AgentArtifactReference as j, AgentCapabilityDeclaration as k, AgentCapabilityRequirements as l, AgentContinuationInput as m, AgentCredentialBroker as n, AgentDispatchContext as o, AgentDispatchPolicy as p, AgentDispatchPolicyDecision as q, AgentDispatchPolicyInput as r, AgentDispatchabilitySnapshot as s, AgentDispatchabilityStatus as t, AgentEffectDeclaration as u, AgentExecutor as v, AgentExecutorEvent as w, AgentExecutorFactory as x, AgentExecutorFactoryContext as y, AgentExecutorPlane as z };
+export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, DEFAULT_SYSTEM_CAP as aV, InvariantSession as bi, MAX_TOOL_LOOP_ITERATIONS as c6, Runner as d0, Tracer as dE, WorkflowEventRecorder as dP, SpanImpl as dm, registerPresetDispatcher as e$, attachRunnerRecoveryTranscript as eA, buildAssistantMessageFromLlmResult as eB, buildSystemPrompt as eC, buildToolResultMessage as eD, createAgent as eE, createHandoff as eF, createInMemorySession as eG, createInvariantSessionForAgent as eH, createStateWriter as eI, createTrace as eJ, createWorkflowProcessTracker as eK, defaultTracer as eL, detectInstructionsInjection as eM, discoverInstances as eN, executeRunnerToolCall as eO, extractAssistantTextFromMessage as eP, getActiveUserInteraction as eQ, getAdmittedAgentBindings as eR, hashMemoryIdentityComponent as eS, isAskUserCustomInputAnswer as eT, isFinalWorkflowProcessStatus as eU, isRunnableTool as eV, isRunnerLlmResult as eW, matchesMemoryApplicability as eX, memoryApplicabilityFingerprint as eY, normalizeHostMetadata as eZ, readRunnerRecoveryTranscript as e_, _resetAdmittedAgentBindings as ex, _resetPresetDispatchers as ey, asSingleSelection as ez, runAdmissionAudit as f0, setActiveUserInteraction as f1, setAdmittedAgentBindings as f2 };
+export type { AgentFollowupResult as $, AgentDetail as B, AgentDispatchContext as C, AgentDispatchPolicy as D, AgentDispatchPolicyDecision as E, AgentDispatchPolicyInput as F, AgentDispatchabilitySnapshot as G, AgentDispatchabilityStatus as H, AgentEffectDeclaration as I, AgentEvent as J, AgentEventKind as K, AgentExecutionInput as L, AgentExecutionKind as M, AgentExecutionResult as N, AgentExecutor as O, AgentExecutorEvent as P, AgentExecutorFactory as Q, AgentExecutorFactoryContext as R, AgentExecutorPlane as S, AgentExecutorPlaneBackgroundErrorContext as T, AgentExecutorPlaneBackgroundErrorHandler as U, AgentExecutorPlaneBinding as V, AgentExecutorPlaneStore as W, AgentExecutorPreflightResult as X, AgentExecutorProtocol as Y, AgentExecutorTaskReference as Z, AgentExecutorTaskSnapshot as _, DispatchableAgentOrigin as a$, AgentForkTurns as a0, AgentInterruptScope as a1, AgentJsonObject as a2, AgentJsonValue as a3, AgentLimitReached as a4, AgentListEntry as a5, AgentMailboxMessage as a6, AgentManifest as a7, AgentMessage as a8, AgentMetadataValue as a9, AgentTreeSnapshot as aA, AgentTurn as aB, AgentTurnExecutor as aC, AgentTurnRef as aD, AgentTurnState as aE, AgentTurnSummary as aF, AskUserAnswer as aG, AskUserCustomInputAnswer as aH, AskUserMultiOptions as aI, AskUserQuestionItem as aJ, AskUserQuestionOptions as aK, AskUserSelectionAnswer as aL, CapabilitySupport as aM, CompactionAnchor as aN, CompactionConfig as aO, CompactionDetails as aP, CompactionResult as aQ, CompactionSpanData as aR, CompactionUpdate as aS, CreateAgentExecutorPlaneOptions as aT, CurrentTodoSummary as aU, Deliverable as aW, DiscoveredInstance as aX, DiscoveryOptions as aY, DispatchableAgentDescriptor as aZ, DispatchableAgentListing as a_, AgentMiddlewareDeclaration as aa, AgentMutationOptions as ab, AgentOutput as ac, AgentPreflightInput as ad, AgentPreflightResult as ae, AgentProgressItem as af, AgentProgressKind as ag, AgentProgressUpdate as ah, AgentReasoningProfile as ai, AgentRegistrationEnabledMutationOptions as aj, AgentRegistrationMutationOptions as ak, AgentRegistrationService as al, AgentSpanData as am, AgentSpawnInput as an, AgentTaskCancellation as ao, AgentTaskCorrelation as ap, AgentTaskEvent as aq, AgentTaskFilter as ar, AgentTaskProgress as as, AgentTaskRegistrationSnapshot as at, AgentTaskService as au, AgentTaskSnapshot as av, AgentTaskStartInput as aw, AgentTaskState as ax, AgentTaskUsage as ay, AgentTool as az, AdmissionAuditOptions as b, KodaXSessionUiToolCallStatus as b$, DispatchableAgentQuery as b0, EvidenceSpanData as b1, ExternalAgentEffectDeclaration as b2, ExternalAgentHealth as b3, ExternalAgentProtocol as b4, ExternalAgentRegistration as b5, ExternalAgentRegistrationSummary as b6, FanoutSpanData as b7, FileOperations as b8, GenerationSpanData as b9, KodaXMemoryOutcomeEvidence as bA, KodaXSessionArchiveMarkerEntry as bB, KodaXSessionArtifactLedgerEntry as bC, KodaXSessionBranchSummaryEntry as bD, KodaXSessionClientNoticeEntry as bE, KodaXSessionCompactionEntry as bF, KodaXSessionData as bG, KodaXSessionEntry as bH, KodaXSessionEntryBase as bI, KodaXSessionGoalEntry as bJ, KodaXSessionLabelEntry as bK, KodaXSessionLineage as bL, KodaXSessionMemoryOutcomeDigestEntry as bM, KodaXSessionMemoryReviewReceiptEntry as bN, KodaXSessionMessageEntry as bO, KodaXSessionMeta as bP, KodaXSessionNavigationOptions as bQ, KodaXSessionRewindMarkerEntry as bR, KodaXSessionRuntimeInfo as bS, KodaXSessionScope as bT, KodaXSessionStorage as bU, KodaXSessionTreeNode as bV, KodaXSessionUiHistoryItem as bW, KodaXSessionUiHistoryItemType as bX, KodaXSessionUiTextHistoryItem as bY, KodaXSessionUiTextHistoryItemType as bZ, KodaXSessionUiToolCall as b_, Guardrail as ba, GuardrailSpanData as bb, Handoff as bc, HandoffSpanData as bd, InMemorySessionOptions as be, InstanceDiscoveryFs as bf, InvariantId as bg, InvariantResult as bh, KodaXCompactMemoryProgress as bj, KodaXCompactMemorySeed as bk, KodaXExtensionSessionRecord as bl, KodaXExtensionSessionState as bm, KodaXExtensionStore as bn, KodaXExtensionStoreEntry as bo, KodaXFileInputArtifact as bp, KodaXGoalEventType as bq, KodaXGoalState as br, KodaXGoalStatus as bs, KodaXImageInputArtifact as bt, KodaXImageMediaType as bu, KodaXInputArtifact as bv, KodaXInputArtifactSource as bw, KodaXJsonValue as bx, KodaXMemoryInfluenceRef as by, KodaXMemoryOutcomeDigest as bz, AdmissionCtx as c, RunnableTool as c$, KodaXSessionUiToolGroupHistoryItem as c0, KodaXSessionWorkspaceKind as c1, KodaXVideoInputArtifact as c2, KodaXVideoMediaType as c3, LocalAgentTaskInput as c4, LocalAgentTaskUpdate as c5, ManifestPatch as c7, MemoryActionProposal as c8, MemoryApplicability as c9, MemoryRefKind as cA, MemoryRejectResult as cB, MemoryReviewCandidateRef as cC, MemoryReviewDraftAction as cD, MemoryReviewInput as cE, MemoryReviewModelInput as cF, MemoryReviewPersistenceDecision as cG, MemoryReviewPersistenceKind as cH, MemoryReviewPlan as cI, MemoryReviewRunner as cJ, MemoryReviewTrigger as cK, MemoryScope as cL, MemorySourceAdapter as cM, MemoryVisibility as cN, MessageEntry as cO, ObserveCtx as cP, PersistedSessionState as cQ, PresetDispatcher as cR, PresetTracingContext as cS, QualityInvariant as cT, ReadonlyMutationTracker as cU, ReadonlyRecorder as cV, ReasoningDepth as cW, RecentlyModifiedFile as cX, RunEvent as cY, RunOptions as cZ, RunResult as c_, MemoryApplyPreview as ca, MemoryApplyResult as cb, MemoryApproval as cc, MemoryAuthority as cd, MemoryAutoCuratorInput as ce, MemoryAutoCuratorResult as cf, MemoryBodySnapshot as cg, MemoryClaimKind as ch, MemoryContextIdentity as ci, MemoryController as cj, MemoryCuratorInput as ck, MemoryDecisionTraceReceipt as cl, MemoryEpisodeReviewResult as cm, MemoryEvent as cn, MemoryGovernanceFinding as co, MemoryGovernanceFindingKind as cp, MemoryGovernanceReport as cq, MemoryItemRef as cr, MemoryLifecycle as cs, MemoryLifecycleOperationResult as ct, MemoryPack as cu, MemoryPackHint as cv, MemoryPackInput as cw, MemoryPackTraceMetadata as cx, MemoryProposalAction as cy, MemoryRefFilter as cz, AdmissionVerdict as d, WorkflowOutcomeUsage as d$, RunnerEvent as d1, RunnerLlmResult as d2, RunnerLlmReturn as d3, RunnerRecoveryTranscriptCarrier as d4, RunnerToolCall as d5, RunnerToolContext as d6, RunnerToolObserver as d7, RunnerToolResult as d8, RunnerToolResultBatch as d9, ToolCapability as dA, ToolPermission as dB, Trace as dC, TraceOptions as dD, TracerOptions as dF, UserInteraction as dG, WorkflowAgentBackend as dH, WorkflowApi as dI, WorkflowApproval as dJ, WorkflowApprovalSummary as dK, WorkflowArtifactRef as dL, WorkflowBudget as dM, WorkflowEvent as dN, WorkflowEventCorrelation as dO, WorkflowEventType as dQ, WorkflowIsolation as dR, WorkflowLimits as dS, WorkflowLogEvent as dT, WorkflowMeta as dU, WorkflowModelHint as dV, WorkflowModule as dW, WorkflowOutcome as dX, WorkflowOutcomeError as dY, WorkflowOutcomeResult as dZ, WorkflowOutcomeStatus as d_, RunnerToolResultBatchTransform as da, Session as db, SessionDispatchResult as dc, SessionEntry as dd, SessionErrorMetadata as de, SessionExtension as df, SessionForkOptions as dg, SessionMeta as dh, SessionStateSnapshot as di, Span as dj, SpanData as dk, SpanError as dl, SpanImplOptions as dn, StartTraceOptions as dp, StateWriter as dq, StateWriterFs as dr, StateWriterOptions as ds, StopHookContext as dt, StopHookFn as du, StopHookResult as dv, StopHookSpanData as dw, SystemCap as dx, TerminalCtx as dy, ToolCallSpanData as dz, AdmittedHandle as e, WorkflowParallelOptions as e0, WorkflowProcessArtifact as e1, WorkflowProcessCounts as e2, WorkflowProcessEvent as e3, WorkflowProcessItem as e4, WorkflowProcessItemKind as e5, WorkflowProcessItemOrigin as e6, WorkflowProcessItemStatus as e7, WorkflowProcessProgress as e8, WorkflowProcessSnapshot as e9, WorkflowProcessSource as ea, WorkflowProcessStatus as eb, WorkflowProcessSummaryStatus as ec, WorkflowProcessTokenUsage as ed, WorkflowProcessTracker as ee, WorkflowProcessTrackerOptions as ef, WorkflowRun as eg, WorkflowRunState as eh, WorkflowRunStatus as ei, WorkflowSpawnAgentInput as ej, WorkflowSynthesis as ek, WorkflowSynthesizeInput as el, WorkflowTaskHandle as em, WorkflowTaskResult as en, WorkflowTaskSnapshot as eo, WorkflowTaskStatus as ep, WorkflowTaskSummaryEventUpdate as eq, WorkflowTaskSummaryKind as er, WorkflowTaskSummaryUpdate as es, WorkflowTaskUsage as et, WorkflowTaskVerification as eu, WorkflowTaskVerificationResult as ev, WorkflowWaitOptions as ew, Agent as f, AgentActor as g, AgentActorClient as h, AgentActorSnapshot as i, AgentActorState as j, AgentActorStore as k, AgentArtifactDescriptor as l, AgentArtifactPolicy as m, AgentArtifactPolicyDecision as n, AgentArtifactPolicyInput as o, AgentArtifactReference as p, AgentBudgetAdmission as q, AgentBudgetAdmissionInput as r, AgentBudgetExhausted as s, AgentBudgetPort as t, AgentCapabilities as u, AgentCapabilityDeclaration as v, AgentCapabilityRequirements as w, AgentContinuationInput as x, AgentCredentialBroker as y, AgentDataClassification as z };

package/dist/types-chunks/{types.d-CzsLFqmf.d.ts → types.d-EqQmHztg.d.ts}

@@ -1,8 +1,8 @@
 import { a9 as KodaXWireReasoningEffort, a1 as KodaXToolDefinition, a3 as KodaXToolResultContentItem, k as KodaXMessage } from './types.d-Cqaw71Ax.js';
 import { K as KodaXBaseProvider } from './base.d-Cz_rwpOi.js';
 import { C as CapabilityKind, a as CapabilityProvider } from './capability.d-K664nHOS.js';
-import { aZ as KodaXJsonValue, aN as KodaXExtensionSessionRecord, aP as KodaXExtensionStore } from './types.d-CRCaLt_s.js';
-import { aB as KodaXToolExecutionContext, bi as ToolSideEffect } from './bash-prefix-extractor.d-YoiZl5yt.js';
+import { bx as KodaXJsonValue, bl as KodaXExtensionSessionRecord, bn as KodaXExtensionStore } from './types.d-DH1mvdcl.js';
+import { aE as KodaXToolExecutionContext, bl as ToolSideEffect } from './bash-prefix-extractor.d-CHJO5y94.js';
 
 /**
  * KodaX Constructed-World types (FEATURE_087, v0.7.28).
@@ -360,9 +360,8 @@ interface RuntimeRemoteToolContract {
  * immediately) or queues the prompt to run after the tool resolves.
  *
  *   - `'cancel'` — long-running tools whose work the user is likely to want
- *     to abandon when they redirect (e.g., `bash` running a 30s script,
- *     `dispatch_child_task` synchronously awaiting a child, sleep-style
- *     tools). InkREPL submit handler aborts the round immediately.
+ *     to abandon when they redirect (e.g., `bash` running a 30s script or
+ *     sleep-style tools). InkREPL submit handler aborts the round immediately.
  *
  *   - `'wait'` (default) — atomic / fast tools (read, grep, glob, write,
  *     edit, …) where waiting for completion is cheaper than aborting and
@@ -390,7 +389,7 @@ interface LocalToolDefinition extends KodaXToolDefinition {
      *     'readonly'` tools.
      *   - `true`: explicitly permitted in plan mode even when sideEffect is
      *     not `'readonly'`. Reserve for tools whose effect is itself part of
-     *     the planning loop (`exit_plan_mode`, `task_stop`, `todo_update`,
+     *     the planning loop (`exit_plan_mode`, `interrupt_agent`, `todo_update`,
      *     `todo_create`, `ask_user_question`).
      *   - `false`: explicitly blocked in plan mode even when sideEffect is
      *     `'readonly'`. Rare — useful for read-only tools whose output would
@@ -452,7 +451,7 @@ interface LocalToolDefinition extends KodaXToolDefinition {
      *      Examples: semantic_lookup (refresh: true rebuilds index)
      *
      * KEEP IT SHORT: ≤ 100 chars typical. Variable-length user-provided fields
-     * (bash command, URL, dispatch_child_task objective) may legitimately
+     * (bash command, URL, `spawn_agent` objective) may legitimately
      * exceed this — the projection's job is to make the risk visible, not to
      * fit a fixed budget at the cost of hiding it.
      *
@@ -723,9 +722,9 @@ interface ExtensionTurnSettleHookContext {
  * the chain (matches `tool:before` semantics).
  *
  * Scope note: this hook fires on the AMA `runner-driven` path only
- * (main loop, B1 retry, V2 worker). SA-path child agents dispatched
- * via `dispatch_child_task` go through `runKodaX` and do NOT trigger
- * this hook — observe their lifecycle via `turn:settle` on the SA
+ * (main loop, B1 retry, V2 worker). Native child Actor turns go through
+ * `runKodaX` and do NOT trigger this hook — observe their lifecycle via
+ * `turn:settle` on the SA
  * path. Extensions wanting "every agent termination" semantics must
  * register both hooks.
  */