@kodax-ai/kodax 0.7.71 → 0.7.72

package/dist/types-chunks/{bash-prefix-extractor.d-YoiZl5yt.d.ts → bash-prefix-extractor.d-CHJO5y94.d.ts}

@@ -1,6 +1,6 @@
-import { aT as KodaXGoalState, M as AgentMessage, cX as StopHookFn, bb as KodaXSessionLineage, aZ as KodaXJsonValue, aN as KodaXExtensionSessionRecord, f as Agent, dj as WorkflowIsolation, aO as KodaXExtensionSessionState, b2 as KodaXSessionArtifactLedgerEntry, cI as SessionErrorMetadata, bj as KodaXSessionScope, bk as KodaXSessionStorage, bK as MemoryContextIdentity, bW as MemoryPack, aX as KodaXInputArtifact, D as AgentExecutorPlaneBinding, ac as ChildTaskRegistry, dg as WorkflowEventCorrelation, ai as CompactionUpdate, dt as WorkflowProcessEvent, df as WorkflowEvent, a9 as AskUserQuestionOptions, a5 as AskUserAnswer, a7 as AskUserMultiOptions, c8 as MemoryReviewPlan, a$ as KodaXMemoryOutcomeDigest, c9 as MemoryReviewRunner, aC as Guardrail, an as DiscoveredInstance, c$ as TaskAbortRegistry } from './types.d-CRCaLt_s.js';
+import { br as KodaXGoalState, a8 as AgentMessage, du as StopHookFn, bL as KodaXSessionLineage, k as AgentActorStore, aC as AgentTurnExecutor, t as AgentBudgetPort, h as AgentActorClient, N as AgentExecutionResult, V as AgentExecutorPlaneBinding, bx as KodaXJsonValue, bl as KodaXExtensionSessionRecord, f as Agent, dR as WorkflowIsolation, bm as KodaXExtensionSessionState, bC as KodaXSessionArtifactLedgerEntry, de as SessionErrorMetadata, bT as KodaXSessionScope, bU as KodaXSessionStorage, ci as MemoryContextIdentity, cu as MemoryPack, aK as AskUserQuestionOptions, aG as AskUserAnswer, aI as AskUserMultiOptions, dO as WorkflowEventCorrelation, aS as CompactionUpdate, e3 as WorkflowProcessEvent, dN as WorkflowEvent, cI as MemoryReviewPlan, bz as KodaXMemoryOutcomeDigest, ba as Guardrail, aX as DiscoveredInstance, bv as KodaXInputArtifact, cJ as MemoryReviewRunner } from './types.d-DH1mvdcl.js';
 import { a0 as KodaXTokenUsage, k as KodaXMessage, a1 as KodaXToolDefinition, a9 as KodaXWireReasoningEffort, U as KodaXTaskRoutingDecision, V as KodaXTaskType, W as KodaXTaskWorkIntent, Q as KodaXTaskComplexity, L as KodaXRiskLevel, h as KodaXHarnessProfile, f as KodaXExecutionMode, b as KodaXChildFanoutClass, F as KodaXReasoningMode, J as KodaXReviewScale } from './types.d-Cqaw71Ax.js';
-import { I as ISkillRegistry, d as SkillDynamicContextExecutor } from './types.d-vJExiRje.js';
+import { d as SkillDynamicContextExecutor, I as ISkillRegistry } from './types.d-DCQVBqVn.js';
 import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation, WorkspaceSymbol, CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall } from 'vscode-languageserver-protocol';
 import { K as KodaXLlmTimeoutConfig, a as CostTracker } from './cost-tracker.d-BeaenODW.js';
 import { C as CapabilityKind, f as CapabilitySearchSnapshot, b as CapabilityResult } from './capability.d-K664nHOS.js';
@@ -74,88 +74,6 @@ interface GoalToolsContext {
  */
 declare function makeDisabledGoalToolsContext(): GoalToolsContext;
 
-/** One tool-call breadcrumb. Captures only the name + a 60-char input
- * hint so the snapshot stays compact under fan-out. Mirrors the
- * `inputHint` extraction in `buildChildEvents.onToolUseStart`. */
-interface ChildToolCallBreadcrumb {
-    readonly iteration: number;
-    readonly toolName: string;
-    /** Truncated path/pattern/command, ≤60 chars. May be empty when the
-     * tool input has no obvious key field. */
-    readonly inputHint: string;
-    /** Monotonic wall-clock ms at the time the tool call started. */
-    readonly startedAt: number;
-}
-/** Snapshot status. `running` is the initial state on dispatch. The
- * three terminal states map from the child promise outcome:
- *   - `completed` — child returned success
- *   - `failed` — child returned non-success OR threw (non-AbortError)
- *   - `aborted` — child threw an AbortError (parent or task_stop fired)
- */
-type ChildProgressStatus = 'running' | 'completed' | 'failed' | 'aborted';
-interface ChildProgressSnapshot {
-    readonly childId: string;
-    /** Mutable in the writer (dispatch-child-tasks) — terminal status is
-     * set once in the inner-IIFE `.finally` block. Readers
-     * (task-output tool) treat it as authoritative. */
-    status: ChildProgressStatus;
-    /** Monotonic wall-clock ms at dispatch. */
-    readonly startedAt: number;
-    /** Monotonic wall-clock ms at terminal. Undefined while `status===
-     * 'running'`. */
-    endedAt?: number;
-    /** Iterations consumed by the child agent. Updated by
-     * `snapshotUpdater({kind:'iteration', iteration, max})` from
-     * `buildChildEvents.onIterationStart`. */
-    iterations: number;
-    /** Iteration ceiling forwarded from `ChildExecutorOptions
-     * .maxIterationsPerChild`. */
-    maxIterations: number;
-    /** Mutable ring buffer; writer must respect `RECENT_TOOL_CALLS_RING_CAP`
-     * via `pushBreadcrumb`. */
-    recentToolCalls: ChildToolCallBreadcrumb[];
-    /** Populated at terminal (any of `completed` / `failed` / `aborted`)
-     * with the same pre-guardrail `rawSummary` string that
-     * `dispatch-child-tasks.ts` produces for the `<task-completed>` body.
-     * For success-empty / failed-empty paths this is the diagnostic
-     * envelope (mode= ... iterations=... etc.) so post-completion
-     * `task_output` reads stay in lock-step with the banner the Worker
-     * already saw. */
-    finalText?: string;
-    /** Optional dispatcher role (`scout` / `worker` / `generator`),
-     * captured at init so a debug-style `task_output` peek can correlate
-     * the child with the parent fan-out class. Not surfaced in the
-     * envelope; reserved for future tracing. */
-    readonly parentRole?: string;
-    /** Read-only flag forwarded from the dispatch bundle. Same rationale
-     * as `parentRole` — currently captured for future surfacing. */
-    readonly readOnly?: boolean;
-    /**
-     * FEATURE_191 — registered specialist agent name when the dispatch
-     * routed through a `subagent_type` argument. `undefined` for generic
-     * anonymous children. Surfaced by `task_output` so post-mortem peeks
-     * can identify which specialist owned the child.
-     */
-    readonly specialistName?: string;
-}
-/**
- * Event variants the per-child events bridge feeds back to the
- * snapshot. Kept as a discriminated union so future event kinds (e.g.,
- * a real assistant-text chunk hook if the agent runtime grows one) can
- * be added without breaking existing call sites.
- */
-type ChildSnapshotEvent = {
-    readonly kind: 'iteration';
-    readonly iteration: number;
-    readonly maxIterations: number;
-} | {
-    readonly kind: 'tool-start';
-    readonly iteration: number;
-    readonly toolName: string;
-    readonly inputHint: string;
-    readonly startedAt: number;
-};
-
 /** Result of a cache lookup. */
 type ReadStateLookup = {
     readonly kind: 'miss';
@@ -319,7 +237,7 @@ interface TodoAddSeed {
  *                                       for atomic "rename a flag" patches.
  *
  * `owner` and `sourceObligationIndex` are intentionally NOT patchable
- * post-creation — they identify provenance (which dispatch_child_task
+ * post-creation — they identify provenance (which child-Actor
  * branch / which Scout obligation produced the item) and must stay
  * stable for downstream consumers. Pass them via `add()` or `init()`
  * seed and treat them as immutable thereafter.
@@ -428,6 +346,14 @@ interface WorkflowInvocationPolicyInput {
 interface WorkflowInvocationPolicyDecision {
     readonly action: WorkflowInvocationAction;
 }
+/**
+ * Decide whether a natural-language turn should receive the model-callable
+ * Workflow surface. This does not launch or generate anything: the Worker still
+ * scouts and authors the protocol. Requiring the standalone product word keeps
+ * ordinary parallel/review requests from acquiring `run_workflow`; the code
+ * identifier `run_workflow` alone is deliberately not an activation signal.
+ */
+declare function hasExplicitNaturalLanguageWorkflowIntent(input: string): boolean;
 /**
  * Decide whether the REPL host should launch a workflow before the agent runs.
  *
@@ -903,6 +829,39 @@ interface GoalRuntimeBinding {
  */
 declare function buildGoalRuntimeBinding(deps: GoalRuntimeBindingDeps): GoalRuntimeBinding;
 
+interface CodingActorSessionOptions {
+    readonly maxConcurrentThreadsPerSession?: number;
+    readonly sessionId?: string;
+    readonly store?: AgentActorStore;
+    readonly executor?: AgentTurnExecutor;
+    readonly budget?: AgentBudgetPort;
+}
+/** One Runtime-owned Actor tree for one KodaX session. */
+declare class CodingActorSession {
+    private readonly sessionOptions;
+    private readonly controller;
+    private readonly turnExecutors;
+    private environment?;
+    private activeBudget?;
+    constructor(sessionOptions?: CodingActorSessionOptions);
+    initialize(): Promise<void>;
+    attach(parentCtx: KodaXToolExecutionContext, options: KodaXOptions, callerPath?: string): AgentActorClient;
+    rootControl(): AgentActorClient;
+    createWorkflowOwner(parentPath: string, runId: string): Promise<AgentActorClient>;
+    workflowOwnerSignal(ownerPath: string): AbortSignal;
+    settleWorkflowOwner(ownerPath: string, state: 'completed' | 'failed' | 'interrupted', result: AgentExecutionResult & {
+        readonly error?: string;
+    }): Promise<void>;
+    bindActor(actorPath: string): AgentActorClient;
+    closeActor(targetPath: string, reason?: string): Promise<void>;
+    registerTurnExecutor(key: string, executor: AgentTurnExecutor): () => void;
+    waitForAgentCapacity(signal?: AbortSignal): Promise<boolean>;
+    close(reason?: string): Promise<void>;
+}
+declare function createLocalCodingActorControl(parentCtx: KodaXToolExecutionContext, options: KodaXOptions): AgentActorClient;
+/** Runtime adapter for detached external Actor turns. The executor plane stays internal. */
+declare function createExternalActorTurnExecutor(binding: AgentExecutorPlaneBinding): AgentTurnExecutor;
+
 /**
  * FEATURE_218 — KodaX Self-Knowledge Manual types.
  *
@@ -1340,7 +1299,7 @@ interface ExtensionRuntimeContract extends CapabilityRuntimeContract {
  * Required field on every {@link import('./types.js').LocalToolDefinition}. Used by:
  *   - Plan mode: tools with `sideEffect !== 'readonly'` are blocked unless
  *     they explicitly opt in via `planModeAllowed: true` (e.g.
- *     `exit_plan_mode`, `task_stop`).
+ *     `exit_plan_mode`, `interrupt_agent`).
  *   - SDK embedders (KodaX Space etc.): iterate `getAllRegisteredTools()`
  *     and build their own blocklist by category — replaces the previous
  *     practice of hardcoding a `Set<string>` of tool names, which silently
@@ -1371,12 +1330,12 @@ interface ExtensionRuntimeContract extends CapabilityRuntimeContract {
  *                            state (web_fetch with a mutating method, mcp_call).
  *   - `'mutates-state'`   — changes internal session/agent state without
  *                            FS or shell side effects (todo_update,
- *                            send_message, dispatch_child_task,
+ *                            send_message, spawn_agent, followup_task,
  *                            exit_plan_mode, emit_managed_protocol).
  *
- * Pick the dominant effect when a tool touches multiple. e.g. `dispatch_
- * child_task` may transitively run any tool, but its own direct effect is
- * spawning a child agent (`mutates-state`).
+ * Pick the dominant effect when a tool touches multiple. For example,
+ * `spawn_agent` may transitively run any tool, but its own direct effect is
+ * starting an Actor turn (`mutates-state`).
  */
 type ToolSideEffect = 'readonly' | 'reads-network' | 'mutates-fs' | 'mutates-shell' | 'mutates-network' | 'mutates-state';
 
@@ -1533,8 +1492,8 @@ type TodoEvaluatorHint = 'build' | 'test' | 'lint';
  * steps don't need it; weaker models reach the API more easily without
  * the forced second-string burden.
  *
- * `owner` partitions the list when child agents run in parallel under
- * `dispatch_child_task`; "main" is the parent thread.
+ * `owner` partitions the list when child Actors run in parallel;
+ * "main" is the parent thread.
  */
 interface TodoItem {
     readonly id: string;
@@ -1902,7 +1861,7 @@ interface KodaXEvents {
      * (`agent_completed` / `agent_unverified` / `agent_failed` /
      * `agent_summary_updated`). The REPL formats each via `formatWorkflowAgentDigest`
      * and writes it to the transcript — matching the slash `/workflow` path and
-     * `dispatch_child_task` children, whose summaries persist in scrollback.
+     * Actor children, whose summaries persist in scrollback.
      */
     onWorkflowAgentDigest?: (event: KodaXWorkflowAgentDigestEvent & Partial<KodaXLiveEventMeta>) => void;
     /**
@@ -2344,7 +2303,14 @@ interface KodaXChildFinding {
     readonly evidence: readonly string[];
     readonly artifacts: readonly string[];
 }
-type KodaXAgentMode = 'ama' | 'sa' | 'amaw';
+type KodaXAgentMode = 'ama' | 'sa'
+/** @deprecated AMAW was merged into AMA in v0.7.72; accepted as an input alias only. */
+ | 'amaw';
+type KodaXCanonicalAgentMode = Exclude<KodaXAgentMode, 'amaw'>;
+/** Normalize the retired AMAW spelling at every public SDK entry boundary. */
+declare function normalizeKodaXAgentMode(mode: KodaXAgentMode): KodaXCanonicalAgentMode;
+declare function normalizeKodaXAgentMode(mode: undefined): undefined;
+declare function normalizeKodaXAgentMode(mode: KodaXAgentMode | undefined): KodaXCanonicalAgentMode | undefined;
 type KodaXMemoryStrategy = 'continuous' | 'compact' | 'reset-handoff';
 type KodaXBudgetDisclosureZone = 'green' | 'yellow' | 'orange' | 'red';
 interface KodaXManagedTaskHarnessTransition {
@@ -2585,11 +2551,40 @@ interface KodaXSkillScriptRunner {
     }): Promise<string>;
     dispose(): Promise<void>;
 }
+/** Trusted coding host bridge; lifecycle state remains owned by the Agent controller. */
+interface KodaXActorHost {
+    createWorkflowOwner(parentPath: string, runId: string): Promise<AgentActorClient>;
+    workflowOwnerSignal(ownerPath: string): AbortSignal;
+    settleWorkflowOwner(ownerPath: string, state: 'completed' | 'failed' | 'interrupted', result: AgentExecutionResult & {
+        readonly error?: string;
+    }): Promise<void>;
+    bindActor(actorPath: string): AgentActorClient;
+    closeActor(targetPath: string, reason?: string): Promise<void>;
+    registerTurnExecutor(key: string, executor: AgentTurnExecutor): () => void;
+    waitForAgentCapacity(signal?: AbortSignal): Promise<boolean>;
+}
+interface KodaXManagedWorkBudget {
+    totalBudget: number;
+    spentBudget: number;
+    currentHarness: KodaXHarnessProfile;
+    upgradeCeiling?: KodaXHarnessProfile;
+    lastApprovalBudgetTotal?: number;
+}
 interface KodaXContextOptions {
+    /** Runtime-internal shared work ledger inherited by every descendant Agent run. */
+    managedWorkBudget?: KodaXManagedWorkBudget;
     /** FEATURE_260 runtime-owned identity used for scoped memory reads. */
     memoryIdentity?: MemoryContextIdentity;
     /** Runtime-built F228 pack reused by prompt rendering and MemorySession. */
     memoryPack?: MemoryPack;
+    /** Runtime-minted collaboration principal for this actor execution. */
+    actorControl?: AgentActorClient;
+    /** Trusted host operations that are intentionally absent from model-facing clients. */
+    actorHost?: KodaXActorHost;
+    /** Runtime-owned session Actor tree; attached when a root run builds its tool context. */
+    actorSession?: CodingActorSession;
+    /** Host attribution for an explicit Workflow command, SDK request, or natural-language product word. */
+    workflowIntent?: 'explicit';
     /** Project root used for project-scoped prompts, permissions, and path policy. */
     gitRoot?: string | null;
     /**
@@ -2727,15 +2722,6 @@ interface KodaXContextOptions {
      * than the top-level Worker.
      */
     parentAgentId?: string;
-    /**
-     * FEATURE_123 v0.7.44 — when set, the spawned runtime's
-     * `ctx.childTaskRegistry` reuses this Map instead of allocating a
-     * fresh one. Children pass the parent's registry through so peer
-     * routing (`send_message` to a sibling task_id) finds the target.
-     * Children remain unable to mutate the registry because
-     * `dispatch_child_task` stays in `CHILD_EXCLUDE_TOOLS_BASE`.
-     */
-    inheritedChildTaskRegistry?: ChildTaskRegistry<KodaXChildExecutionResult>;
     /**
      * FEATURE_192 v0.7.44 Phase F — `/goal` runtime binding.
      *
@@ -2830,6 +2816,8 @@ interface KodaXOptions {
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
     agentMode?: KodaXAgentMode;
+    /** Total concurrent Agent turns for one session, including the root. Defaults to 4. */
+    maxConcurrentThreadsPerSession?: number;
     maxIter?: number;
     session?: KodaXSessionOptions;
     context?: KodaXContextOptions;
@@ -3177,6 +3165,12 @@ interface KodaXResult {
 interface KodaXToolExecutionContext {
     /** File backups for undo functionality - 文件备份用于撤销功能 */
     backups: Map<string, string>;
+    /** Runtime-minted collaboration principal; model inputs cannot replace its caller path. */
+    actorControl?: AgentActorClient;
+    /** Shared root-run work ledger; descendant runtimes retain this exact object. */
+    managedWorkBudget?: KodaXManagedWorkBudget;
+    /** Trusted host operations that are intentionally absent from model-facing clients. */
+    actorHost?: KodaXActorHost;
     /** FEATURE_260: current exactly-scoped read-only MemorySession query binding. */
     memoryRecall?: (need: string) => Promise<{
         readonly content: string;
@@ -3301,22 +3295,13 @@ interface KodaXToolExecutionContext {
         readonly repoIntelligenceMode?: KodaXRepoIntelligenceMode;
         readonly repoIntelligenceTrace?: boolean;
     };
-    /**
-     * Parent SDK/REPL callback surface available to child-dispatch tools.
-     * `dispatch_child_task` uses this to preserve live child telemetry without
-     * copying every callback onto KodaXToolExecutionContext as a separate field.
-     */
+    /** Parent SDK/REPL callback surface used to preserve nested Agent telemetry. */
     parentEvents?: KodaXEvents;
     /**
      * FEATURE_123 v0.7.44 — agentId of the agent whose tool call this
      * context backs. `undefined` for the top-level Worker (main runtime
      * loop); set to the child's `bundle.id` for sub-agent runtimes.
      *
-     * Consumed by `send_message` to:
-     *   - know who "self" is for broadcast self-exclusion and for the
-     *     `from=...` framing tag,
-     *   - reject self-targeted sends as a single-hop cycle guard.
-     *
      * Wired by `child-executor.executeReadChild` / `executeWriteChild`
      * via `options.context.currentAgentId`.
      */
@@ -3328,31 +3313,13 @@ interface KodaXToolExecutionContext {
      * `'worker'` sentinel rather than an agentId). Set for grand-child
      * runtimes whose parent is itself a child.
      *
-     * Consumed by `send_message` when `to === 'worker'`:
-     *   - If `parentAgentId` is set, route to that specific id.
-     *   - If `parentAgentId` is undefined, route to `agentId: undefined`
-     *     (the main loop / top Worker).
      */
     parentAgentId?: string;
     /**
      * FEATURE_123 v0.7.44 — per-turn `send_message` flood throttle counter.
      *
-     * Mutable ref that the `send_message` tool increments on every
-     * outbound enqueue (broadcast counts as N — one per recipient).
-     * `runner-driven.ts`' `beforeNextTurn` resets `count = 0` at every
-     * turn boundary so the limit is "per LLM turn", matching the
-     * design's "≤5 per child-turn / ≤20 per Worker-turn".
-     *
-     * The cap chosen by `send_message` is per-call:
-     *   - Worker (`currentAgentId === undefined`): 20 outbound enqueues
-     *     per turn — Worker is the coordinator + has the higher fan-out
-     *     budget.
-     *   - Child (`currentAgentId !== undefined`): 5 outbound enqueues
-     *     per turn — peer chatter that goes over this is almost always
-     *     a misfire (storm vs coordination).
-     *
-     * When undefined (sync-mode dispatch, no async substrate), the
-     * throttle is bypassed.
+     * Legacy-compatible per-turn collaboration throttle counter. Actor controls
+     * enforce their own topology and permission limits.
      */
     sendMessageTurnCounter?: {
         count: number;
@@ -3375,9 +3342,8 @@ interface KodaXToolExecutionContext {
      */
     planModeBlockCheck?: (tool: string, input: Record<string, unknown>) => string | null;
     /**
-     * FEATURE_092 phase 2b.7b slice D: parent-Runner guardrails surfaced into the
-     * tool-execution context so `dispatch_child_task` can forward them to the
-     * child's `Runner.run` via `KodaXOptions.guardrails`. Sharing the SAME
+     * Parent-Runner guardrails surfaced into the tool-execution context so nested
+     * Agent turns share the same mutable safety state. Sharing the SAME
      * guardrail instance means the auto-mode `engine` + `denialTracker` +
      * `circuitBreaker` state is observed across the parent/child boundary —
      * rate-limit by hitting the threshold from a fresh tracker).
@@ -3456,73 +3422,6 @@ interface KodaXToolExecutionContext {
      * See `packages/coding/src/multi-instance/active-file-warning.ts`.
      */
     siblingSnapshot?: readonly DiscoveredInstance[];
-    /**
-     * FEATURE_119 v0.7.36 Pattern B: registry of in-flight async child
-     * dispatches. When set, `dispatch_child_task` runs in fire-and-forget
-     * mode (returns a `task_id` immediately without awaiting). The Worker
-     * launches multiple children in parallel; under FEATURE_155 (v0.7.39)
-     * idle-yield, the runner-driven outer loop awaits the registered
-     * promises on the Worker's behalf and splices a `<task-completed>`
-     * banner into the next user turn — the Worker no longer pulls results
-     * itself (the legacy `await_child_task` tool was removed in Slice C1).
-     *
-     * The map's value is the executor's full result promise, identical to
-     * what the legacy synchronous dispatch returned.
-     *
-     * When `undefined`, dispatch falls back to the legacy synchronous path
-     * (await inline, return finding text). The registry is populated by
-     * `runner-driven.ts` per turn so each agent run has its own registry
-     * scope.
-     *
-     * **v0.7.39 FEATURE_120 Step 0**: the type alias is now imported from
-     * `@kodax-ai/agent`'s orchestration layer (`ChildTaskRegistry<T>`).
-     * Structure-compatible with the previous `Map<string, Promise<…>>`
-     * inline shape — the rename is a packaging-only change per ADR-021.
-     * Coding-flavor consumers should keep using
-     * `registerChildTask(registry, id, promise)` (also from
-     * `@kodax-ai/agent`) to get the FEATURE_155 Bug A cleanup chain
-     * built-in.
-     */
-    childTaskRegistry?: ChildTaskRegistry<KodaXChildExecutionResult>;
-    /**
-     * FEATURE_120 v0.7.39 Phase 3b: per-child AbortController registry.
-     * Provisioned alongside `childTaskRegistry` by `runner-driven.ts`
-     * when async dispatch is enabled. `dispatch_child_task` allocates
-     * a fresh `AbortController` per child and registers it here under
-     * the child's task id; the child's executor receives the controller's
-     * signal (chained with the parent's `abortSignal` so EITHER source
-     * can cancel the child). The `task_stop` tool looks up the
-     * controller and calls `requestTaskStop` to fire the signal.
-     *
-     * The map is cleaned in the dispatch handler's `.finally` chain
-     * alongside the child-task registry cleanup so an aborted or
-     * settled child does not leak its controller reference.
-     *
-     * Undefined in legacy sync-mode dispatch (same gate as
-     * `childTaskRegistry`).
-     */
-    childAbortControllers?: TaskAbortRegistry;
-    /**
-     * FEATURE_177 v0.7.45 substrate for the `task_output` tool. Per-child
-     * runtime snapshot a parent agent can query mid-flight to peek at
-     * iteration count + recent tool-call breadcrumbs without waiting for
-     * the child's `<task-completed>` banner.
-     *
-     * Populated by `dispatch_child_task` at launch (`initChildSnapshot`)
-     * and at terminal (`finalizeChildSnapshot` in the child promise's
-     * inner-IIFE `.finally`). The `task_output` tool reads from this map.
-     *
-     * Snapshots survive the child task settling (so post-completion peeks
-     * work) and are bounded by `CHILD_PROGRESS_SNAPSHOT_CAP` (FIFO prune
-     * by `startedAt` when the cap is exceeded). No TTL — snapshots are
-     * cleared with the ctx itself when the parent runner exits.
-     *
-     * Undefined in legacy sync-mode dispatch (same gate as
-     * `childTaskRegistry`). Children's own SA contexts do NOT inherit
-     * this map (verified by `buildToolExecutionContext` not forwarding
-     * it into child `runKodaX` calls).
-     */
-    childProgressSnapshots?: Map<string, ChildProgressSnapshot>;
     /**
      * FEATURE_192 v0.7.44 — `/goal` Persistent Goal runtime hook.
      *
@@ -3542,15 +3441,6 @@ interface KodaXToolExecutionContext {
      * absent in SA / when no runs dir is configured, so the tool fails closed.
      */
     workflowHost?: WorkflowToolHost;
-    /**
-     * Gap A — run-level progress getters keyed by a background workflow's runId.
-     * The async `run_workflow` path registers a getter here on start and removes
-     * it when the run settles, so `task_output(runId)` can render live workflow
-     * progress (phase + active/finished agents) while it is in flight, instead of
-     * `not_found`. Same lifetime as `childAbortControllers` (per ctx). Undefined
-     * outside the async/idle-yield path.
-     */
-    workflowRunProgress?: Map<string, () => WorkflowRunProgressView | undefined>;
 }
 /** Result of a model-launched workflow run (FEATURE_246 Part A2). */
 interface WorkflowToolHostResult {
@@ -3587,40 +3477,12 @@ interface WorkflowToolHostInlineInput {
     readonly source: string;
     readonly args?: unknown;
     readonly resumeFromRunId?: string;
-    /**
-     * Per-run abort signal, combined with the session signal. Lets the Worker stop
-     * THIS running workflow (via task_stop on its task_id) without aborting the
-     * whole session — so it can change the goal, stop, and re-run an improved script.
-     */
+    /** Per-run abort signal, combined with the session signal. */
     readonly signal?: AbortSignal;
 }
-/**
- * Compact live view of a running workflow. Surfaced so the Worker can peek at a
- * background `run_workflow`'s progress via `task_output(runId)` while it is still
- * in flight (gap A) — otherwise it only ever sees the final `<task-completed>`.
- * Derived on demand from the run's process snapshot; deliberately free of any
- * workflow-layer type import so this module stays dependency-light.
- */
-interface WorkflowRunProgressView {
-    readonly status: 'running' | 'completed' | 'failed' | 'stopped';
-    readonly workflowName: string;
-    /** Active phase title (e.g. "Verify"), when the script uses phases. */
-    readonly phase?: string;
-    readonly phaseIndex?: number;
-    readonly phaseTotal?: number;
-    /** Names of the agents currently running. */
-    readonly activeAgents: readonly string[];
-    readonly completedAgents: number;
-    readonly failedAgents: number;
-    readonly stoppedAgents: number;
-    readonly totalSpawned: number;
-    readonly plannedAgents?: number;
-    readonly elapsedMs?: number;
-}
 /** ADR-049: a started-but-not-awaited workflow handle. `done` resolves with the
- *  terminal result when the run settles — the async run_workflow path registers it
- *  in the Worker's childTaskRegistry so the idle-yield loop resumes the Worker with
- *  the synthesis instead of blocking the turn. */
+ * terminal result when the run settles. The Workflow owner Actor exposes that
+ * result without blocking the launching turn. */
 type WorkflowToolHostStartResult = {
     readonly kind: 'declined';
     readonly reason?: string;
@@ -3630,9 +3492,6 @@ type WorkflowToolHostStartResult = {
     readonly done: Promise<WorkflowToolHostResult>;
     /** Non-blocking diagnostic preflight warnings available immediately at start. */
     readonly workflowQualityWarnings?: readonly string[];
-    /** Gap A: on-demand live progress for a `task_output(runId)` peek while the
-     *  run is in flight. Absent when the host cannot snapshot the run. */
-    readonly getProgress?: () => WorkflowRunProgressView | undefined;
 };
 interface WorkflowToolHost {
     /** Start an inline-authored workflow ({manifest, source}) and await its result.
@@ -3794,5 +3653,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, LSP_SERVERS as aN, LspService as aP, drainPendingSwaps as bA, estimateToolSchemaTokens as bB, extractCommandPrefix as bC, getDefaultLspService as bD, hasPendingSwap as bE, makeDisabledGoalToolsContext as bF, planToolExposure as bG, providerResilienceConfigFromTimeouts as bH, recordCompactionSavings as bI, resolveConstructedAgent as bJ, shouldSkipLlmCompaction as bK, shutdownDefaultLspService as bL, withGoalBeforeNextTurn as bM, withGoalStopHook as bN, workflowStartOutcomeConsumesTurn as bO, buildGoalRuntimeBinding as bu, consumeCompactionCooldown as bv, createBashPrefixExtractor as bw, createCompactionAntiThrashState as bx, createRuntimeContextBudgetSnapshot as by, decideWorkflowInvocation as bz };
-export type { KodaXProviderPolicyHints as $, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXContextOptions as H, KodaXContextTokenSnapshot as I, KodaXEffectiveTaskConfig as J, KodaXActivityEventMeta as K, KodaXEvents as L, KodaXLiveEventMeta as M, KodaXManagedBudgetSnapshot as N, KodaXManagedProtocolPayload as O, KodaXManagedTask as P, KodaXManagedTaskRuntimeState as Q, KodaXManagedTaskStatusEvent as R, KodaXManualIndexTopic as S, KodaXManualSource as T, KodaXManualTopic as U, KodaXManualTopicId as V, KodaXManualTopicInput as W, KodaXMemoryStrategy as X, KodaXOptions as Y, KodaXOrchestrationVerdict as Z, KodaXParentReductionContract as _, BashPrefixExtractor as a, ResolveKodaXManualInput as a$, KodaXRepoIntelligenceCapability as a0, KodaXRepoIntelligenceMode as a1, KodaXRepoIntelligenceResolvedMode as a2, KodaXRepoIntelligenceTrace as a3, KodaXRepoIntelligenceTraceEvent as a4, KodaXRepoRoutingSignals as a5, KodaXResult as a6, KodaXRoleRoundSummary as a7, KodaXRuntimeVerificationContract as a8, KodaXSelfManualConfig as a9, KodaXToolEventMeta as aA, KodaXToolExecutionContext as aB, KodaXToolVisibilityMeta as aC, KodaXToolVisibilityPolicy as aD, KodaXTurnCompletedEvent as aE, KodaXTurnDeliveryKind as aF, KodaXTurnFailedEvent as aG, KodaXTurnStartedEvent as aH, KodaXVerificationScorecard as aI, KodaXVerificationScorecardCriterion as aJ, KodaXWorkflowAgentDigestEvent as aK, KodaXWorkflowEventMeta as aL, KodaXWorkflowTimeoutConfig as aM, LspServerInfo as aO, LspServiceConfig as aQ, ProviderExecutionState as aR, ProviderRecoveryEvent as aS, ProviderResilienceConfig as aT, ProviderResiliencePolicy as aU, RecoveryAction as aV, RecoveryDecision as aW, RecoveryLadderStep as aX, RecoveryResult as aY, ResilienceClassification as aZ, ResilienceErrorClass as a_, KodaXSessionControl as aa, KodaXSessionMutators as ab, KodaXSessionOptions as ac, KodaXSidecarMessageEvent as ad, KodaXSkillDynamicContextPolicy as ae, KodaXSkillInvocationContext as af, KodaXSkillMap as ag, KodaXSkillProjectionConfidence as ah, KodaXSkillScriptInputFile as ai, KodaXSkillScriptOutputFile as aj, KodaXSkillScriptRunInput as ak, KodaXSkillScriptRunner as al, KodaXTaskCapabilityHint as am, KodaXTaskContract as an, KodaXTaskEvidenceArtifact as ao, KodaXTaskEvidenceBundle as ap, KodaXTaskEvidenceEntry as aq, KodaXTaskRole as ar, KodaXTaskRoleAssignment as as, KodaXTaskStatus as at, KodaXTaskSurface as au, KodaXTaskToolPolicy as av, KodaXTaskVerificationContract as aw, KodaXTaskVerificationCriterion as ax, KodaXTaskWorkItem as ay, KodaXTimeoutConfig as az, BashPrefixResult as b, ResolveKodaXManualOptions as b0, ResolveKodaXManualResult as b1, RuntimeCompactionSkippedEvent as b2, RuntimeContextBudgetBreakdown as b3, RuntimeContextBudgetRecommendation as b4, RuntimeContextBudgetSnapshot as b5, RuntimeContextBudgetSnapshotInput as b6, RuntimeContextOptimizationProfile as b7, RuntimeContextPressure as b8, RuntimeDefaultsSnapshot as b9, RuntimeToolExposureDecision as ba, RuntimeToolExposureMode as bb, RuntimeToolExposurePlan as bc, RuntimeToolExposurePlanInput as bd, RuntimeToolExposureReason as be, TodoItem as bf, TodoList as bg, TodoStatus as bh, ToolSideEffect as bi, WorkflowHostPolicy as bj, WorkflowInvocationAction as bk, WorkflowInvocationPolicyDecision as bl, WorkflowInvocationPolicyInput as bm, WorkflowInvocationSource as bn, WorkflowRunProgressView as bo, WorkflowStartOutcome as bp, WorkflowToolHost as bq, WorkflowToolHostInlineInput as br, WorkflowToolHostResult as bs, WorkflowToolHostStartResult as bt, BoundExtensionRuntimeController as c, ChildSnapshotEvent as d, CompactionAntiThrashConfig as e, CompactionAntiThrashState as f, CompactionSavingsDecision as g, CompactionSavingsSample as h, CompactionSkipReason as i, CreateBashPrefixExtractorOptions as j, ExtractCommandPrefixOptions as k, GoalCompleteResult as l, GoalCreateInput as m, GoalLifecycleContext as n, GoalRuntimeBinding as o, GoalRuntimeBindingDeps as p, GoalToolsContext as q, KodaXAgentMode as r, KodaXAgentProfile as s, KodaXAgentScope as t, KodaXBudgetDisclosureZone as u, KodaXBudgetExtensionRequest as v, KodaXChildAgentResult as w, KodaXChildContextBundle as x, KodaXChildExecutionResult as y, KodaXCompactionOverride as z };
+export { ALWAYS_RESIDENT_TOOL_NAMES as A, BASH_POLICY_SPEC as B, LSP_SERVERS as aQ, LspService as aS, createExternalActorTurnExecutor as bA, createLocalCodingActorControl as bB, createRuntimeContextBudgetSnapshot as bC, decideWorkflowInvocation as bD, drainPendingSwaps as bE, estimateToolSchemaTokens as bF, extractCommandPrefix as bG, getDefaultLspService as bH, hasExplicitNaturalLanguageWorkflowIntent as bI, hasPendingSwap as bJ, makeDisabledGoalToolsContext as bK, normalizeKodaXAgentMode as bL, planToolExposure as bM, providerResilienceConfigFromTimeouts as bN, recordCompactionSavings as bO, resolveConstructedAgent as bP, shouldSkipLlmCompaction as bQ, shutdownDefaultLspService as bR, withGoalBeforeNextTurn as bS, withGoalStopHook as bT, workflowStartOutcomeConsumesTurn as bU, buildGoalRuntimeBinding as bw, consumeCompactionCooldown as bx, createBashPrefixExtractor as by, createCompactionAntiThrashState as bz, CodingActorSession as d };
+export type { KodaXOptions as $, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXChildContextBundle as H, KodaXChildExecutionResult as I, KodaXCompactionOverride as J, KodaXActivityEventMeta as K, KodaXContextOptions as L, KodaXContextTokenSnapshot as M, KodaXEffectiveTaskConfig as N, KodaXEvents as O, KodaXLiveEventMeta as P, KodaXManagedBudgetSnapshot as Q, KodaXManagedProtocolPayload as R, KodaXManagedTask as S, KodaXManagedTaskRuntimeState as T, KodaXManagedTaskStatusEvent as U, KodaXManualIndexTopic as V, KodaXManualSource as W, KodaXManualTopic as X, KodaXManualTopicId as Y, KodaXManualTopicInput as Z, KodaXMemoryStrategy as _, BashPrefixExtractor as a, RecoveryResult as a$, KodaXOrchestrationVerdict as a0, KodaXParentReductionContract as a1, KodaXProviderPolicyHints as a2, KodaXRepoIntelligenceCapability as a3, KodaXRepoIntelligenceMode as a4, KodaXRepoIntelligenceResolvedMode as a5, KodaXRepoIntelligenceTrace as a6, KodaXRepoIntelligenceTraceEvent as a7, KodaXRepoRoutingSignals as a8, KodaXResult as a9, KodaXTaskVerificationCriterion as aA, KodaXTaskWorkItem as aB, KodaXTimeoutConfig as aC, KodaXToolEventMeta as aD, KodaXToolExecutionContext as aE, KodaXToolVisibilityMeta as aF, KodaXToolVisibilityPolicy as aG, KodaXTurnCompletedEvent as aH, KodaXTurnDeliveryKind as aI, KodaXTurnFailedEvent as aJ, KodaXTurnStartedEvent as aK, KodaXVerificationScorecard as aL, KodaXVerificationScorecardCriterion as aM, KodaXWorkflowAgentDigestEvent as aN, KodaXWorkflowEventMeta as aO, KodaXWorkflowTimeoutConfig as aP, LspServerInfo as aR, LspServiceConfig as aT, ProviderExecutionState as aU, ProviderRecoveryEvent as aV, ProviderResilienceConfig as aW, ProviderResiliencePolicy as aX, RecoveryAction as aY, RecoveryDecision as aZ, RecoveryLadderStep as a_, KodaXRoleRoundSummary as aa, KodaXRuntimeVerificationContract as ab, KodaXSelfManualConfig as ac, KodaXSessionControl as ad, KodaXSessionMutators as ae, KodaXSessionOptions as af, KodaXSidecarMessageEvent as ag, KodaXSkillDynamicContextPolicy as ah, KodaXSkillInvocationContext as ai, KodaXSkillMap as aj, KodaXSkillProjectionConfidence as ak, KodaXSkillScriptInputFile as al, KodaXSkillScriptOutputFile as am, KodaXSkillScriptRunInput as an, KodaXSkillScriptRunner as ao, KodaXTaskCapabilityHint as ap, KodaXTaskContract as aq, KodaXTaskEvidenceArtifact as ar, KodaXTaskEvidenceBundle as as, KodaXTaskEvidenceEntry as at, KodaXTaskRole as au, KodaXTaskRoleAssignment as av, KodaXTaskStatus as aw, KodaXTaskSurface as ax, KodaXTaskToolPolicy as ay, KodaXTaskVerificationContract as az, BashPrefixResult as b, ResilienceClassification as b0, ResilienceErrorClass as b1, ResolveKodaXManualInput as b2, ResolveKodaXManualOptions as b3, ResolveKodaXManualResult as b4, RuntimeCompactionSkippedEvent as b5, RuntimeContextBudgetBreakdown as b6, RuntimeContextBudgetRecommendation as b7, RuntimeContextBudgetSnapshot as b8, RuntimeContextBudgetSnapshotInput as b9, RuntimeContextOptimizationProfile as ba, RuntimeContextPressure as bb, RuntimeDefaultsSnapshot as bc, RuntimeToolExposureDecision as bd, RuntimeToolExposureMode as be, RuntimeToolExposurePlan as bf, RuntimeToolExposurePlanInput as bg, RuntimeToolExposureReason as bh, TodoItem as bi, TodoList as bj, TodoStatus as bk, ToolSideEffect as bl, WorkflowHostPolicy as bm, WorkflowInvocationAction as bn, WorkflowInvocationPolicyDecision as bo, WorkflowInvocationPolicyInput as bp, WorkflowInvocationSource as bq, WorkflowStartOutcome as br, WorkflowToolHost as bs, WorkflowToolHostInlineInput as bt, WorkflowToolHostResult as bu, WorkflowToolHostStartResult as bv, BoundExtensionRuntimeController as c, CodingActorSessionOptions as e, CompactionAntiThrashConfig as f, CompactionAntiThrashState as g, CompactionSavingsDecision as h, CompactionSavingsSample as i, CompactionSkipReason as j, CreateBashPrefixExtractorOptions as k, ExtractCommandPrefixOptions as l, GoalCompleteResult as m, GoalCreateInput as n, GoalLifecycleContext as o, GoalRuntimeBinding as p, GoalRuntimeBindingDeps as q, GoalToolsContext as r, KodaXActorHost as s, KodaXAgentMode as t, KodaXAgentProfile as u, KodaXAgentScope as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXCanonicalAgentMode as y, KodaXChildAgentResult as z };