@kodax-ai/kodax 0.7.96 → 0.7.97-alpha.2

package/dist/types-chunks/types.d-o7t9dds4.d.ts

@@ -0,0 +1,1484 @@
+import { k as KodaXMessage, I as KodaXReasoningRequest, a2 as KodaXTokenUsage } from './types.d-BjOq57-z.js';
+import { a9 as KodaXCompactMemorySeed, ao as KodaXSessionArtifactLedgerEntry } from './review-inbox.d-BeaLRNHx.js';
+
+/**
+ * FEATURE_222 — user-interaction primitive (agent layer).
+ *
+ * "Ask the user a question" is needed at BOTH layers: the coding `ask_user_*`
+ * tools (LLM-initiated) AND the MCP elicitation reverse capability
+ * (server-initiated). The capability historically lived only in
+ * `@kodax-ai/coding`, but the MCP runtime lives one layer below in
+ * `@kodax-ai/agent` and cannot reach up to it. So the primitive is owned here,
+ * at the agent layer, and the host injects ONE implementation that both layers
+ * share — coding re-exports these types for backward compatibility.
+ *
+ * The agent layer is UI-less by design: these are the contract the host
+ * (REPL / ACP / SDK) fulfils with its real interaction surface. A headless host
+ * leaves them undefined and consumers degrade gracefully (cancel / decline).
+ */
+/** A single question item used in multi-question mode. */
+interface AskUserQuestionItem {
+    question: string;
+    header?: string;
+    options: Array<{
+        label: string;
+        description?: string;
+        value: string;
+    }>;
+    multiSelect?: boolean;
+    /**
+     * FEATURE_222 — only meaningful when `multiSelect` is true. The host should
+     * reject (re-prompt / show an error, do NOT resolve) a selection with fewer
+     * than `minSelections` items. Absent ⇒ no lower bound.
+     */
+    minSelections?: number;
+    /**
+     * FEATURE_222 — only meaningful when `multiSelect` is true. The host should
+     * reject a selection with more than `maxSelections` items. Absent ⇒ no upper
+     * bound. Lets a host render + validate "pick at most N" structurally instead
+     * of parsing it out of natural-language question text.
+     */
+    maxSelections?: number;
+    /** Runtime-validated option value selected if the interaction expires. */
+    default?: string;
+    /**
+     * Choice surfaces are open-ended by default: hosts SHOULD offer a synthetic
+     * custom-input option unless this is explicitly false.
+     */
+    allowCustomInput?: boolean;
+    customInputLabel?: string;
+    customInputPrompt?: string;
+    customInputDefault?: string;
+}
+/** Options for multi-question mode — multiple independent questions in one call. */
+interface AskUserMultiOptions {
+    questions: AskUserQuestionItem[];
+}
+/** Options for a single question (select or free-text input). */
+interface AskUserQuestionOptions {
+    question: string;
+    kind?: 'select' | 'input';
+    /** Required for kind="select", ignored for kind="input". */
+    options?: Array<{
+        label: string;
+        description?: string;
+        value: string;
+    }>;
+    multiSelect?: boolean;
+    /** FEATURE_222 — see {@link AskUserQuestionItem.minSelections}. */
+    minSelections?: number;
+    /** FEATURE_222 — see {@link AskUserQuestionItem.maxSelections}. */
+    maxSelections?: number;
+    /** Input text or a Runtime-validated option value selected on expiry. */
+    default?: string;
+    /**
+     * Choice surfaces are open-ended by default: hosts SHOULD offer a synthetic
+     * custom-input option unless this is explicitly false.
+     */
+    allowCustomInput?: boolean;
+    customInputLabel?: string;
+    customInputPrompt?: string;
+    customInputDefault?: string;
+}
+/** Host return value for a user-entered answer chosen through a select dialog's
+ *  synthetic "Other..." option. */
+interface AskUserCustomInputAnswer {
+    kind: 'customInput';
+    value: string;
+}
+type AskUserSelectionAnswer = string | AskUserCustomInputAnswer;
+type AskUserAnswer = AskUserSelectionAnswer | AskUserSelectionAnswer[];
+/**
+ * FEATURE_222 — reserved option value a host may append as a synthetic option
+ * (e.g. a "← Back" entry) in `askUserMulti`'s per-question flow to mean "return
+ * to the previous question" instead of answering the current one. Only
+ * meaningful for `questions[]` index > 0 (there is no previous before the
+ * first). The coding `ask_user_question` tool rejects this as a normal
+ * `option.value` supplied by the model, so a host may safely reuse it for its
+ * own back-navigation UI. A host that ignores this constant simply never offers
+ * back-navigation — the default multi-question flow is unaffected either way.
+ */
+declare const ASK_USER_BACK_SIGNAL = "__back__";
+/** Reserved synthetic option value for a host-provided custom input entry. */
+declare const ASK_USER_CUSTOM_INPUT_SIGNAL = "__custom_input__";
+declare function isAskUserCustomInputAnswer(value: unknown): value is AskUserCustomInputAnswer;
+/**
+ * FEATURE_222 — narrow an `askUser` result to a single string for the many
+ * callers that only ever ask single-select questions (they never set
+ * `multiSelect: true`, so the array branch is unreachable at runtime). Collapses
+ * an unexpected array to its first element so a mis-configured host degrades
+ * predictably instead of leaking `[object Array]` into a string comparison.
+ */
+declare function asSingleSelection(answer: AskUserAnswer): string;
+/** Lifecycle signal supplied by a bounded interaction owner. */
+interface UserInteractionPromptContext {
+    /** Aborted when the interaction expires or its owner settles it elsewhere. */
+    readonly signal: AbortSignal;
+}
+/**
+ * The host-provided user-interaction surface. Each method is optional — a
+ * headless host omits them and callers degrade gracefully. This is the single
+ * primitive shared by the coding `ask_user_*` tools and the agent's MCP
+ * elicitation reverse capability.
+ */
+interface UserInteraction {
+    /**
+     * Ask one question (select mode by default). Single-select resolves the
+     * chosen option value as a string. Multi-select resolves the selected values
+     * as an array. If the user chooses the host-provided custom-input option,
+     * return `{ kind: 'customInput', value }` in the single or array position.
+     * Plain string/string[] hosts remain valid for backward compatibility.
+     */
+    askUser?: (options: AskUserQuestionOptions, context?: UserInteractionPromptContext) => Promise<AskUserAnswer>;
+    /** Ask several independent questions sequentially. Resolves a per-question
+     *  value map using the same `AskUserAnswer` shape as `askUser`, or undefined
+     *  when the user cancels. */
+    askUserMulti?: (options: AskUserMultiOptions, context?: UserInteractionPromptContext) => Promise<Record<string, AskUserAnswer> | undefined>;
+    /** Ask for free-text input. Resolves the text, or undefined when cancelled. */
+    askUserInput?: (options: {
+        question: string;
+        default?: string;
+    }, context?: UserInteractionPromptContext) => Promise<string | undefined>;
+}
+/** Register the live user-interaction surface (host calls this when interactive). */
+declare function setActiveUserInteraction(interaction: UserInteraction | undefined): void;
+/** The live user-interaction surface, or undefined when none is active. */
+declare function getActiveUserInteraction(): UserInteraction | undefined;
+
+type KodaXImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+type KodaXVideoMediaType = 'video/mp4' | 'video/mpeg' | 'video/quicktime' | 'video/x-msvideo' | 'video/x-flv' | 'video/webm' | 'video/x-ms-wmv' | 'video/3gpp';
+type KodaXInputArtifactSource = 'user-inline' | 'clipboard' | 'drag-drop' | 'file-picker';
+interface KodaXImageInputArtifact {
+    readonly kind: 'image';
+    readonly path: string;
+    readonly mediaType?: KodaXImageMediaType;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface KodaXFileInputArtifact {
+    readonly kind: 'file';
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+interface KodaXVideoInputArtifact {
+    readonly kind: 'video';
+    readonly path: string;
+    readonly mediaType: KodaXVideoMediaType;
+    readonly name?: string;
+    readonly source?: KodaXInputArtifactSource;
+    readonly description?: string;
+}
+type KodaXInputArtifact = KodaXImageInputArtifact | KodaXFileInputArtifact | KodaXVideoInputArtifact;
+
+type LearnedCapabilityCarrier = 'skill' | 'extension' | 'workflow_handoff';
+type LearnedCapabilityLifecycle = 'opportunity' | 'drafting' | 'ready' | 'testing' | 'active_learned' | 'promoted_user' | 'quarantined' | 'archived' | 'rejected';
+type LearningEventKind = 'opportunity' | 'drafting' | 'ready' | 'testing' | 'activated' | 'promoted' | 'attention' | 'archived' | 'rejected';
+type LearningAction = 'review' | 'trust' | 'reject' | 'disable' | 'rollback' | 'archive' | 'restore' | 'promote';
+interface LearnedCapabilitySource {
+    readonly kind: 'learning_controller' | 'f224_proposal' | 'skill_learning_loop' | 'legacy_manual';
+    readonly proposalId?: string;
+}
+interface LearnedCapabilityRecordBase {
+    readonly capabilityId: string;
+    readonly displayName: string;
+    readonly slug: string;
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly lifecycle: LearnedCapabilityLifecycle;
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly source: LearnedCapabilitySource;
+    /** The control action that produced this revision, when it is not implied by lifecycle. */
+    readonly lastAction?: LearningAction;
+    readonly artifactPath?: string;
+    readonly previousGoodRevision?: number;
+    readonly previousLifecycle?: LearnedCapabilityLifecycle;
+    readonly diagnostics?: readonly string[];
+}
+interface LearnedCapabilityRecordV1 extends LearnedCapabilityRecordBase {
+    readonly schemaVersion: 1;
+}
+interface LearnedCapabilityScope {
+    readonly configHomeHash: string;
+    readonly tenantHash: string;
+    readonly projectHash: string;
+}
+interface LearnedCapabilityArtifact {
+    readonly kind: 'skill_markdown';
+    readonly relativePath: string;
+    readonly fingerprint: string;
+    readonly contentRevision: number;
+}
+interface LearnedCapabilityProvenance {
+    readonly jobId: string;
+    readonly inputHash: string;
+    readonly decisionId: string;
+    readonly actionId: string;
+}
+interface LearnedCapabilityCanaryBinding {
+    readonly bindingId: string;
+    readonly ownerSessionRef: string;
+    readonly expiresAt: string;
+}
+interface LearnedCapabilityCanaryInvocation {
+    readonly invocationId: string;
+    readonly bindingId: string;
+    /** Durable usage-ledger identity for recovery after the binding expires. */
+    readonly usageSessionHash?: string;
+    readonly artifactRevision?: number;
+    readonly artifactFingerprint?: string;
+    readonly status: 'pending' | 'verified_success' | 'credible_negative' | 'inconclusive';
+    readonly evidenceRefs: readonly string[];
+    readonly invokedAt: string;
+    readonly completedAt?: string;
+}
+interface LearnedCapabilityCanary {
+    readonly maxInvocations: 3;
+    readonly invocationCount: number;
+    readonly verifiedSuccesses: number;
+    readonly credibleNegatives: number;
+    readonly binding?: LearnedCapabilityCanaryBinding;
+    readonly invocations: readonly LearnedCapabilityCanaryInvocation[];
+}
+interface LearnedCapabilityRecordV2 extends LearnedCapabilityRecordBase {
+    readonly schemaVersion: 2;
+    readonly carrier: 'skill';
+    readonly scope: LearnedCapabilityScope;
+    readonly artifact: LearnedCapabilityArtifact;
+    readonly previousGoodArtifact?: LearnedCapabilityArtifact;
+    readonly provenance: LearnedCapabilityProvenance;
+    readonly canary: LearnedCapabilityCanary;
+}
+type LearnedCapabilityRecord = LearnedCapabilityRecordV1 | LearnedCapabilityRecordV2;
+interface LearningEvent {
+    readonly schemaVersion: 1;
+    readonly sequence: number;
+    readonly eventId: string;
+    readonly capabilityId: string;
+    readonly capabilityRevision: number;
+    readonly kind: LearningEventKind;
+    readonly lifecycle: LearnedCapabilityLifecycle;
+    readonly displayName: string;
+    readonly slug: string;
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly createdAt: string;
+}
+type LearningNotificationState = 'unread' | 'seen' | 'acknowledged' | 'snoozed';
+interface LearningClientEventState {
+    readonly state: LearningNotificationState;
+    readonly capabilityRevision: number;
+    readonly updatedAt: string;
+    readonly snoozedUntil?: string;
+}
+interface LearningClientRecord {
+    readonly schemaVersion: 1;
+    readonly clientIdentity: string;
+    readonly events: Readonly<Record<string, LearningClientEventState>>;
+}
+interface LearningSurfaceSnapshot {
+    readonly ready: number;
+    readonly newlyActive: number;
+    readonly attention: number;
+    readonly active: number;
+    readonly revision: number;
+}
+interface LearningQuery {
+    readonly search?: string;
+    readonly carrier?: LearnedCapabilityCarrier;
+    readonly lifecycle?: LearnedCapabilityLifecycle;
+    readonly limit?: number;
+    readonly cursor?: string;
+}
+interface LearningPage {
+    readonly items: readonly LearnedCapabilityRecord[];
+    readonly nextCursor?: string;
+    readonly revision: number;
+}
+interface LearningSubscribeOptions {
+    readonly afterRevision?: number;
+}
+interface LearningExplicitUserAuthority {
+    readonly authority: 'explicit_user';
+    readonly expectedRevision: number;
+    readonly expectedFingerprint?: string;
+}
+interface LearningActionDriver {
+    readonly carrier: LearnedCapabilityCarrier;
+    readonly actions: readonly LearningAction[];
+    execute(action: LearningAction, capability: LearnedCapabilityRecord): Promise<LearnedCapabilityRecord>;
+}
+type LearningCapabilityErrorCode = 'ambiguous_name' | 'action_failed' | 'capability_not_found' | 'invalid_record' | 'invalid_transition' | 'store_integrity_error' | 'unsupported_action';
+declare class LearningCapabilityError extends Error {
+    readonly code: LearningCapabilityErrorCode;
+    constructor(code: LearningCapabilityErrorCode, message: string);
+}
+declare function canTransitionLearnedCapability(from: LearnedCapabilityLifecycle, to: LearnedCapabilityLifecycle): boolean;
+declare function assertLearnedCapabilityTransition(from: LearnedCapabilityLifecycle, to: LearnedCapabilityLifecycle): void;
+declare function slugifyLearnedCapabilityName(displayName: string): string;
+declare function learningEventKindForLifecycle(lifecycle: LearnedCapabilityLifecycle): LearningEventKind;
+declare function learningEventIdFor(record: LearnedCapabilityRecord): string;
+
+/**
+ * ../../index.js Compaction Types
+ */
+
+interface CompactionConfig {
+    /** Independent of the main turn; defaults off, or to a low supported effort on always-on models. */
+    reasoning?: boolean | KodaXReasoningRequest;
+    /** @deprecated Automatic large compaction is always enabled. */
+    enabled: boolean;
+    /**
+     * Automatic large-compaction threshold percentage. Defaults to 75 and is
+     * normalized to the inclusive 15-90 range.
+     */
+    triggerPercent: number;
+    /**
+     * Optional absolute token threshold. Missing or zero is inactive; otherwise
+     * the smaller percentage/absolute/physical threshold wins.
+     */
+    triggerTokens?: number;
+    /**
+     * @deprecated V2 compaction no longer uses this option.
+     * FEATURE_272 derives protection from the effective trigger and covers the
+     * complete eligible prefix in one logical wave.
+     */
+    keepRecentPercent?: number;
+    /**
+     * @deprecated Large compaction protects 20% of its effective trigger.
+     * Retained only for source compatibility with v0.7.x callers.
+     */
+    protectionPercent?: number;
+    /**
+     * @deprecated FEATURE_272 replaces rolling summary passes with one complete
+     * eligible-prefix wave. Retained for source compatibility.
+     */
+    rollingSummaryPercent?: number;
+    /**
+     * Explicit legacy opt-in for destructive emergency pruning after semantic
+     * compaction cannot restore a physically valid request. Undefined keeps the
+     * fallback disabled.
+     */
+    pruningThresholdTokens?: number;
+    /**
+     * Legacy deterministic-pruning gap ratio. Only relevant when
+     * `pruningThresholdTokens` is explicitly configured.
+     */
+    pruningGapRatio?: number;
+    /** Optional override for the provider context window. */
+    contextWindow?: number;
+}
+interface CompactionDetails {
+    readFiles: string[];
+    modifiedFiles: string[];
+}
+interface CompactionAnchor {
+    summary: string;
+    tokensBefore: number;
+    tokensAfter: number;
+    entriesRemoved: number;
+    reason: string;
+    artifactLedgerId?: string;
+    details?: CompactionDetails;
+    memorySeed?: KodaXCompactMemorySeed;
+}
+interface CompactionUpdate {
+    /**
+     * Exact host-only snapshot used to reconcile lineage before durable commit.
+     * It is intentionally not part of the persisted CompactionEntry or provider
+     * context. Hosts may evict old message bodies only after saving this state.
+     */
+    preCompactionMessages?: readonly KodaXMessage[];
+    anchor?: CompactionAnchor;
+    artifactLedger?: KodaXSessionArtifactLedgerEntry[];
+    memorySeed?: KodaXCompactMemorySeed;
+    /**
+     * FEATURE_072: ledger-summary + file-content messages produced by
+     * `buildPostCompactAttachments` + `buildFileContentMessages`. Agent.ts
+     * passes these separately from the kept-tail messages so REPL-side
+     * `applySessionCompaction` can store them natively on the CompactionEntry
+     * rather than inlining them as loose `[Post-compact: ...]` system messages
+     * in lineage. Agent.ts keeps inlining them into its local flat `messages`
+     * via `injectPostCompactAttachments` (P4 belt-and-suspenders); the lineage
+     * is the persistence source of truth.
+     */
+    postCompactAttachments?: readonly KodaXMessage[];
+    /** Canonical metrics for one committed large-compaction transaction. */
+    report?: CompactionReport;
+}
+interface CompactionReport {
+    /** Physical summary calls, including map/reduce; never contains prompt or output text. */
+    readonly summaryRequests?: readonly CompactionRequestMetrics[];
+    /** Durable history commit only; excludes summary generation. */
+    readonly commitMs?: number;
+    readonly strategy: 'full_prefix' | 'map_reduce';
+    readonly triggerSource: 'percentage' | 'absolute' | 'physical_capacity';
+    readonly effectiveTriggerTokens: number;
+    readonly protectedBudgetTokens: number;
+    readonly fixedInputTokens: number;
+    readonly eligibleTokens: number;
+    readonly rawTailTokens: number;
+    readonly summaryTokens: number;
+    readonly queryLedgerTokens: number;
+}
+interface CompactionRequestMetrics {
+    readonly provider: string;
+    readonly model: string;
+    /** Requested summary policy; the provider may adapt it to its capabilities. */
+    readonly reasoning: boolean | KodaXReasoningRequest;
+    readonly prepareMs: number;
+    readonly credentialMs: number;
+    /** Includes retries and their waits. firstDeltaMs is an offset within this duration. */
+    readonly providerMs: number;
+    readonly firstDeltaMs?: number;
+    /** Retries reported by the provider adapter; excludes opaque upstream retries. */
+    readonly retryCount: number;
+    readonly retryWaitMs: number;
+    readonly usage?: KodaXTokenUsage;
+    readonly stopReason?: string;
+    readonly outcome: 'succeeded' | 'failed';
+}
+interface CompactionResult {
+    compacted: boolean;
+    messages: KodaXMessage[];
+    summary?: string;
+    tokensBefore: number;
+    tokensAfter: number;
+    entriesRemoved: number;
+    details?: CompactionDetails;
+    artifactLedger?: KodaXSessionArtifactLedgerEntry[];
+    anchor?: CompactionAnchor;
+    memorySeed?: KodaXCompactMemorySeed;
+    report?: CompactionReport;
+}
+interface FileOperations {
+    readFiles: string[];
+    modifiedFiles: string[];
+}
+
+/**
+ * FEATURE_217 (v0.7.49) — Workflow run-graph events.
+ *
+ * Append-only event stream for a workflow run. Each event carries a
+ * monotonic `seq` so ordering is stable and verifiable regardless of
+ * wall-clock (the durable writer in Phase D adds timestamps via an
+ * injected clock). The run graph models agent relationships as a
+ * thread/edge/event stream, not just a final summary blob.
+ */
+type WorkflowEventType = 'workflow_started' | 'phase_started' | 'phase_finished' | 'agent_spawned' | 'agent_message_sent' | 'agent_completed' | 'agent_unverified' | 'agent_failed' | 'agent_summary_updated' | 'agent_stopped' | 'agent_replayed' | 'workflow_log' | 'artifact_written' | 'synthesis_completed' | 'workflow_completed' | 'workflow_stopped' | 'workflow_failed';
+interface WorkflowEvent {
+    /** Monotonic sequence number — stable append ordering. */
+    readonly seq: number;
+    readonly type: WorkflowEventType;
+    /** Structured payload (agent name/id, phase name, error message, …). */
+    readonly data?: Record<string, unknown>;
+}
+/**
+ * Append-only event recorder. Assigns sequential `seq` and fans each
+ * event out to an optional sink (the durable JSONL writer / UI consumer
+ * subscribes here in Phase D).
+ */
+declare class WorkflowEventRecorder {
+    private readonly sink?;
+    private seq;
+    private readonly events;
+    constructor(sink?: ((event: WorkflowEvent) => void) | undefined);
+    /** Append an event, returning the materialized record. */
+    emit(type: WorkflowEventType, data?: Record<string, unknown>): WorkflowEvent;
+    /** Immutable snapshot of all events emitted so far. */
+    snapshot(): readonly WorkflowEvent[];
+}
+
+/**
+ * FEATURE_217 (v0.7.49) — Dynamic Workflow Harness Runtime: public types.
+ *
+ * Domain-neutral workflow orchestration surface. A workflow *script*
+ * coordinates (decompose / fan-out / loop / wait / stop / verify /
+ * synthesize); it never touches files or shell directly. The actual
+ * agent execution is delegated to an injected `WorkflowAgentBackend`
+ * (the coding layer provides the real one in Phase B; tests inject a
+ * fake). This keeps `@kodax-ai/agent` free of any `@kodax-ai/coding`
+ * dependency (ADR-021 layer independence).
+ */
+/** Lifecycle status of a single workflow-spawned agent. */
+type WorkflowTaskStatus = 'running' | 'completed' | 'completed_unverified' | 'failed' | 'stopped';
+/** Routing hint for which provider/model tier the child should use. */
+type WorkflowModelHint = 'fast' | 'balanced' | 'deep';
+/** Isolation policy for a spawned agent. `shared-cwd` is the default
+ *  (FEATURE_188); `worktree` is opt-in for high-risk parallel writes. */
+type WorkflowIsolation = 'shared-cwd' | 'worktree';
+/**
+ * Machine-checkable postconditions for a workflow child task. The agent
+ * package only defines the contract; concrete backends decide which evidence
+ * they can verify.
+ */
+interface WorkflowTaskVerification {
+    readonly enforcement?: 'hard' | 'warn';
+    readonly requiresMutation?: boolean;
+    readonly requiredChangedPaths?: readonly string[];
+    /** Read-tool paths that must be observed before accepting a review verdict. */
+    readonly requiredReadPaths?: readonly string[];
+    readonly minFinalTextChars?: number;
+    readonly rejectPreparatoryFinalText?: boolean;
+}
+interface WorkflowTaskVerificationResult {
+    readonly ok: boolean;
+    readonly enforcement?: 'hard' | 'warn';
+    readonly reasons: readonly string[];
+    readonly changedPaths?: readonly string[];
+    readonly mutationToolCalls?: readonly string[];
+    readonly mutationEvidence?: boolean;
+    readonly readPaths?: readonly string[];
+}
+interface WorkflowAgentTarget {
+    readonly agentId: string;
+    readonly expectedConfigurationRevision?: string;
+}
+interface WorkflowSpawnAgentInput {
+    /** Human-readable label for the agent — surfaces in events / UI. */
+    readonly name: string;
+    /**
+     * Optional progress-group tag (FEATURE_246 Part E). When set, this agent is
+     * grouped under a phase of that name in the progress display — the per-agent
+     * equivalent of wrapping a block in `wf.phase(name, fn)`, matching the harness
+     * `agent(..., { phase })`. The phase group is created on first use. Agents
+     * with no `phase` fall under the currently-active `wf.phase(...)` block (if any).
+     */
+    readonly phase?: string;
+    /** The task prompt handed to the child agent. */
+    readonly prompt: string;
+    /** Compact scope summary copied into the child briefing without retyping the diff. */
+    readonly scopeSummary?: string;
+    /** Binding constraints/interfaces the child cannot discover locally. */
+    readonly constraints?: readonly string[];
+    /** When true, the child runs with a read-only tool whitelist. */
+    readonly readOnly?: boolean;
+    /** Route to a registered specialist agent (FEATURE_191). */
+    readonly subagentType?: string;
+    /** Route through the shared dispatchable-agent catalog (FEATURE_258). */
+    readonly target?: WorkflowAgentTarget;
+    /**
+     * Per-agent model TIER (FEATURE_120 model_hint). The script expresses semantic
+     * intent — 'fast' (cheap), 'deep' (strong), 'balanced' (default) — NOT a
+     * concrete model name: the authoring model has no cognition of which
+     * providers/models a given operator has configured. The operator maps the
+     * tiers to concrete models via env (KODAX_FAST/DEEP_PROVIDER/MODEL); when a
+     * tier is unconfigured the child inherits the parent provider/model. 'fast'
+     * applies to read-only children
+     * only (write/codegen stays on the parent tier — a quality guard).
+     */
+    readonly modelHint?: WorkflowModelHint;
+    /** Isolation policy; defaults to `shared-cwd`. */
+    readonly isolation?: WorkflowIsolation;
+    /** Per-child reasoning effort hint (e.g. 'low' | 'medium' | 'high' | 'max').
+     *  The backend maps it onto the child's reasoning resolver; omit to inherit
+     *  the parent/default effort. Opaque string so the agent layer needs no
+     *  coding effort-enum dependency. */
+    readonly effort?: string;
+    /** Evidence refs (`task_id:<id>` etc.) seeded into the child context. */
+    readonly evidenceRefs?: readonly string[];
+    /** Optional machine-checkable postconditions for this child task. */
+    readonly verification?: WorkflowTaskVerification;
+    /**
+     * Optional JSON Schema (FEATURE_246 Part B). When set, the child is asked to
+     * end with a fenced JSON block matching the schema; the backend parses and
+     * validates it (with one bounded repair turn on a hard miss) and returns the
+     * parsed object on `WorkflowTaskResult.structured`. Orthogonal to
+     * `verification` (which checks side-effects, not return shape). Carried as an
+     * opaque value so the agent layer needs no JSON-Schema dependency.
+     */
+    readonly outputSchema?: unknown;
+    /** Register concise finalText for digest reuse; trusted host provenance is checked separately. */
+    readonly terseResult?: boolean;
+}
+/** Returned by `spawnAgent` — the child is in-flight, not yet complete. */
+interface WorkflowTaskHandle {
+    readonly taskId: string;
+    readonly name: string;
+}
+interface WorkflowTaskUsage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly cacheReadTokens?: number;
+}
+type WorkflowTaskSummaryKind = 'digest' | 'excerpt' | 'digest-failed' | 'pending';
+interface WorkflowTaskSummaryEventUpdate {
+    readonly summary?: string;
+    readonly summaryKind: WorkflowTaskSummaryKind;
+    readonly usage?: WorkflowTaskUsage;
+}
+/** Terminal result of a spawned agent (from `wait` / `runAgent`). */
+interface WorkflowTaskResult {
+    readonly taskId: string;
+    readonly name: string;
+    readonly status: WorkflowTaskStatus;
+    readonly finalText: string;
+    /** Schema-validated structured result (FEATURE_246 Part B), present when the
+     *  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. */
+    readonly digestFailed?: boolean;
+    /** True when a digest was scheduled asynchronously and may arrive via `agent_summary_updated`. */
+    readonly digestPending?: boolean;
+    /** Task postcondition check, when a backend evaluated one. */
+    readonly verification?: WorkflowTaskVerificationResult;
+    /** True when the child exhausted its iteration budget before completing. */
+    readonly limitReached?: boolean;
+    /** Best-known provider/model used by the child, for host correlation only. */
+    readonly provider?: string;
+    readonly model?: string;
+    /** Requested semantic tier and how the local runtime resolved it. */
+    readonly requestedTier?: WorkflowModelHint | 'inherited';
+    readonly tierOutcome?: 'applied' | 'balanced-parent' | 'fast-write-ineligible' | 'unconfigured' | 'shadowed-by-selector' | 'inherited';
+    readonly providerSource?: 'explicit' | 'specialist' | 'tier' | 'parent' | 'default';
+    readonly modelSource?: 'explicit' | 'specialist' | 'tier' | 'parent';
+    readonly initialProvider?: string;
+    readonly initialModel?: string;
+    readonly finalProvider?: string;
+    readonly finalModel?: string;
+    readonly fallbackReason?: string;
+    readonly resolvedEffort?: string;
+    readonly iterations?: number;
+    readonly durationMs?: number;
+    readonly digestUsage?: WorkflowTaskUsage;
+    readonly usage?: WorkflowTaskUsage;
+}
+/** Point-in-time snapshot of a (possibly still-running) agent. */
+interface WorkflowTaskSnapshot {
+    readonly taskId: string;
+    readonly name: string;
+    readonly status: WorkflowTaskStatus;
+    readonly lastText?: string;
+}
+interface WorkflowWaitOptions {
+    readonly timeoutMs?: number;
+}
+interface WorkflowParallelOptions {
+    /** In-flight cap for this parallel block; clamped by workflow
+     *  maxConcurrency. */
+    readonly concurrency?: number;
+}
+interface WorkflowSynthesizeInput {
+    readonly inputs: readonly unknown[] | string | Record<string, unknown>;
+    readonly rubric: string;
+}
+interface WorkflowSynthesis {
+    readonly text: string;
+}
+interface WorkflowArtifactRef {
+    readonly name: string;
+    readonly path?: string;
+}
+interface WorkflowLogEvent {
+    readonly message: string;
+    readonly data?: unknown;
+}
+/**
+ * Token budget accounting. The runtime hard-stops before launching a new
+ * agent once completed children have exhausted the configured budget.
+ */
+interface WorkflowBudget {
+    /** Configured token budget, or null when unbounded. */
+    readonly total: number | null;
+    /** Tokens accounted across completed agents so far. */
+    spent(): number;
+    /** `max(0, total - spent())`, or Infinity when unbounded. */
+    remaining(): number;
+}
+interface WorkflowLimits {
+    /** Total agents spawnable across the whole run lifetime. */
+    readonly maxAgents?: number;
+    /** Maximum simultaneously in-flight agents (via runAgent / parallel). */
+    readonly maxConcurrency?: number;
+    /** Token budget. New spawns stop once completed usage exhausts it. */
+    readonly tokenBudget?: number;
+}
+/**
+ * The surface a workflow script consumes. The script never gets raw
+ * fs/shell — all effects route through agent tools behind the backend.
+ */
+interface WorkflowApi {
+    readonly runId: string;
+    readonly args: unknown;
+    readonly budget: WorkflowBudget;
+    /** Group operations under a named phase (emits phase_started/finished). */
+    phase<T>(name: string, fn: () => Promise<T>): Promise<T>;
+    /** Start a child agent; returns immediately with a handle. */
+    spawnAgent(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskHandle>;
+    /** spawnAgent + wait convenience; returns the terminal result, or `null` if
+     *  the child ended failed/stopped (FEATURE_246 Part E lenient failure — the
+     *  harness `agent()` semantics, so scripts can `.filter(Boolean)` instead of
+     *  wrapping every call in try/catch). Abort and budget/agent-cap limits still
+     *  throw. */
+    runAgent(input: WorkflowSpawnAgentInput): Promise<WorkflowTaskResult | null>;
+    /** Await a spawned agent's terminal result. */
+    wait(taskId: string, opts?: WorkflowWaitOptions): Promise<WorkflowTaskResult>;
+    /** Snapshot a (possibly running) agent. */
+    snapshot(taskId: string): Promise<WorkflowTaskSnapshot>;
+    /** 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 through its Actor mailbox. */
+    send(taskId: string, content: string): Promise<void>;
+    /** Stop a running agent (graceful abort). */
+    stop(taskId: string, reason: string): Promise<void>;
+    /** Run lazy thunks concurrently under the concurrency gate. Thunks
+     *  MUST be `() => Promise<T>` (not already-started promises) so the
+     *  runtime can bound concurrency. A thunk that throws (or whose agent fails)
+     *  resolves to `null` in the result array — the call itself never rejects, so
+     *  `.filter(Boolean)` before use (FEATURE_246 Part E, harness parity). Abort
+     *  still tears down the whole run. */
+    parallel<T>(items: readonly (() => Promise<T>)[], opts?: WorkflowParallelOptions): Promise<(T | null)[]>;
+    /**
+     * Stream items through ordered stages with NO barrier between stages: an
+     * item advances to stage N+1 as soon as its own stage N resolves,
+     * independent of other items (wall-clock = slowest single chain, not
+     * sum-of-slowest-per-stage). Each stage receives `(prev, item, index)`
+     * where `prev` is the previous stage's result (the original item at
+     * stage 1). A stage that throws drops that item to `null` and skips its
+     * remaining stages; results preserve input order. Agent spawns inside
+     * stages stay bounded by the workflow `maxConcurrency` gate. Optional:
+     * the restricted-script bootstrap always provides it; SDK consumers get
+     * it from the runtime. */
+    pipeline?(items: readonly unknown[], ...stages: readonly ((prev: unknown, item: unknown, index: number) => unknown)[]): Promise<unknown[]>;
+    /** Synthesize across inputs. Runs as a gated agent through the runtime
+     *  (spawn → wait), so it counts toward maxAgents / concurrency / budget
+     *  and emits run-graph events — it is NOT a backend side-channel. */
+    synthesize(input: WorkflowSynthesizeInput): Promise<WorkflowSynthesis>;
+    /**
+     * Run another saved/built-in workflow inline as a sub-step (FEATURE_246 Part E,
+     * harness parity). Resolves the module by name via the host-injected resolver
+     * and runs it under THIS run's runtime — sharing the same concurrency cap,
+     * agent counter, token budget, and abort signal. **One level only**: calling
+     * `workflow(...)` from inside a nested workflow throws. Returns whatever the
+     * sub-workflow's `run` returns. Optional: present when a resolver is wired
+     * (the restricted-script bootstrap provides it; SDK consumers may omit). */
+    workflow?(name: string, args?: unknown): Promise<unknown>;
+    /** Persist a named artifact. */
+    artifact(name: string, value: unknown): Promise<WorkflowArtifactRef>;
+    /** Emit a free-text progress log event. */
+    log(event: WorkflowLogEvent): void;
+}
+/** Metadata a workflow declares (name, description, default caps). */
+interface WorkflowMeta {
+    readonly name: string;
+    readonly description: string;
+    /** Best-effort expected child-agent count for progress UI; not a hard cap. */
+    readonly plannedAgents?: number;
+    readonly maxAgents?: number;
+    readonly maxConcurrency?: number;
+    readonly tokenBudget?: number;
+    /** True when the workflow only ever spawns read-only agents (no file
+     *  writes) — surfaced in the approval prompt. */
+    readonly readOnly?: boolean;
+    /** Declared phase names, for the approval prompt preview. */
+    readonly phases?: readonly string[];
+}
+/** Summary shown to the user before a workflow's first run. */
+interface WorkflowApprovalSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly phases: readonly string[];
+    readonly plannedAgents?: number;
+    readonly maxAgents: number | null;
+    readonly maxConcurrency: number | null;
+    readonly tokenBudget: number | null;
+    /** Whether the workflow may write files (false for read-only workflows). */
+    readonly writesFiles: boolean;
+}
+/** Approval gate — returns true to proceed, false to cancel the run. */
+type WorkflowApproval = (summary: WorkflowApprovalSummary) => boolean | Promise<boolean>;
+/** A workflow's entry function: coordinates agents via the `WorkflowApi`. */
+type WorkflowRun<TArgs = unknown, TResult = unknown> = (wf: WorkflowApi, args: TArgs) => Promise<TResult>;
+/** A self-contained workflow: metadata + entry function. Built-in
+ *  workflows (Phase C) and saved `.kodax/workflows/*.ts` (Phase E) both
+ *  materialize to this shape. */
+interface WorkflowModule<TArgs = unknown, TResult = unknown> {
+    readonly meta: WorkflowMeta;
+    readonly run: WorkflowRun<TArgs, TResult>;
+}
+/** 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>;
+    stop(taskId: string, reason: string): Promise<void>;
+    /** Optional late summary stream for presentation-only async digests. */
+    subscribeTaskSummaryUpdates?(listener: (taskId: string, update: WorkflowTaskSummaryEventUpdate) => void): () => void;
+    /** Optional durable artifact writer (Phase D wires the run graph).
+     *  `wf.synthesize` is NOT a backend method — it runs as a gated agent
+     *  through `spawn`/`wait` so it counts toward the runtime's caps. */
+    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[];
+}
+
+type WorkflowProcessStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+type WorkflowProcessItemStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'skipped';
+type WorkflowProcessItemKind = 'phase' | 'agent' | 'step' | 'artifact';
+/**
+ * FEATURE_246 resume telemetry — how an agent item came to be in a resumed run.
+ * `ran` = executed live this run; `replayed-from-cache` = returned instantly from
+ * a prior run's content-addressed result cache (resumeFromRunId). Only populated
+ * on resumed runs; absent on a fresh run (treat absent as `ran`).
+ */
+type WorkflowProcessItemOrigin = 'ran' | 'replayed-from-cache';
+type WorkflowProcessSummaryStatus = 'pending' | 'result' | 'notice' | 'unavailable';
+type WorkflowProcessSource = 'command' | 'review' | 'sdk' | 'capsule' | 'extension' | 'automation';
+interface WorkflowProcessItem {
+    readonly id: string;
+    readonly title: string;
+    readonly kind: WorkflowProcessItemKind;
+    readonly status: WorkflowProcessItemStatus;
+    readonly phaseId?: string;
+    readonly parentId?: string;
+    readonly agentId?: string;
+    readonly childAgentId?: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly startedAt?: string;
+    readonly endedAt?: string;
+    readonly summary?: string;
+    readonly summaryStatus?: WorkflowProcessSummaryStatus;
+    readonly error?: string;
+    /** FEATURE_246 resume telemetry — see {@link WorkflowProcessItemOrigin}. */
+    readonly origin?: WorkflowProcessItemOrigin;
+}
+interface WorkflowEventCorrelation {
+    readonly workflowRunId: string;
+    readonly childAgentId?: string;
+    readonly phaseId?: string;
+    readonly itemId?: string;
+}
+interface WorkflowProcessCounts {
+    readonly pending: number;
+    readonly running: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly cancelled: number;
+    readonly skipped: number;
+}
+interface WorkflowProcessProgress {
+    readonly spawnedAgents: number;
+    readonly finishedAgents: number;
+    readonly activeAgents: number;
+    readonly failedAgents: number;
+    readonly stoppedAgents: number;
+    readonly agentCap?: number;
+    readonly plannedItems?: number;
+    /** FEATURE_246 resume telemetry — count of agents that replayed from a prior
+     *  run's cache (origin `replayed-from-cache`). Present only when > 0, so a
+     *  fresh run's progress is unchanged. */
+    readonly replayedAgents?: number;
+}
+interface WorkflowProcessTokenUsage {
+    readonly spent: number;
+    readonly total?: number;
+}
+interface WorkflowProcessArtifact {
+    readonly name: string;
+    readonly path?: string;
+    readonly description?: string;
+}
+interface WorkflowProcessSnapshot {
+    readonly runId: string;
+    readonly workflowName: string;
+    readonly displayName?: string;
+    readonly status: WorkflowProcessStatus;
+    readonly startedAt: string;
+    readonly updatedAt: string;
+    readonly elapsedMs?: number;
+    readonly goal?: string;
+    readonly source?: WorkflowProcessSource;
+    readonly savedWorkflowName?: string;
+    readonly sourceRunId?: string;
+    readonly sourceWorkflowName?: string;
+    readonly revisionOf?: string;
+    /** FEATURE_246 resume telemetry — the prior run this run resumed from
+     *  (content-addressed replay). Absent on a fresh (non-resumed) run. */
+    readonly resumedFromRunId?: string;
+    readonly hostMetadata?: Record<string, string>;
+    readonly activePhaseId?: string;
+    readonly activePhaseIndex?: number;
+    readonly phaseCount?: number;
+    readonly items: readonly WorkflowProcessItem[];
+    readonly counts: WorkflowProcessCounts;
+    readonly progress: WorkflowProcessProgress;
+    readonly tokens?: WorkflowProcessTokenUsage;
+    readonly latestMessage?: string;
+    readonly resultSummary?: string;
+    readonly error?: string;
+    readonly artifacts?: readonly WorkflowProcessArtifact[];
+}
+type WorkflowProcessEvent = {
+    readonly type: 'workflow_started';
+    readonly snapshot: WorkflowProcessSnapshot;
+} | {
+    readonly type: 'workflow_updated';
+    readonly snapshot: WorkflowProcessSnapshot;
+    readonly message?: string;
+} | {
+    readonly type: 'workflow_finished';
+    readonly snapshot: WorkflowProcessSnapshot;
+};
+interface WorkflowProcessTrackerOptions {
+    readonly runId: string;
+    readonly workflowName: string;
+    readonly displayName?: string;
+    readonly goal?: string;
+    readonly source?: WorkflowProcessSource;
+    readonly savedWorkflowName?: string;
+    readonly sourceRunId?: string;
+    readonly sourceWorkflowName?: string;
+    readonly revisionOf?: string;
+    /** FEATURE_246 resume telemetry — the prior run this run resumed from. */
+    readonly resumedFromRunId?: string;
+    readonly hostMetadata?: Record<string, string>;
+    readonly phases?: readonly string[];
+    readonly maxAgents?: number;
+    readonly plannedAgents?: number;
+    readonly tokenBudget?: number;
+    readonly resultSummary?: string;
+    readonly artifacts?: readonly WorkflowArtifactRef[];
+    readonly now?: () => string;
+}
+interface WorkflowTaskSummaryUpdate {
+    readonly summary?: string;
+    readonly summaryStatus: WorkflowProcessSummaryStatus;
+}
+interface WorkflowProcessTracker {
+    applyEvent(event: WorkflowEvent): WorkflowProcessEvent;
+    updateTaskSummary(taskId: string, update: WorkflowTaskSummaryUpdate): WorkflowProcessEvent | undefined;
+    setStatus(status: WorkflowProcessStatus, message?: string): WorkflowProcessEvent;
+    setResultSummary(resultSummary: string | undefined): WorkflowProcessEvent;
+    getSnapshot(): WorkflowProcessSnapshot;
+}
+declare function isFinalWorkflowProcessStatus(status: WorkflowProcessStatus): boolean;
+declare function normalizeHostMetadata(value: unknown): Record<string, string> | undefined;
+declare function createWorkflowProcessTracker(options: WorkflowProcessTrackerOptions): WorkflowProcessTracker;
+
+/**
+ * FEATURE_246 Part A0 (ADR-046) — neutral workflow run lifecycle manager.
+ *
+ * Domain-neutral run registry + lifecycle (pause / resume / stop), process-event
+ * tracking, and terminal settle — lifted out of `@kodax-ai/coding` so any agent
+ * (including non-coding SDK hosts) can host and manage workflow runs.
+ *
+ * It never knows HOW a run executes: the caller injects a `runFn` thunk that
+ * receives lifecycle hooks (`onEvent` / `signal` / `beforeSpawn`) and returns a
+ * caller-shaped outcome, plus a `classify` mapping that outcome to a neutral
+ * terminal status and an `onError` that synthesizes a failure outcome. The
+ * coding layer wires `runFn` to its `runWorkflowModule` / `runWorkflowFromOptions`
+ * (backend + run-graph + worktrees); SDK hosts wire their own. Dependency arrows
+ * therefore point only coding → agent — no cycle.
+ */
+
+type ManagedWorkflowStatus = 'running' | 'paused' | 'completed' | 'failed' | 'denied' | 'stopped';
+/** Provenance/display metadata for a run's process tracker. */
+type WorkflowProcessMetadata = Pick<WorkflowProcessTrackerOptions, 'displayName' | 'goal' | 'source' | 'savedWorkflowName' | 'sourceRunId' | 'sourceWorkflowName' | 'revisionOf' | 'resumedFromRunId' | 'hostMetadata'>;
+interface ManagedWorkflowSnapshot {
+    readonly stop?: {
+        readonly state: 'unknown' | 'confirmed';
+    };
+    readonly runId: string;
+    readonly workflow: string;
+    readonly status: ManagedWorkflowStatus;
+    readonly totalSpawned: number;
+    readonly eventCount: number;
+    readonly startedAt: number;
+    readonly endedAt?: number;
+    readonly error?: string;
+    readonly resultText?: string;
+}
+interface ManagedWorkflowRun<TOutcome = unknown> {
+    readonly runId: string;
+    readonly done: Promise<TOutcome>;
+    getSnapshot(): ManagedWorkflowSnapshot | undefined;
+    getProcessSnapshot(): WorkflowProcessSnapshot | undefined;
+}
+/** Lifecycle hooks the manager injects into the caller's `runFn`. */
+interface ManagedRunHooks {
+    /** Forward every workflow event so the manager can track spawn/progress. */
+    readonly onEvent: (event: WorkflowEvent) => void;
+    /** Abort signal owned by the manager (fires on stop()). */
+    readonly signal: AbortSignal;
+    /** Await before launching each agent so pause() can gate new spawns. */
+    readonly beforeSpawn: () => Promise<void>;
+}
+/** Neutral terminal classification of a caller-shaped outcome. */
+interface ManagedRunClassification {
+    readonly status: 'completed' | 'failed' | 'denied';
+    readonly error?: Error;
+    readonly resultText?: string;
+}
+interface StartManagedRunInput<TOutcome> {
+    readonly runId: string;
+    /** Display name (usually the workflow's `meta.name`). */
+    readonly workflow: string;
+    readonly phases?: readonly string[];
+    readonly maxAgents?: number;
+    readonly plannedAgents?: number;
+    readonly tokenBudget?: number;
+    readonly processMetadata?: WorkflowProcessMetadata;
+    readonly signal?: AbortSignal;
+    /** Executes the run with the manager's lifecycle hooks injected. */
+    readonly runFn: (hooks: ManagedRunHooks) => Promise<TOutcome>;
+    /** Map the caller's terminal outcome to a neutral status for the snapshot. */
+    readonly classify: (outcome: TOutcome) => ManagedRunClassification;
+    /** Synthesize a caller-shaped outcome when `runFn` throws. */
+    readonly onError: (error: unknown) => TOutcome;
+}
+interface WorkflowRunManager {
+    start<TOutcome>(input: StartManagedRunInput<TOutcome>): ManagedWorkflowRun<TOutcome>;
+    list(): readonly ManagedWorkflowSnapshot[];
+    get(runId: string): ManagedWorkflowSnapshot | undefined;
+    subscribeWorkflowProcess(listener: (event: WorkflowProcessEvent) => void): () => void;
+    getWorkflowProcessSnapshot(runId: string): WorkflowProcessSnapshot | undefined;
+    listWorkflowProcessSnapshots(options?: {
+        readonly activeOnly?: boolean;
+        readonly limit?: number;
+    }): readonly WorkflowProcessSnapshot[];
+    pause(runId: string): boolean;
+    resume(runId: string): boolean;
+    stop(runId: string, reason?: string): boolean;
+}
+declare function createWorkflowRunManager(deps?: {
+    readonly now?: () => number;
+}): WorkflowRunManager;
+declare function getDefaultWorkflowRunManager(): WorkflowRunManager;
+
+type DispatchableAgentOrigin = 'native' | 'constructed' | 'external';
+type AgentExecutorProtocol = 'native' | 'a2a' | 'mcp' | 'http';
+type ExternalAgentProtocol = Exclude<AgentExecutorProtocol, 'native'>;
+type CapabilitySupport = 'supported' | 'unsupported' | 'conditional';
+type AgentJsonValue = string | number | boolean | null | AgentJsonObject | readonly AgentJsonValue[];
+interface AgentJsonObject {
+    readonly [key: string]: AgentJsonValue;
+}
+interface AgentCapabilityDeclaration {
+    readonly streaming: CapabilitySupport;
+    readonly durableTasks: CapabilitySupport;
+    readonly inputRequired: CapabilitySupport;
+    readonly cancellation: CapabilitySupport;
+    readonly artifacts: CapabilitySupport;
+}
+interface AgentEffectDeclaration {
+    readonly remote: 'none' | 'read' | 'write' | 'unknown';
+    readonly workspace: 'none' | 'proposal' | 'direct';
+}
+interface ExternalAgentEffectDeclaration extends AgentEffectDeclaration {
+    readonly workspace: 'none' | 'proposal';
+}
+interface DispatchableAgentDescriptor {
+    readonly agentId: string;
+    readonly displayName: string;
+    readonly description?: string;
+    readonly origin: DispatchableAgentOrigin;
+    readonly protocol: AgentExecutorProtocol;
+    readonly configurationRevision: string;
+    readonly skills: readonly string[];
+    readonly inputModalities: readonly string[];
+    readonly outputModalities: readonly string[];
+    readonly capabilities: AgentCapabilityDeclaration;
+    readonly effects: AgentEffectDeclaration;
+}
+type AgentDispatchabilityStatus = 'dispatchable' | 'degraded' | 'busy' | 'unavailable';
+interface AgentDispatchabilitySnapshot {
+    readonly status: AgentDispatchabilityStatus;
+    readonly checkedAt: string;
+    readonly reasons: readonly string[];
+    readonly retryAfterMs?: number;
+}
+interface DispatchableAgentListing {
+    readonly descriptor: DispatchableAgentDescriptor;
+    readonly dispatchability: AgentDispatchabilitySnapshot;
+}
+interface AgentDispatchContext {
+    readonly actorId: string;
+    readonly projectId?: string;
+    readonly workflowId?: string;
+    readonly parentTaskId?: string;
+    readonly runId?: string;
+    readonly nodeId?: string;
+    readonly dataClassifications?: readonly string[];
+    readonly budget?: number;
+}
+interface AgentCapabilityRequirements {
+    readonly streaming?: boolean;
+    readonly durableTasks?: boolean;
+    readonly inputRequired?: boolean;
+    readonly cancellation?: boolean;
+    readonly artifacts?: boolean;
+}
+interface DispatchableAgentQuery extends AgentDispatchContext {
+    readonly requiredSkills?: readonly string[];
+    readonly requiredCapabilities?: AgentCapabilityRequirements;
+    readonly readOnly?: boolean;
+}
+interface ExternalAgentHealth {
+    readonly status: 'healthy' | 'degraded' | 'unhealthy';
+    readonly checkedAt: string;
+    readonly retryAfterMs?: number;
+    readonly diagnostic?: string;
+}
+interface ExternalAgentRegistration {
+    readonly agentId: string;
+    readonly displayName: string;
+    readonly description?: string;
+    readonly managementOwner?: string;
+    readonly enabled: boolean;
+    readonly executorId: string;
+    readonly protocol: ExternalAgentProtocol;
+    /**
+     * Stable content identity for this execution route. Producers must issue a
+     * new value whenever immutable execution content changes. The same immutable
+     * content may reuse its stable revision after removal or Runtime restart;
+     * different content must never reuse a revision.
+     */
+    readonly configurationRevision: string;
+    readonly endpointIdentityHash: string;
+    readonly credentialRef?: string;
+    /** Public, JSON-safe executor configuration. Secrets must remain references. */
+    readonly executorConfig?: AgentJsonObject;
+    readonly skills?: readonly string[];
+    readonly inputModalities?: readonly string[];
+    readonly outputModalities?: readonly string[];
+    readonly capabilities: AgentCapabilityDeclaration;
+    readonly effects: ExternalAgentEffectDeclaration;
+    readonly health?: ExternalAgentHealth;
+    readonly maxConcurrency?: number;
+    readonly minimumBudget?: number;
+    readonly allowedDataClassifications?: readonly string[];
+}
+interface ExternalAgentRegistrationSummary {
+    readonly agentId: string;
+    readonly displayName: string;
+    readonly description?: string;
+    readonly managementOwner?: string;
+    readonly enabled: boolean;
+    readonly executorId: string;
+    readonly protocol: ExternalAgentProtocol;
+    readonly configurationRevision: string;
+    readonly endpointIdentityHash: string;
+    readonly credentialConfigured: boolean;
+    readonly capabilities: AgentCapabilityDeclaration;
+    readonly effects: ExternalAgentEffectDeclaration;
+    readonly health?: ExternalAgentHealth;
+    readonly diagnostics: readonly string[];
+}
+interface AgentDispatchPolicyInput {
+    readonly registration: ExternalAgentRegistration;
+    readonly query: DispatchableAgentQuery;
+}
+interface AgentDispatchPolicyDecision {
+    readonly allowed: boolean;
+    readonly reasons?: readonly string[];
+}
+type AgentDispatchPolicy = (input: AgentDispatchPolicyInput) => AgentDispatchPolicyDecision | Promise<AgentDispatchPolicyDecision>;
+interface AgentCredentialBroker {
+    isAvailable?(credentialRef: string): boolean | Promise<boolean>;
+    withCredential<T>(credentialRef: string, use: (credential: string) => Promise<T>): Promise<T>;
+}
+interface AgentArtifactReference {
+    readonly name: string;
+    readonly mimeType?: string;
+    readonly size?: number;
+    readonly hash?: string;
+    readonly uri?: string;
+    readonly provenance?: string;
+    readonly producingAgentId?: string;
+    readonly remoteTaskId?: string;
+}
+interface AgentArtifactPolicyInput {
+    readonly registration: ExternalAgentRegistration;
+    readonly artifact: AgentArtifactReference;
+}
+interface AgentArtifactPolicyDecision {
+    readonly allowed: boolean;
+    readonly reason?: string;
+}
+type AgentArtifactPolicy = (input: AgentArtifactPolicyInput) => AgentArtifactPolicyDecision | Promise<AgentArtifactPolicyDecision>;
+interface AgentTaskUsage {
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly cost?: number;
+    readonly currency?: string;
+}
+type AgentTaskState = 'submitted' | 'working' | 'input-required' | 'auth-required' | 'completed' | 'failed' | 'canceled' | 'rejected' | 'unknown';
+type AgentTaskCancellation = 'none' | 'requested' | 'confirmed' | 'unsupported' | 'failed' | 'unknown';
+interface AgentTaskProgress {
+    readonly message?: string;
+    readonly percent?: number;
+}
+interface AgentTaskCorrelation {
+    readonly parentTaskId?: string;
+    readonly workflowId?: string;
+    readonly runId?: string;
+    readonly nodeId?: string;
+}
+interface AgentTaskRegistrationSnapshot {
+    readonly agentId: string;
+    readonly origin: DispatchableAgentOrigin;
+    readonly executorId: string;
+    readonly protocol: AgentExecutorProtocol;
+    readonly configurationRevision: string;
+    readonly endpointIdentityHash?: string;
+    readonly capabilities: AgentCapabilityDeclaration;
+    readonly effects: AgentEffectDeclaration;
+}
+interface AgentExecutorTaskReference {
+    readonly idempotencyKey: string;
+    readonly remoteTaskId?: string;
+    readonly metadata?: AgentJsonObject;
+}
+interface AgentTaskSnapshot extends AgentTaskCorrelation {
+    readonly taskId: string;
+    readonly route: 'local' | 'external';
+    readonly agentId: string;
+    readonly objective: string;
+    readonly state: AgentTaskState;
+    readonly cancellation: AgentTaskCancellation;
+    readonly registration: AgentTaskRegistrationSnapshot;
+    readonly idempotencyKey: string;
+    readonly dispatchAttempt: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly remoteTaskId?: string;
+    readonly executorReference?: AgentExecutorTaskReference;
+    readonly progress?: AgentTaskProgress;
+    readonly output?: string;
+    readonly error?: string;
+    readonly cancellationError?: string;
+    readonly artifacts?: readonly AgentArtifactReference[];
+    readonly usage?: AgentTaskUsage;
+}
+interface AgentExecutorTaskSnapshot {
+    readonly state: AgentTaskState;
+    readonly progress?: AgentTaskProgress;
+    readonly output?: string;
+    readonly error?: string;
+    readonly artifacts?: readonly AgentArtifactReference[];
+    readonly usage?: AgentTaskUsage;
+}
+interface AgentTaskStartInput {
+    readonly taskId?: string;
+    readonly agentId: string;
+    readonly objective: string;
+    readonly context: AgentDispatchContext;
+    readonly readOnly?: boolean;
+    readonly requiredSkills?: readonly string[];
+    readonly requiredCapabilities?: AgentCapabilityRequirements;
+    readonly expectedConfigurationRevision?: string;
+    readonly idempotencyKey?: string;
+    readonly input?: string;
+}
+interface AgentContinuationInput {
+    readonly content: string;
+}
+interface AgentExecutorEvent {
+    readonly state?: AgentTaskState;
+    readonly progress?: AgentTaskProgress;
+    readonly output?: string;
+    readonly error?: string;
+    readonly artifacts?: readonly AgentArtifactReference[];
+    readonly usage?: AgentTaskUsage;
+}
+interface AgentTaskEvent extends AgentExecutorEvent {
+    readonly taskId: string;
+    readonly seq: number;
+    readonly timestamp: string;
+    readonly type: 'submitted' | 'state' | 'progress' | 'output' | 'artifact' | 'usage' | 'error' | 'cancellation';
+    readonly cancellation?: AgentTaskCancellation;
+}
+interface AgentExecutorPreflightResult {
+    readonly ok: boolean;
+    readonly reasons?: readonly string[];
+}
+interface AgentExecutor {
+    preflight?(input: AgentTaskStartInput): Promise<AgentExecutorPreflightResult>;
+    start(input: AgentTaskStartInput, signal?: AbortSignal): Promise<AgentExecutorTaskReference>;
+    events(reference: AgentExecutorTaskReference): AsyncIterable<AgentExecutorEvent>;
+    get(reference: AgentExecutorTaskReference): Promise<AgentExecutorTaskSnapshot>;
+    sendInput(reference: AgentExecutorTaskReference, input: AgentContinuationInput): Promise<void>;
+    cancel(reference: AgentExecutorTaskReference, reason?: string): Promise<AgentExecutorTaskSnapshot>;
+    reconcile(reference: AgentExecutorTaskReference): Promise<AgentExecutorTaskSnapshot>;
+    dispose(): Promise<void>;
+}
+interface AgentExecutorFactoryContext {
+    withCredential<T>(credentialRef: string, use: (credential: string) => Promise<T>): Promise<T>;
+    authorizeArtifact(artifact: AgentArtifactReference): Promise<void>;
+}
+interface AgentExecutorFactory {
+    readonly executorId: string;
+    readonly protocol: ExternalAgentProtocol;
+    create(registration: ExternalAgentRegistration, context: AgentExecutorFactoryContext): Promise<AgentExecutor>;
+}
+interface AgentPreflightInput {
+    readonly agentId: string;
+    readonly query: DispatchableAgentQuery;
+    readonly expectedConfigurationRevision?: string;
+}
+interface AgentPreflightResult {
+    readonly ok: boolean;
+    readonly descriptor?: DispatchableAgentDescriptor;
+    readonly dispatchability: AgentDispatchabilitySnapshot;
+    readonly reasons: readonly string[];
+}
+interface AgentTaskFilter {
+    readonly agentId?: string;
+    readonly parentTaskId?: string;
+    readonly workflowId?: string;
+    readonly runId?: string;
+    readonly state?: AgentTaskState | readonly AgentTaskState[];
+}
+interface LocalAgentTaskInput extends AgentTaskCorrelation {
+    readonly taskId: string;
+    readonly agentId: string;
+    readonly objective: string;
+    readonly configurationRevision: string;
+    readonly origin?: 'native' | 'constructed';
+}
+interface LocalAgentTaskUpdate {
+    readonly state?: AgentTaskState;
+    readonly progress?: AgentTaskProgress;
+    readonly output?: string;
+    readonly error?: string;
+    readonly artifacts?: readonly AgentArtifactReference[];
+    readonly usage?: AgentTaskUsage;
+}
+interface AgentExecutorPlaneStore {
+    loadRegistrations(): Promise<readonly ExternalAgentRegistration[]>;
+    saveRegistrations(registrations: readonly ExternalAgentRegistration[]): Promise<void>;
+    /**
+     * Optional compatibility extension for durable executor recovery across a
+     * registration update/removal. Built-in stores implement both hooks. A
+     * custom store that omits them can only recover through a still-current
+     * registration with the same revision; otherwise recovery fails closed.
+     * Implement both hooks or neither. The plane is the single writer and
+     * serializes whole-map replacements. Credential fields in snapshots are
+     * references only; `executorConfig` must likewise contain public data or secret
+     * references, never secret material. A store must never resolve or persist a
+     * referenced secret value.
+     */
+    loadTaskRegistrationSnapshots?(): Promise<readonly ExternalAgentRegistration[]>;
+    saveTaskRegistrationSnapshots?(registrations: readonly ExternalAgentRegistration[]): Promise<void>;
+    loadTasks(): Promise<readonly AgentTaskSnapshot[]>;
+    saveTask(task: AgentTaskSnapshot): Promise<void>;
+    loadEvents(taskId: string): Promise<readonly AgentTaskEvent[]>;
+    appendEvent(event: AgentTaskEvent): Promise<void>;
+}
+interface AgentRegistrationMutationOptions {
+    /** `null` means that no registration may exist; `undefined` disables CAS. */
+    readonly expectedConfigurationRevision?: string | null;
+    /** `null` means that no manager may own the registration; `undefined` disables owner CAS. */
+    readonly expectedManagementOwner?: string | null;
+}
+interface AgentRegistrationEnabledMutationOptions extends AgentRegistrationMutationOptions {
+    /** Atomically claims an unowned registration; a different existing owner is rejected. */
+    readonly claimOwner?: string;
+}
+interface AgentRegistrationService {
+    list(): Promise<readonly ExternalAgentRegistrationSummary[]>;
+    upsert(input: ExternalAgentRegistration, options?: AgentRegistrationMutationOptions): Promise<ExternalAgentRegistrationSummary>;
+    setEnabled(agentId: string, enabled: boolean, options?: AgentRegistrationEnabledMutationOptions): Promise<ExternalAgentRegistrationSummary | undefined>;
+    remove(agentId: string, options?: AgentRegistrationMutationOptions): Promise<boolean>;
+}
+interface AgentTaskService {
+    start(input: AgentTaskStartInput, signal?: AbortSignal): Promise<AgentTaskSnapshot>;
+    list(filter?: AgentTaskFilter): Promise<readonly AgentTaskSnapshot[]>;
+    get(taskId: string): Promise<AgentTaskSnapshot>;
+    events(taskId: string, cursor?: number): Promise<readonly AgentTaskEvent[]>;
+    wait(taskId: string, timeoutMs?: number): Promise<AgentTaskSnapshot>;
+    sendInput(taskId: string, input: AgentContinuationInput): Promise<AgentTaskSnapshot>;
+    cancel(taskId: string, reason?: string): Promise<AgentTaskSnapshot>;
+    reconcile(taskId: string): Promise<AgentTaskSnapshot>;
+    recordLocal(input: LocalAgentTaskInput): Promise<AgentTaskSnapshot>;
+    updateLocal(taskId: string, update: LocalAgentTaskUpdate): Promise<AgentTaskSnapshot>;
+}
+interface AgentExecutorPlaneBinding {
+    readonly plane: AgentExecutorPlane;
+    readonly context: AgentDispatchContext;
+}
+interface AgentExecutorPlane {
+    readonly registrations: AgentRegistrationService;
+    readonly tasks: AgentTaskService;
+    listDispatchable(query: DispatchableAgentQuery, localAgents?: readonly DispatchableAgentDescriptor[]): Promise<readonly DispatchableAgentListing[]>;
+    describe(agentId: string, query: DispatchableAgentQuery, localAgents?: readonly DispatchableAgentDescriptor[]): Promise<DispatchableAgentListing | undefined>;
+    preflight(input: AgentPreflightInput, localAgents?: readonly DispatchableAgentDescriptor[]): Promise<AgentPreflightResult>;
+    close(): Promise<void>;
+}
+interface AgentExecutorPlaneBackgroundErrorContext {
+    readonly operation: 'event-pump-recovery' | 'task-admission-event' | 'executor-dispose';
+    readonly taskId?: string;
+    readonly agentId?: string;
+    readonly configurationRevision?: string;
+}
+type AgentExecutorPlaneBackgroundErrorHandler = (error: Error, context: AgentExecutorPlaneBackgroundErrorContext) => void | Promise<void>;
+interface CreateAgentExecutorPlaneOptions {
+    readonly factories: readonly AgentExecutorFactory[];
+    readonly policy: AgentDispatchPolicy;
+    readonly credentialBroker?: AgentCredentialBroker;
+    readonly artifactPolicy?: AgentArtifactPolicy;
+    /** Receives failures from detached event handling and best-effort resource cleanup. */
+    readonly onBackgroundError?: AgentExecutorPlaneBackgroundErrorHandler;
+    readonly store?: AgentExecutorPlaneStore;
+    readonly now?: () => Date;
+    readonly createTaskId?: () => string;
+    readonly createIdempotencyKey?: () => string;
+    /** Overall bound for draining admitted work and disposing executors during close. */
+    readonly closeTimeoutMs?: number;
+}
+
+export { ASK_USER_BACK_SIGNAL as A, ASK_USER_CUSTOM_INPUT_SIGNAL as a, LearningCapabilityError as aE, learningEventIdFor as b$, WorkflowEventRecorder as b6, asSingleSelection as bS, assertLearnedCapabilityTransition as bT, canTransitionLearnedCapability as bU, createWorkflowProcessTracker as bV, createWorkflowRunManager as bW, getActiveUserInteraction as bX, getDefaultWorkflowRunManager as bY, isAskUserCustomInputAnswer as bZ, isFinalWorkflowProcessStatus as b_, learningEventKindForLifecycle as c0, normalizeHostMetadata as c1, setActiveUserInteraction as c2, slugifyLearnedCapabilityName as c3 };
+export type { AskUserSelectionAnswer as $, AgentExecutorProtocol as B, AgentExecutorTaskReference as C, AgentExecutorTaskSnapshot as D, AgentJsonObject as E, AgentJsonValue as F, AgentPreflightInput as G, AgentPreflightResult as H, AgentRegistrationEnabledMutationOptions as I, AgentRegistrationMutationOptions as J, AgentRegistrationService as K, AgentTaskCancellation as L, AgentTaskCorrelation as M, AgentTaskEvent as N, AgentTaskFilter as O, AgentTaskProgress as P, AgentTaskRegistrationSnapshot as Q, AgentTaskService as R, AgentTaskSnapshot as S, AgentTaskStartInput as T, AgentTaskState as U, AgentTaskUsage as V, AskUserAnswer as W, AskUserCustomInputAnswer as X, AskUserMultiOptions as Y, AskUserQuestionItem as Z, AskUserQuestionOptions as _, WorkflowApi as a$, CapabilitySupport as a0, CompactionAnchor as a1, CompactionConfig as a2, CompactionDetails as a3, CompactionReport as a4, CompactionRequestMetrics as a5, CompactionResult as a6, CompactionUpdate as a7, CreateAgentExecutorPlaneOptions as a8, DispatchableAgentDescriptor as a9, LearnedCapabilityScope as aA, LearnedCapabilitySource as aB, LearningAction as aC, LearningActionDriver as aD, LearningCapabilityErrorCode as aF, LearningClientEventState as aG, LearningClientRecord as aH, LearningEvent as aI, LearningEventKind as aJ, LearningExplicitUserAuthority as aK, LearningNotificationState as aL, LearningPage as aM, LearningQuery as aN, LearningSubscribeOptions as aO, LearningSurfaceSnapshot as aP, LocalAgentTaskInput as aQ, LocalAgentTaskUpdate as aR, ManagedRunClassification as aS, ManagedRunHooks as aT, ManagedWorkflowRun as aU, ManagedWorkflowSnapshot as aV, ManagedWorkflowStatus as aW, StartManagedRunInput as aX, UserInteraction as aY, UserInteractionPromptContext as aZ, WorkflowAgentBackend as a_, DispatchableAgentListing as aa, DispatchableAgentOrigin as ab, DispatchableAgentQuery as ac, ExternalAgentEffectDeclaration as ad, ExternalAgentHealth as ae, ExternalAgentProtocol as af, ExternalAgentRegistration as ag, ExternalAgentRegistrationSummary as ah, FileOperations as ai, KodaXFileInputArtifact as aj, KodaXImageInputArtifact as ak, KodaXImageMediaType as al, KodaXInputArtifact as am, KodaXInputArtifactSource as an, KodaXVideoInputArtifact as ao, KodaXVideoMediaType as ap, LearnedCapabilityArtifact as aq, LearnedCapabilityCanary as ar, LearnedCapabilityCanaryBinding as as, LearnedCapabilityCanaryInvocation as at, LearnedCapabilityCarrier as au, LearnedCapabilityLifecycle as av, LearnedCapabilityProvenance as aw, LearnedCapabilityRecord as ax, LearnedCapabilityRecordV1 as ay, LearnedCapabilityRecordV2 as az, AgentArtifactPolicy as b, WorkflowApproval as b0, WorkflowApprovalSummary as b1, WorkflowArtifactRef as b2, WorkflowBudget as b3, WorkflowEvent as b4, WorkflowEventCorrelation as b5, WorkflowEventType as b7, WorkflowIsolation as b8, WorkflowLimits as b9, WorkflowRun as bA, WorkflowRunManager as bB, WorkflowRunState as bC, WorkflowRunStatus as bD, WorkflowSpawnAgentInput as bE, WorkflowSynthesis as bF, WorkflowSynthesizeInput as bG, WorkflowTaskHandle as bH, WorkflowTaskResult as bI, WorkflowTaskSnapshot as bJ, WorkflowTaskStatus as bK, WorkflowTaskSummaryEventUpdate as bL, WorkflowTaskSummaryKind as bM, WorkflowTaskSummaryUpdate as bN, WorkflowTaskUsage as bO, WorkflowTaskVerification as bP, WorkflowTaskVerificationResult as bQ, WorkflowWaitOptions as bR, WorkflowLogEvent as ba, WorkflowMeta as bb, WorkflowModelHint as bc, WorkflowModule as bd, WorkflowOutcome as be, WorkflowOutcomeError as bf, WorkflowOutcomeResult as bg, WorkflowOutcomeStatus as bh, WorkflowOutcomeUsage as bi, WorkflowParallelOptions as bj, WorkflowProcessArtifact as bk, WorkflowProcessCounts as bl, WorkflowProcessEvent as bm, WorkflowProcessItem as bn, WorkflowProcessItemKind as bo, WorkflowProcessItemOrigin as bp, WorkflowProcessItemStatus as bq, WorkflowProcessMetadata as br, WorkflowProcessProgress as bs, WorkflowProcessSnapshot as bt, WorkflowProcessSource as bu, WorkflowProcessStatus as bv, WorkflowProcessSummaryStatus as bw, WorkflowProcessTokenUsage as bx, WorkflowProcessTracker as by, WorkflowProcessTrackerOptions as bz, AgentArtifactPolicyDecision as c, AgentArtifactPolicyInput as d, AgentArtifactReference as e, AgentCapabilityDeclaration as f, AgentCapabilityRequirements as g, AgentContinuationInput as h, AgentCredentialBroker as i, AgentDispatchContext as j, AgentDispatchPolicy as k, AgentDispatchPolicyDecision as l, AgentDispatchPolicyInput as m, AgentDispatchabilitySnapshot as n, AgentDispatchabilityStatus as o, AgentEffectDeclaration as p, AgentExecutor as q, AgentExecutorEvent as r, AgentExecutorFactory as s, AgentExecutorFactoryContext as t, AgentExecutorPlane as u, AgentExecutorPlaneBackgroundErrorContext as v, AgentExecutorPlaneBackgroundErrorHandler as w, AgentExecutorPlaneBinding as x, AgentExecutorPlaneStore as y, AgentExecutorPreflightResult as z };