@kodax-ai/kodax 0.7.57 → 0.7.59

package/dist/types-chunks/{bash-prefix-extractor.d-BgvMbfq6.d.ts → bash-prefix-extractor.d-BNdpV4Cf.d.ts}

@@ -1,9 +1,10 @@
-import { U as KodaXGoalState, f as AgentMessage, b0 as StopHookFn, a4 as KodaXSessionLineage, W as KodaXJsonValue, P as KodaXExtensionSessionRecord, a9 as KodaXSessionScope, aa as KodaXSessionStorage, Q as KodaXExtensionSessionState, C as ChildTaskRegistry, bl as WorkflowEventCorrelation, s as CompactionUpdate, bx as WorkflowProcessEvent, m as AskUserQuestionOptions, k as AskUserMultiOptions, y as Guardrail, bo as WorkflowIsolation, Y as KodaXSessionArtifactLedgerEntry, aN as SessionErrorMetadata, v as DiscoveredInstance, b4 as TaskAbortRegistry } from './process.d-BZncyzEj.js';
-import { Z as KodaXTokenUsage, j as KodaXMessage, a6 as KodaXWireReasoningEffort, E as KodaXReasoningMode, g as KodaXHarnessProfile, T as KodaXTaskWorkIntent, I as KodaXReviewScale, P as KodaXTaskComplexity, b as KodaXChildFanoutClass, R as KodaXTaskRoutingDecision, S as KodaXTaskType, J as KodaXRiskLevel, e as KodaXExecutionMode } from './types.d-6VOXvF88.js';
+import { W as KodaXGoalState, g as AgentMessage, b8 as StopHookFn, aa as KodaXSessionLineage, a0 as KodaXJsonValue, Q as KodaXExtensionSessionRecord, bw as WorkflowIsolation, R as KodaXExtensionSessionState, a2 as KodaXSessionArtifactLedgerEntry, aV as SessionErrorMetadata, af as KodaXSessionScope, ag as KodaXSessionStorage, _ as KodaXInputArtifact, C as ChildTaskRegistry, bt as WorkflowEventCorrelation, t as CompactionUpdate, bF as WorkflowProcessEvent, bs as WorkflowEvent, n as AskUserQuestionOptions, l as AskUserMultiOptions, z as Guardrail, w as DiscoveredInstance, bc as TaskAbortRegistry } from './process.d-BOrAxjvM.js';
+import { Z as KodaXTokenUsage, j as KodaXMessage, a6 as KodaXWireReasoningEffort, R as KodaXTaskRoutingDecision, S as KodaXTaskType, T as KodaXTaskWorkIntent, P as KodaXTaskComplexity, J as KodaXRiskLevel, g as KodaXHarnessProfile, e as KodaXExecutionMode, b as KodaXChildFanoutClass, E as KodaXReasoningMode, I as KodaXReviewScale } from './types.d-Ci5YPFEh.js';
+import { d as SkillDynamicContextExecutor } from './types.d-vJExiRje.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-CBLk1fiD.js';
 import { C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
-import { K as KodaXBaseProvider } from './base.d-BnjQrSVf.js';
-import { a as CostTracker } from './cost-tracker.d-wRtyEW9d.js';
+import { K as KodaXBaseProvider } from './base.d-BA9Doaj_.js';
 
 /**
  * FEATURE_192 v0.7.44 Phase C — Goal-tools execution context.
@@ -408,26 +409,41 @@ interface TodoStore {
 }
 
 type WorkflowInvocationSource = 'natural-language' | 'command';
-type WorkflowInvocationAction = 'none' | 'suggest' | 'auto-start';
-type WorkflowInvocationTrigger = 'explicit' | 'complexity' | 'negated' | 'none';
+type WorkflowInvocationAction = 'none' | 'suggest';
 type WorkflowStartOutcome = 'started' | 'declined' | 'cancelled' | 'failed';
+/**
+ * Host-owned execution ceilings for a workflow run (FEATURE_229). These clamp
+ * the run-manager / runner (maxAgents, concurrency, token budget); they do not
+ * affect whether a workflow launches — that is decided by the source alone
+ * (ADR-047).
+ */
 interface WorkflowHostPolicy {
-    readonly autoStart?: 'off' | 'confirm' | 'on';
     readonly maxAgents?: number;
     readonly maxConcurrency?: number;
     readonly tokenBudget?: number;
 }
 interface WorkflowInvocationPolicyInput {
-    readonly agentMode: KodaXAgentMode;
     readonly source: WorkflowInvocationSource;
-    readonly input: string;
-    readonly hostPolicy?: WorkflowHostPolicy;
 }
 interface WorkflowInvocationPolicyDecision {
     readonly action: WorkflowInvocationAction;
-    readonly trigger: WorkflowInvocationTrigger;
-    readonly reason: string;
 }
+/**
+ * Decide whether the REPL host should launch a workflow before the agent runs.
+ *
+ * FEATURE_246 A5 (ADR-047): the host only launches workflows for an explicit
+ * `/workflow` command (`'suggest'`). Natural language is never intercepted in
+ * any mode (`'none'`) — in AMA/AMAW the Worker owns the decision through the
+ * `run_workflow` tool, which scouts the codebase first and authors a script
+ * from real findings (file paths, the actual sub-problems, a concrete
+ * outputSchema). A blind host-side generator cannot investigate, so pre-empting
+ * NL here produced shallow, disjointed workflows. SA has no workflow host.
+ *
+ * The decision is the source alone, so this takes no agent mode or input text:
+ * the earlier NL detection (explicit/complexity/negation regexes) existed only
+ * to gate the removed auto-start path — that judgment now belongs to the Worker
+ * with full context, not a keyword match.
+ */
 declare function decideWorkflowInvocation(input: WorkflowInvocationPolicyInput): WorkflowInvocationPolicyDecision;
 declare function workflowStartOutcomeConsumesTurn(input: {
     readonly outcome: WorkflowStartOutcome;
@@ -900,6 +916,22 @@ interface KodaXManualSource {
     readonly label: string;
     readonly path: string;
 }
+interface KodaXManualTopic {
+    readonly id: KodaXManualTopicId;
+    /** Human title, shown as the answer heading. */
+    readonly title: string;
+    /** Lookup aliases (English + Chinese high-frequency terms). */
+    readonly aliases: readonly string[];
+    /** One-line summary, shown in the index listing. */
+    readonly summary: string;
+    /**
+     * Bounded topic body. Built at module load — dynamic parts (e.g. the
+     * provider list) read live constants so the manual cannot drift from code.
+     */
+    readonly body: string;
+    readonly sources: readonly KodaXManualSource[];
+    readonly nextTopics: readonly KodaXManualTopicId[];
+}
 interface ResolveKodaXManualInput {
     /** Exact topic id or alias. Takes precedence over `query`. */
     readonly topic?: string;
@@ -924,10 +956,24 @@ interface KodaXManualTopicInput {
 }
 /** Per-call resolver options — consumer topic injection + product re-branding. */
 interface ResolveKodaXManualOptions {
-    /** Injected consumer topics, merged over the KodaX base (override by id). */
+    /** Injected consumer topics, merged over the seeded base (override by id, then append). */
     readonly extraTopics?: readonly KodaXManualTopicInput[];
     /** Product name used in the scope anchor (default "KodaX"). */
     readonly productName?: string;
+    /**
+     * FEATURE_221 — which KodaX base topics to SEED before `extraTopics` is
+     * layered on top. Orthogonal to `extraTopics` (whose override-by-id/append
+     * semantics are unchanged).
+     *
+     *   - `undefined` → seed all base topics (`MANUAL_TOPIC_IDS`). Today's exact
+     *     behavior (byte-identical default).
+     *   - `[]` → seed ZERO base topics; only `extraTopics` populate the manual
+     *     (full white-label replace).
+     *   - `KodaXManualTopicId[]` → seed exactly this curated subset (e.g.
+     *     `KODAX_UNDERLYING_CAPABILITY_TOPICS`), so a replacing consumer can still
+     *     keep the mechanism topics its product inherits from KodaX.
+     */
+    readonly baseTopics?: readonly KodaXManualTopicId[];
 }
 interface ResolveKodaXManualResult {
     /** A topic id (KodaX base or injected consumer topic), or 'index'. */
@@ -1070,16 +1116,6 @@ interface ProviderResiliencePolicy extends ProviderResilienceConfig {
     provider: string;
 }
 
-interface KodaXLlmTimeoutConfig {
-    /** Main provider request hard timeout, in seconds. Default 600s. */
-    readonly requestTimeoutSec?: number;
-    /** Idle timeout between stream deltas, in seconds. Set 0 to disable. Default 0. */
-    readonly streamIdleTimeoutSec?: number;
-    /** Per stream chunk timeout, in seconds. Default 30s. */
-    readonly chunkTimeoutSec?: number;
-    /** Maximum retry delay, in seconds. Default 60s. */
-    readonly maxRetryDelaySec?: number;
-}
 interface KodaXWorkflowTimeoutConfig {
     /** Workflow harness generation LLM call timeout, in seconds. Default 120s. */
     readonly generationTimeoutSec?: number;
@@ -1092,10 +1128,6 @@ interface KodaXTimeoutConfig {
     readonly llm?: KodaXLlmTimeoutConfig;
     readonly workflow?: KodaXWorkflowTimeoutConfig;
 }
-declare function timeoutSecToMs(value: number | undefined, label: string, opts?: {
-    readonly allowZero?: boolean;
-}): number | undefined;
-declare function parseTimeoutSecEnvMs(raw: string | undefined): number | undefined;
 declare function providerResilienceConfigFromTimeouts(timeouts: KodaXTimeoutConfig | undefined): ProviderResilienceConfig | undefined;
 
 /**
@@ -1156,6 +1188,58 @@ interface ExtensionRuntimeContract extends CapabilityRuntimeContract {
     hydrateSession?(sessionId: string): Promise<void>;
 }
 
+/**
+ * v0.7.42 — Declarative tool side-effect class.
+ *
+ * FEATURE_247: extracted into this leaf module (from `tools/types.ts`) so the
+ * main `coding/src/types.ts` can import `ToolSideEffect` for the tool-visibility
+ * policy WITHOUT forming a type-level import cycle with `tools/types.ts` (which
+ * imports `KodaXToolExecutionContext` back from `types.ts`). This file imports
+ * nothing from the coding type graph.
+ *
+ * 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`).
+ *   - 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
+ *     drifted whenever KodaX added a new tool.
+ *   - Internal permission system: `FILE_MODIFICATION_TOOLS` and
+ *     `MODIFICATION_TOOLS` exports in `@kodax-ai/repl` are now computed
+ *     from this metadata at module load time, so adding a new
+ *     `'mutates-fs'` tool here automatically reaches every callsite
+ *     that consumes those sets.
+ *
+ * Categories (mutually exclusive; pick the dominant effect):
+ *   - `'readonly'`        — produces no observable side effect, just reads
+ *                            local state (FS, registry, computed views).
+ *   - `'mutates-fs'`      — writes to the local filesystem (write, edit,
+ *                            multi-edit, undo, worktree-*, construction
+ *                            artifacts). Bash is NOT in this bucket; it has
+ *                            its own.
+ *   - `'mutates-shell'`   — invokes an arbitrary shell command (bash).
+ *   - `'reads-network'`   — FEATURE_247: performs a network request whose
+ *                            LLM-facing semantics are read-only, i.e. no remote
+ *                            mutation (web_search, mcp_read_resource,
+ *                            mcp_get_prompt). Distinct from `'mutates-network'`
+ *                            so a permission broker can allow web research while
+ *                            still blocking mutating network calls. Plan-mode
+ *                            eligibility is still driven by `planModeAllowed`,
+ *                            unchanged.
+ *   - `'mutates-network'` — performs a network request that may mutate remote
+ *                            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,
+ *                            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`).
+ */
+type ToolSideEffect = 'readonly' | 'reads-network' | 'mutates-fs' | 'mutates-shell' | 'mutates-network' | 'mutates-state';
+
 /**
  * FEATURE_200 Phase F (v0.7.45) — Todo domain types extracted from types.ts.
  * Self-contained (no other coding-type deps); re-exported from ../types.ts
@@ -1304,6 +1388,28 @@ interface KodaXActivityEventMeta extends KodaXWorkflowEventMeta {
     readonly childAgentName?: string;
     readonly parentToolId?: string;
     readonly liveOnly?: boolean;
+    /**
+     * FEATURE_247 (R8) — session id this event belongs to. Lets a host that runs
+     * concurrent Partner/Coder sessions attribute a streamed event to the right
+     * session. Absent on paths that do not yet thread the resolved session id.
+     */
+    readonly sessionId?: string;
+    /**
+     * FEATURE_247 (R8) — SDK-consumer agent profile that produced this event.
+     * Absent ⇒ default Coding Agent (or an event emitted before a profile is known).
+     */
+    readonly agentProfile?: KodaXAgentProfile;
+}
+/**
+ * ADR-049: a single workflow child agent reached a terminal/summary state during
+ * an inline `run_workflow` run. The raw `WorkflowEvent` is forwarded (not a
+ * pre-formatted string) so the REPL renders it with its own
+ * `formatWorkflowAgentDigest` — keeping digest formatting in the UI layer and the
+ * coding layer free of presentation logic.
+ */
+interface KodaXWorkflowAgentDigestEvent {
+    readonly runId: string;
+    readonly event: WorkflowEvent;
 }
 interface KodaXToolEventMeta extends KodaXActivityEventMeta {
     readonly toolId?: string;
@@ -1317,6 +1423,17 @@ interface KodaXSidecarMessageEvent {
     readonly content: string;
     readonly suggestedFix?: string;
     readonly trace?: string;
+    /**
+     * FEATURE_247 (R3/R8) — session id the verdict belongs to, so a host running
+     * concurrent Partner/Coder sessions can correlate a sidecar verdict to the
+     * right session. Absent when the resolved session id is not available.
+     */
+    readonly sessionId?: string;
+    /**
+     * FEATURE_247 (R3/R8) — SDK-consumer agent profile whose output was verified.
+     * Absent ⇒ default Coding Agent.
+     */
+    readonly agentProfile?: KodaXAgentProfile;
 }
 interface KodaXTodoDriftWarningEvent {
     readonly kind: 'work_started_without_claimed_todo';
@@ -1441,9 +1558,10 @@ interface KodaXEvents {
         maxAttempts: number;
     }, meta?: KodaXActivityEventMeta) => void;
     /**
-     * Passive capability learning — fired when a provider HARD-rejects a
-     * reasoning-effort value. The REPL records it in `capability-cache.json` so
-     * the rung is narrowed out of the ladder and never offered/sent again.
+     * Passive capability learning: fired when a provider HARD-rejects a
+     * reasoning-effort value. Hosts can record it via the agent-layer capability
+     * cache so the rung is narrowed out of the ladder and never offered/sent
+     * again.
      */
     onReasoningEffortRejected?: (event: {
         provider: string;
@@ -1483,8 +1601,24 @@ interface KodaXEvents {
     onComplete?: () => void;
     onError?: (error: Error) => void;
     onManagedTaskStatus?: (status: KodaXManagedTaskStatusEvent) => void;
+    /**
+     * FEATURE_247 (R4) — fired once at managed-task start with the effective
+     * profile / tool scope / verification snapshot. Lets an SDK embedder confirm
+     * the intended profile (e.g. Partner) actually entered the SDK managed task
+     * and diagnose the tools + verification constraints it was given.
+     */
+    onEffectiveConfig?: (config: KodaXEffectiveTaskConfig) => void;
     /** FEATURE_229: workflow process snapshot stream for SDK/host panels. */
     onWorkflowProcessEvent?: (event: WorkflowProcessEvent) => void;
+    /**
+     * ADR-049: per-agent digest stream for the inline `run_workflow` path. Fires
+     * once per workflow child agent reaching a terminal/summary state
+     * (`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.
+     */
+    onWorkflowAgentDigest?: (event: KodaXWorkflowAgentDigestEvent) => void;
     /**
      * Fired when Scout's managed-task completion is inferred but the harness
      * detected suspicious signals (mutation expected but none happened, budget
@@ -1522,10 +1656,11 @@ interface KodaXEvents {
     };
     /** Tool execution hook - called before tool execution, return false to block - 工具执行前回调 */
     beforeToolExecute?: (tool: string, input: Record<string, unknown>, meta?: KodaXToolEventMeta) => Promise<boolean | string>;
-    /** Ask user a question interactively - Issue 069 - 交互式向用户提问 */
-    askUser?: (options: AskUserQuestionOptions, meta?: KodaXToolEventMeta) => Promise<string>;
+    /** Ask user a question interactively - Issue 069 - 交互式向用户提问. Multi-select
+     *  (options.multiSelect) resolves string[]; single-select resolves string. */
+    askUser?: (options: AskUserQuestionOptions, meta?: KodaXToolEventMeta) => Promise<string | string[]>;
     /** Ask user multiple independent questions sequentially - 澶氶棶棰橀『搴忔彁闂?*/
-    askUserMulti?: (options: AskUserMultiOptions, meta?: KodaXToolEventMeta) => Promise<Record<string, string> | undefined>;
+    askUserMulti?: (options: AskUserMultiOptions, meta?: KodaXToolEventMeta) => Promise<Record<string, string | string[]> | undefined>;
     /** Ask user for free-text input - 自由文本输入 (Issue 112) */
     askUserInput?: (options: {
         question: string;
@@ -1672,10 +1807,52 @@ interface KodaXTaskVerificationContract {
     requiredEvidence?: string[];
     requiredChecks?: string[];
     capabilityHints?: KodaXTaskCapabilityHint[];
-    rubricFamily?: 'code-review' | 'frontend' | 'product-completeness' | 'functionality' | 'code-quality';
+    rubricFamily?: 'code-review' | 'frontend' | 'product-completeness' | 'functionality' | 'code-quality' | 'partner-research';
     criteria?: KodaXTaskVerificationCriterion[];
     runtime?: KodaXRuntimeVerificationContract;
 }
+/**
+ * FEATURE_247 — SDK-consumer agent profile identity (e.g. KodaX-Space Partner).
+ *
+ * The SDK core treats this as OPAQUE attribution: it is echoed onto results,
+ * events, the effective-config snapshot, session runtimeInfo, and tool context
+ * so an embedder can confirm which profile actually ran and can attribute
+ * concurrent Partner/Coder sessions. Absent ⇒ the default Coding Agent, with no
+ * behavioral change anywhere.
+ *
+ * Only two fields carry behavior, both additive and gated on their own presence:
+ *   - `instructions` — on the SA path the embedder sets
+ *     `context.systemPromptOverride`; the AMA/AMAW path builds role prompts
+ *     internally, so when this is set the Worker role prompt PREPENDS this block
+ *     (absent ⇒ byte-identical default coding role prompt).
+ *   - `verification` — a profile-default verifier standard the Sidecar Verifier
+ *     applies; per-task `context.taskVerification` still overrides/augments it.
+ *
+ * Everything else (`surface`/`id`/`version`/`name`) is pure identity passthrough.
+ */
+interface KodaXAgentProfile {
+    /** Surface/profile label, e.g. `'code'` | `'partner'`. Opaque to the core. */
+    readonly surface?: string;
+    /** Stable profile id (UUID or stable name). Opaque to the core. */
+    readonly id?: string;
+    /** Profile version. Opaque to the core. */
+    readonly version?: string;
+    /** Human-facing display name. Opaque to the core. */
+    readonly name?: string;
+    /**
+     * Partner behavior instructions injected into the AMA/AMAW Worker role prompt
+     * (prepended). The SA path uses `context.systemPromptOverride` instead — this
+     * field is the AMA-path equivalent so a Partner profile behaves consistently
+     * across both execution modes.
+     */
+    readonly instructions?: string;
+    /**
+     * Profile-default verification standard. Merged with per-task
+     * `context.taskVerification` (per-task fields win) before reaching the Sidecar
+     * Verifier.
+     */
+    readonly verification?: KodaXTaskVerificationContract;
+}
 type KodaXSkillProjectionConfidence = 'high' | 'medium' | 'low';
 interface KodaXSkillInvocationContext {
     name: string;
@@ -1756,6 +1933,13 @@ interface KodaXChildContextBundle {
     model?: string;
     /** Optional per-dispatch reasoning effort. Omit to inherit the parent effort. */
     effort?: KodaXWireReasoningEffort;
+    /**
+     * FEATURE_246 Part B — optional JSON Schema (opaque) for the child's
+     * structured output. When set, the child briefing asks for a fenced JSON
+     * block matching it; the child executor parses + validates the result (with
+     * one bounded repair turn) and surfaces it on `KodaXChildAgentResult.structured`.
+     */
+    outputSchema?: unknown;
 }
 /**
  * FEATURE_120 v0.7.39 Phase 4 — model tier hint. Tier semantics:
@@ -1802,6 +1986,13 @@ interface KodaXChildAgentResult {
      * and consumed by dispatch-child-tasks' empty-summary fallback.
      */
     interrupted?: boolean;
+    /**
+     * FEATURE_246 Part B — schema-validated structured output parsed from the
+     * child's final text (present only when the bundle carried `outputSchema`
+     * and a JSON value was parseable). Surfaced to the workflow runtime as
+     * `WorkflowTaskResult.structured`.
+     */
+    structured?: unknown;
 }
 interface KodaXParentReductionContract {
     owner: 'parent';
@@ -1851,6 +2042,11 @@ interface KodaXManagedLiveEvent {
 interface KodaXManagedTaskStatusEvent {
     agentMode: KodaXAgentMode;
     harnessProfile: KodaXHarnessProfile;
+    /**
+     * FEATURE_247 — SDK-consumer agent profile driving this managed task, echoed
+     * from `options.context.agentProfile`. Absent ⇒ default Coding Agent.
+     */
+    agentProfile?: KodaXAgentProfile;
     activeWorkerId?: string;
     activeWorkerTitle?: string;
     childFanoutClass?: KodaXChildFanoutClass;
@@ -1898,6 +2094,29 @@ interface KodaXManagedTaskStatusEvent {
      */
     idleWaitingPendingCount?: number;
 }
+/**
+ * FEATURE_247 (R4) — effective managed-task configuration snapshot, emitted once
+ * at run start via {@link KodaXEvents.onEffectiveConfig} so an SDK embedder can
+ * (a) assert the intended profile actually entered the SDK managed task and
+ * (b) diagnose which tools + verification standard are in force.
+ */
+interface KodaXEffectiveTaskConfig {
+    readonly agentMode: KodaXAgentMode;
+    /** SDK-consumer profile driving the run; undefined ⇒ default Coding Agent. */
+    readonly agentProfile?: KodaXAgentProfile;
+    /** Tool names visible to the model for this run. */
+    readonly toolScope: readonly string[];
+    /**
+     * Effective verification standard reaching the Sidecar Verifier — the profile
+     * default merged with per-task `context.taskVerification` (per-task wins).
+     */
+    readonly verification?: KodaXTaskVerificationContract;
+    /** Resolved Sidecar Verifier provider/model, when the verifier is active. */
+    readonly verifier?: {
+        readonly provider?: string;
+        readonly model?: string;
+    };
+}
 interface KodaXVerificationScorecardCriterion {
     id: string;
     label: string;
@@ -1986,6 +2205,29 @@ interface ManagedMutationTracker {
     /** Set to true after scope reflection has been injected once. Prevents repeated injection. */
     reflectionInjected?: boolean;
 }
+/**
+ * FEATURE_247 (R2) — a minimal, stable per-tool view handed to a
+ * {@link KodaXToolVisibilityPolicy}. Only the load-bearing declarative metadata
+ * is exposed (never the handler / full schema) so the contract stays stable as
+ * tools evolve. `sideEffect` distinguishes readonly / reads-network /
+ * mutates-* classes; `planModeAllowed` marks query-shaped tools.
+ */
+interface KodaXToolVisibilityMeta {
+    readonly name: string;
+    readonly sideEffect: ToolSideEffect;
+    readonly planModeAllowed: boolean;
+}
+/**
+ * FEATURE_247 (R2) — an SDK-consumer predicate evaluated for every candidate
+ * tool BEFORE the model-visible tool list is built. Return `false` to hide a
+ * tool from the model. Space uses this to express profile-scoped rules such as
+ * "only readonly + reads-network visible" and to default-deny anything it does
+ * not explicitly recognize, without enumerating a name list that drifts as the
+ * SDK adds tools. Covers SDK builtin + host-registered + extension + MCP tools
+ * uniformly (each carries a required `sideEffect`). A tool with no resolvable
+ * metadata is hidden (fail-closed).
+ */
+type KodaXToolVisibilityPolicy = (tool: KodaXToolVisibilityMeta) => boolean;
 interface KodaXContextOptions {
     /** Project root used for project-scoped prompts, permissions, and path policy. */
     gitRoot?: string | null;
@@ -2048,6 +2290,13 @@ interface KodaXContextOptions {
     mutationTracker?: ManagedMutationTracker;
     /** FEATURE_067 v3: Tool names to exclude from API-level tool list (child agents). */
     excludeTools?: readonly string[];
+    /**
+     * FEATURE_247 (R2) — profile-scoped tool visibility predicate applied when the
+     * model-visible tool list is built (in addition to `excludeTools`). Tools for
+     * which it returns `false` are hidden from the model. Absent ⇒ no policy (only
+     * `excludeTools` applies) — the default Coding Agent path is unchanged.
+     */
+    toolVisibilityPolicy?: KodaXToolVisibilityPolicy;
     /**
      * FEATURE_067 v3: Override the entire system prompt for this run.
      * When set, buildSystemPromptSnapshot is skipped — only this string is used.
@@ -2058,6 +2307,13 @@ interface KodaXContextOptions {
     taskMetadata?: Record<string, KodaXJsonValue>;
     /** Optional structured verification contract carried into managed tasks. */
     taskVerification?: KodaXTaskVerificationContract;
+    /**
+     * FEATURE_247 — SDK-consumer agent profile (KodaX-Space Partner et al).
+     * Opaque identity + optional AMA-path instructions + optional default verifier
+     * standard. Absent ⇒ the default Coding Agent (no behavioral change). See
+     * {@link KodaXAgentProfile}.
+     */
+    agentProfile?: KodaXAgentProfile;
     /**
      * FEATURE_074: Plan-mode block predicate provided by the parent REPL. The predicate
      * closes over live parent state so mid-run mode toggles propagate to in-flight
@@ -2123,12 +2379,25 @@ interface KodaXContextOptions {
  * FEATURE_221 — an SDK consumer (a product built on KodaX, e.g. KodaX-Space)
  * injects its own product manual so that when ITS users ask "how do I use /
  * configure <product>?", the kodax_manual tool answers with the consumer's
- * topics. `topics` extend the KodaX base (override by id); `productName`
- * re-brands the routing rule + scope anchor. Topics are still byte-capped.
+ * topics. `topics` extend the seeded base (override by id, then append);
+ * `productName` re-brands the routing rule + scope anchor. Topics are still
+ * byte-capped.
+ *
+ * `baseTopics` controls how much of KodaX's own manual is present underneath:
+ * omit it for the default full base, `[]` for a full white-label replace, or a
+ * curated subset (e.g. `KODAX_UNDERLYING_CAPABILITY_TOPICS`) to keep only the
+ * mechanism topics a product built on KodaX inherits. For build-time docs, a
+ * consumer can import `MANUAL_REGISTRY` to read the base topic bodies directly.
  */
 interface KodaXSelfManualConfig {
     readonly productName?: string;
     readonly topics?: readonly KodaXManualTopicInput[];
+    /**
+     * Which KodaX base topics to seed before `topics` is layered on. `undefined`
+     * ⇒ all base topics (default). `[]` ⇒ none (full replace). A subset ⇒ exactly
+     * those ids. See {@link ResolveKodaXManualOptions.baseTopics}.
+     */
+    readonly baseTopics?: readonly KodaXManualTopicId[];
 }
 /**
  * SDK-consumer auto-compaction override. When a field is provided it wins
@@ -2147,6 +2416,21 @@ interface KodaXCompactionOverride {
     /** Set false to disable automatic compaction for this run. */
     enabled?: boolean;
 }
+/**
+ * FEATURE_222 skill security — host policy for a skill's `!`cmd`` dynamic-context
+ * tokens. By default (both fields unset) the LLM-triggered `skill` tool runs
+ * those commands via the built-in allowlist + `execSync` — fine for the trusted
+ * standalone CLI, but an embedder host (KodaX-Space) wants every shell touch to
+ * go through its own permission broker. Set `execute` to route each `!`cmd``
+ * through the host, or `disable: true` to refuse them outright.
+ */
+interface KodaXSkillDynamicContextPolicy {
+    /** Host hook run for each `!`cmd`` token (command, cwd) → stdout. Mediate via
+     *  the host's permission broker; throw to refuse a command. */
+    execute?: SkillDynamicContextExecutor;
+    /** When true, every `!`cmd`` token is refused without executing anything. */
+    disable?: boolean;
+}
 interface KodaXOptions {
     provider: string;
     model?: string;
@@ -2162,8 +2446,62 @@ interface KodaXOptions {
     extensionRuntime?: ExtensionRuntimeContract;
     /** FEATURE_229: host-owned policy for workflow auto-start and ceilings. */
     workflowHostPolicy?: WorkflowHostPolicy;
+    /**
+     * FEATURE_246 Part A2 (ADR-046): durable run-graph base dir for workflow runs
+     * the model launches via `run_workflow`. The host (REPL / SDK) resolves it
+     * (e.g. `getAgentConfigPath('workflow-runs', projectKey)`); when set + the
+     * agent mode is ama/amaw, the tool-execution context wires `ctx.workflowHost`.
+     */
+    workflowRunsBaseDir?: string;
+    /**
+     * M2 — per-agent model TIERS for the workflow / dispatch `model_hint`. An
+     * embedder maps the semantic tiers to concrete models; a workflow script /
+     * dispatch then expresses intent via `modelHint: 'fast' | 'deep'` (NOT a
+     * concrete model name — the authoring model has no cognition of the
+     * embedder's configured providers). 'fast' routes read-only children only
+     * (write/codegen stays on the parent — a quality guard); 'deep' routes any
+     * child; an unset tier inherits the parent provider/model. Carried run-scoped
+     * (AsyncLocalStorage) by runManagedTask so concurrent SDK sessions never
+     * clobber each other; KODAX_FAST/DEEP_PROVIDER/MODEL is the env fallback used
+     * by the CLI / config.json path.
+     */
+    modelTiers?: {
+        readonly fast?: {
+            readonly provider?: string;
+            readonly model?: string;
+        };
+        readonly deep?: {
+            readonly provider?: string;
+            readonly model?: string;
+        };
+    };
+    /**
+     * Config-surface SDK peers for settings the llm layer otherwise reads via env.
+     * Carried run-scoped (AsyncLocalStorage) by runManagedTask so concurrent SDK
+     * sessions are isolated; the KODAX_* env vars are the CLI/config.json fallback.
+     * `maxOutputTokens` caps every provider call; `disablePromptCache` turns off
+     * Anthropic prompt caching; `lsp: false` disables LSP-assisted diagnostics.
+     */
+    maxOutputTokens?: number;
+    disablePromptCache?: boolean;
+    lsp?: boolean;
+    /**
+     * Workflow engine run-scoped overrides. `maxConcurrency` caps how many child
+     * agents a `run_workflow` fans out at once (default 8, clamped to [1, 32]); the
+     * `KODAX_WORKFLOW_MAX_CONCURRENCY` env var (bridged from config.json) is the
+     * CLI fallback. Carried run-scoped so concurrent SDK sessions stay isolated.
+     */
+    workflow?: {
+        readonly maxConcurrency?: number;
+    };
     /** FEATURE_221: SDK-consumer self-manual injection (product name + topics). */
     selfManual?: KodaXSelfManualConfig;
+    /**
+     * FEATURE_222 skill security: host policy for skill `!`cmd`` dynamic-context.
+     * Absent → built-in allowlist+execSync (trusted-CLI default). See
+     * {@link KodaXSkillDynamicContextPolicy}.
+     */
+    skillDynamicContext?: KodaXSkillDynamicContextPolicy;
     /**
      * FEATURE_092 (v0.7.33): caller-supplied run-scoped guardrails forwarded
      * to `Runner.run` via `RunOptions.guardrails`. Merged with the START
@@ -2267,34 +2605,6 @@ interface KodaXTaskEvidenceArtifact {
     path: string;
     description?: string;
 }
-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;
 interface KodaXTaskEvidenceEntry {
     assignmentId: string;
     role: KodaXTaskRole;
@@ -2435,6 +2745,12 @@ interface KodaXResult {
     signalDebugReason?: string;
     messages: KodaXMessage[];
     sessionId: string;
+    /**
+     * FEATURE_247 — the agent profile this run executed under, echoed verbatim from
+     * `options.context.agentProfile`. Lets an embedder confirm the running profile
+     * was Partner (not the default Coding Agent). Absent ⇒ default Coding Agent.
+     */
+    agentProfile?: KodaXAgentProfile;
     /** Internal raw protocol output retained for artifact persistence after compacting visible failure text. */
     protocolRawText?: string;
     /** Structured managed-task protocol payload separated from visible text. */
@@ -2471,8 +2787,36 @@ interface KodaXToolExecutionContext {
     backups: Map<string, string>;
     /** Git root directory - Git 鏍圭洰褰?*/
     gitRoot?: string;
+    /**
+     * FEATURE_247 (R7) — runtime-resolved session id for the run that owns this
+     * tool call. Lets host-registered tools (Space artifact/source/KB) attribute a
+     * call to the right session when multiple Partner/Coder sessions run
+     * concurrently, without AsyncLocalStorage. Absent on paths that do not resolve
+     * a session id (e.g. isolated tool tests).
+     */
+    sessionId?: string;
+    /**
+     * FEATURE_247 (R7) — id of the LLM `tool_use` block this execution backs
+     * (same value surfaced as `KodaXToolEventMeta.toolId`). Lets a host correlate a
+     * tool handler invocation to its event stream and de-duplicate retries.
+     */
+    toolCallId?: string;
+    /**
+     * FEATURE_247 (R7) — task surface/profile label forwarded from
+     * `options.context.taskSurface`, so a tool handler can tell a Partner call from
+     * a Coder call. Absent ⇒ not set by the caller.
+     */
+    taskSurface?: KodaXTaskSurface;
+    /**
+     * FEATURE_247 (R7) — SDK-consumer agent profile owning this tool call, echoed
+     * from `options.context.agentProfile`. Absent ⇒ default Coding Agent.
+     */
+    agentProfile?: KodaXAgentProfile;
     /** FEATURE_221: SDK-consumer self-manual injection, forwarded from KodaXOptions. */
     selfManual?: KodaXSelfManualConfig;
+    /** FEATURE_222 skill security — host policy for skill `!`cmd`` dynamic-context,
+     *  forwarded from `KodaXOptions.skillDynamicContext`. Consumed by the `skill` tool. */
+    skillDynamicContext?: KodaXSkillDynamicContextPolicy;
     /** Working directory used to resolve relative paths and execute shell commands. */
     executionCwd?: string;
     /** Session-scoped directory for helper scripts and scratch outputs. */
@@ -2491,10 +2835,11 @@ interface KodaXToolExecutionContext {
     workflowWorktreeBaseDir?: string;
     /** Shared extension capability runtime used by retrieval-family tools. */
     extensionRuntime?: CapabilityRuntimeContract;
-    /** Ask user a question interactively (select mode) - 交互式向用户提问 (Issue 069) */
-    askUser?: (options: AskUserQuestionOptions) => Promise<string>;
+    /** Ask user a question interactively (select mode) - 交互式向用户提问 (Issue 069).
+     *  Multi-select resolves string[]; single-select resolves string. */
+    askUser?: (options: AskUserQuestionOptions) => Promise<string | string[]>;
     /** Ask user multiple independent questions sequentially - 澶氶棶棰橀『搴忔彁闂?*/
-    askUserMulti?: (options: AskUserMultiOptions) => Promise<Record<string, string> | undefined>;
+    askUserMulti?: (options: AskUserMultiOptions) => Promise<Record<string, string | string[]> | undefined>;
     /** Ask user for free-text input - 自由文本输入 (Issue 112) */
     askUserInput?: (options: {
         question: string;
@@ -2773,6 +3118,107 @@ interface KodaXToolExecutionContext {
      * See `packages/coding/src/goal/tools-context.ts`.
      */
     goalContext?: GoalToolsContext;
+    /**
+     * FEATURE_246 Part A2 (ADR-046): narrow capability the `run_workflow` tool
+     * uses to start a managed workflow run. Wired by tool-execution-context (via
+     * a lazy import of the coding WorkflowHost) only when the session enables it;
+     * 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 {
+    readonly kind: 'declined' | 'started';
+    /** declined: why the host/generator declined to run. */
+    readonly reason?: string;
+    /** started: the minted run id. */
+    readonly runId?: string;
+    /** started: terminal status once the run settled. */
+    readonly status?: string;
+    /** started: the run's displayable result text, when completed. */
+    readonly resultText?: string;
+    /** started: terminal error message, when failed. */
+    readonly error?: string;
+    /** started: names of child agents that completed but FAILED their sidecar
+     *  verification in warn-only mode (`agent_unverified`). The overall run still
+     *  settles as `completed`, so without surfacing these the Worker would act on
+     *  the result unaware that some verification failed. Empty/omitted = all
+     *  completed children verified (or none were verified). */
+    readonly verificationWarnings?: readonly string[];
+}
+/**
+ * Narrow ctx capability for launching workflows from a tool. Intentionally free
+ * of any workflow-layer type import (keeps `types.ts` dependency-light); the
+ * concrete implementation lives behind a lazy import in tool-execution-context.
+ */
+interface WorkflowToolHostInlineInput {
+    readonly manifest: unknown;
+    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.
+     */
+    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. */
+type WorkflowToolHostStartResult = {
+    readonly kind: 'declined';
+    readonly reason?: string;
+} | {
+    readonly kind: 'started';
+    readonly runId: string;
+    readonly done: Promise<WorkflowToolHostResult>;
+    /** 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.
+     *  `resumeFromRunId` (FEATURE_246 Part D) seeds the result cache from a prior
+     *  run so unchanged effects replay and only changed ones re-run live. */
+    runInline(input: WorkflowToolHostInlineInput): Promise<WorkflowToolHostResult>;
+    /** ADR-049: start the workflow and return immediately with a `done` promise,
+     *  without blocking the calling turn. The async/idle-yield run_workflow path uses
+     *  this; `runInline` is just `startInline` + `await done`. */
+    startInline(input: WorkflowToolHostInlineInput): Promise<WorkflowToolHostStartResult>;
 }
 
 /**
@@ -2924,5 +3370,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { BASH_POLICY_SPEC as B, extractCommandPrefix as a$, buildGoalRuntimeBinding as aY, createBashPrefixExtractor as aZ, decideWorkflowInvocation as a_, LSP_SERVERS as aw, LspService as ay, getDefaultLspService as b0, makeDisabledGoalToolsContext as b1, parseTimeoutSecEnvMs as b2, providerResilienceConfigFromTimeouts as b3, shutdownDefaultLspService as b4, timeoutSecToMs as b5, withGoalBeforeNextTurn as b6, withGoalStopHook as b7, workflowStartOutcomeConsumesTurn as b8 };
-export type { KodaXResult as $, KodaXInputArtifactSource as A, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXLlmTimeoutConfig as H, KodaXManagedBudgetSnapshot as I, KodaXManagedProtocolPayload as J, KodaXActivityEventMeta as K, KodaXManagedTask as L, KodaXManagedTaskRuntimeState as M, KodaXManagedTaskStatusEvent as N, KodaXManualTopicId as O, KodaXManualTopicInput as P, KodaXMemoryStrategy as Q, KodaXOptions as R, KodaXOrchestrationVerdict as S, KodaXParentReductionContract as T, KodaXProviderPolicyHints as U, KodaXRepoIntelligenceCapability as V, KodaXRepoIntelligenceMode as W, KodaXRepoIntelligenceResolvedMode as X, KodaXRepoIntelligenceTrace as Y, KodaXRepoIntelligenceTraceEvent as Z, KodaXRepoRoutingSignals as _, BashPrefixExtractor as a, KodaXRoleRoundSummary as a0, KodaXRuntimeVerificationContract as a1, KodaXSelfManualConfig as a2, KodaXSessionControl as a3, KodaXSessionMutators as a4, KodaXSessionOptions as a5, KodaXSidecarMessageEvent as a6, KodaXSkillInvocationContext as a7, KodaXSkillMap as a8, KodaXSkillProjectionConfidence as a9, ProviderExecutionState as aA, ProviderRecoveryEvent as aB, ProviderResilienceConfig as aC, ProviderResiliencePolicy as aD, RecoveryAction as aE, RecoveryDecision as aF, RecoveryLadderStep as aG, RecoveryResult as aH, ResilienceClassification as aI, ResilienceErrorClass as aJ, ResolveKodaXManualInput as aK, ResolveKodaXManualOptions as aL, ResolveKodaXManualResult as aM, RuntimeDefaultsSnapshot as aN, TodoItem as aO, TodoList as aP, TodoStatus as aQ, WorkflowHostPolicy as aR, WorkflowInvocationAction as aS, WorkflowInvocationPolicyDecision as aT, WorkflowInvocationPolicyInput as aU, WorkflowInvocationSource as aV, WorkflowInvocationTrigger as aW, WorkflowStartOutcome as aX, KodaXTaskCapabilityHint as aa, KodaXTaskContract as ab, KodaXTaskEvidenceArtifact as ac, KodaXTaskEvidenceBundle as ad, KodaXTaskEvidenceEntry as ae, KodaXTaskRole as af, KodaXTaskRoleAssignment as ag, KodaXTaskStatus as ah, KodaXTaskSurface as ai, KodaXTaskToolPolicy as aj, KodaXTaskVerificationContract as ak, KodaXTaskVerificationCriterion as al, KodaXTaskWorkItem as am, KodaXTimeoutConfig as an, KodaXToolEventMeta as ao, KodaXToolExecutionContext as ap, KodaXVerificationScorecard as aq, KodaXVerificationScorecardCriterion as ar, KodaXVideoInputArtifact as as, KodaXVideoMediaType as at, KodaXWorkflowEventMeta as au, KodaXWorkflowTimeoutConfig as av, LspServerInfo as ax, LspServiceConfig as az, BashPrefixResult as b, BoundExtensionRuntimeController as c, ChildSnapshotEvent as d, CreateBashPrefixExtractorOptions as e, ExtractCommandPrefixOptions as f, GoalCompleteResult as g, GoalCreateInput as h, GoalLifecycleContext as i, GoalRuntimeBinding as j, GoalRuntimeBindingDeps as k, GoalToolsContext as l, KodaXAgentMode as m, KodaXBudgetDisclosureZone as n, KodaXBudgetExtensionRequest as o, KodaXChildAgentResult as p, KodaXChildContextBundle as q, KodaXChildExecutionResult as r, KodaXCompactionOverride as s, KodaXContextOptions as t, KodaXContextTokenSnapshot as u, KodaXEvents as v, KodaXFileInputArtifact as w, KodaXImageInputArtifact as x, KodaXImageMediaType as y, KodaXInputArtifact as z };
+export { BASH_POLICY_SPEC as B, LSP_SERVERS as aw, LspService as ay, buildGoalRuntimeBinding as b1, createBashPrefixExtractor as b2, decideWorkflowInvocation as b3, extractCommandPrefix as b4, getDefaultLspService as b5, makeDisabledGoalToolsContext as b6, providerResilienceConfigFromTimeouts as b7, shutdownDefaultLspService as b8, withGoalBeforeNextTurn as b9, withGoalStopHook as ba, workflowStartOutcomeConsumesTurn as bb };
+export type { KodaXRuntimeVerificationContract as $, KodaXManagedTask as A, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXManagedTaskRuntimeState as H, KodaXManagedTaskStatusEvent as I, KodaXManualSource as J, KodaXActivityEventMeta as K, KodaXManualTopic as L, KodaXManualTopicId as M, KodaXManualTopicInput as N, KodaXMemoryStrategy as O, KodaXOptions as P, KodaXOrchestrationVerdict as Q, KodaXParentReductionContract as R, KodaXProviderPolicyHints as S, KodaXRepoIntelligenceCapability as T, KodaXRepoIntelligenceMode as U, KodaXRepoIntelligenceResolvedMode as V, KodaXRepoIntelligenceTrace as W, KodaXRepoIntelligenceTraceEvent as X, KodaXRepoRoutingSignals as Y, KodaXResult as Z, KodaXRoleRoundSummary as _, BashPrefixExtractor as a, WorkflowToolHostResult as a$, KodaXSelfManualConfig as a0, KodaXSessionControl as a1, KodaXSessionMutators as a2, KodaXSessionOptions as a3, KodaXSidecarMessageEvent as a4, KodaXSkillDynamicContextPolicy as a5, KodaXSkillInvocationContext as a6, KodaXSkillMap as a7, KodaXSkillProjectionConfidence as a8, KodaXTaskCapabilityHint as a9, ProviderExecutionState as aA, ProviderRecoveryEvent as aB, ProviderResilienceConfig as aC, ProviderResiliencePolicy as aD, RecoveryAction as aE, RecoveryDecision as aF, RecoveryLadderStep as aG, RecoveryResult as aH, ResilienceClassification as aI, ResilienceErrorClass as aJ, ResolveKodaXManualInput as aK, ResolveKodaXManualOptions as aL, ResolveKodaXManualResult as aM, RuntimeDefaultsSnapshot as aN, TodoItem as aO, TodoList as aP, TodoStatus as aQ, ToolSideEffect as aR, WorkflowHostPolicy as aS, WorkflowInvocationAction as aT, WorkflowInvocationPolicyDecision as aU, WorkflowInvocationPolicyInput as aV, WorkflowInvocationSource as aW, WorkflowRunProgressView as aX, WorkflowStartOutcome as aY, WorkflowToolHost as aZ, WorkflowToolHostInlineInput as a_, KodaXTaskContract as aa, KodaXTaskEvidenceArtifact as ab, KodaXTaskEvidenceBundle as ac, KodaXTaskEvidenceEntry as ad, KodaXTaskRole as ae, KodaXTaskRoleAssignment as af, KodaXTaskStatus as ag, KodaXTaskSurface as ah, KodaXTaskToolPolicy as ai, KodaXTaskVerificationContract as aj, KodaXTaskVerificationCriterion as ak, KodaXTaskWorkItem as al, KodaXTimeoutConfig as am, KodaXToolEventMeta as an, KodaXToolExecutionContext as ao, KodaXToolVisibilityMeta as ap, KodaXToolVisibilityPolicy as aq, KodaXVerificationScorecard as ar, KodaXVerificationScorecardCriterion as as, KodaXWorkflowAgentDigestEvent as at, KodaXWorkflowEventMeta as au, KodaXWorkflowTimeoutConfig as av, LspServerInfo as ax, LspServiceConfig as az, BashPrefixResult as b, WorkflowToolHostStartResult as b0, BoundExtensionRuntimeController as c, ChildSnapshotEvent as d, CreateBashPrefixExtractorOptions as e, ExtractCommandPrefixOptions as f, GoalCompleteResult as g, GoalCreateInput as h, GoalLifecycleContext as i, GoalRuntimeBinding as j, GoalRuntimeBindingDeps as k, GoalToolsContext as l, KodaXAgentMode as m, KodaXAgentProfile as n, KodaXBudgetDisclosureZone as o, KodaXBudgetExtensionRequest as p, KodaXChildAgentResult as q, KodaXChildContextBundle as r, KodaXChildExecutionResult as s, KodaXCompactionOverride as t, KodaXContextOptions as u, KodaXContextTokenSnapshot as v, KodaXEffectiveTaskConfig as w, KodaXEvents as x, KodaXManagedBudgetSnapshot as y, KodaXManagedProtocolPayload as z };