@kodax-ai/kodax 0.7.56 → 0.7.58

package/dist/types-chunks/{bash-prefix-extractor.d-DZF1gDDz.d.ts → bash-prefix-extractor.d-D3cddmyV.d.ts}

@@ -1,9 +1,9 @@
-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-BdiIUr8T.js';
-import { X as KodaXTokenUsage, E as KodaXReasoningMode, n as KodaXMessage, k as KodaXHarnessProfile, S as KodaXTaskWorkIntent, I as KodaXReviewScale, O as KodaXTaskComplexity, a as KodaXAmaFanoutClass, Q as KodaXTaskRoutingDecision, R as KodaXTaskType, J as KodaXRiskLevel, i as KodaXExecutionMode, c as KodaXAmaProfile, d as KodaXAmaTactic, b as KodaXAmaFanoutPolicy } from './types.d-BJmoMf5H.js';
-import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation } from 'vscode-languageserver-protocol';
+import { W as KodaXGoalState, g as AgentMessage, b8 as StopHookFn, aa as KodaXSessionLineage, a0 as KodaXJsonValue, Q as KodaXExtensionSessionRecord, af as KodaXSessionScope, ag as KodaXSessionStorage, R as KodaXExtensionSessionState, _ 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, bw as WorkflowIsolation, a2 as KodaXSessionArtifactLedgerEntry, aV as SessionErrorMetadata, w as DiscoveredInstance, bc as TaskAbortRegistry } from './process.d-DHow2y2G.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-Ci5YPFEh.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-CwPfI8WQ.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 +408,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;
@@ -524,6 +539,16 @@ interface LspClient {
     references(file: string, position: Position): Promise<Location[]>;
     /** The document's symbol outline. */
     documentSymbols(file: string): Promise<Array<DocumentSymbol | SymbolInformation>>;
+    /** Project-wide symbols matching a query string. */
+    workspaceSymbols(query: string): Promise<Array<SymbolInformation | WorkspaceSymbol>>;
+    /** Implementation site(s) of the symbol at a position. */
+    implementation(file: string, position: Position): Promise<Location[]>;
+    /** Prepare the call hierarchy item(s) for a symbol at a position. */
+    prepareCallHierarchy(file: string, position: Position): Promise<CallHierarchyItem[]>;
+    /** Incoming callers for a prepared call hierarchy item. */
+    incomingCalls(item: CallHierarchyItem): Promise<CallHierarchyIncomingCall[]>;
+    /** Outgoing callees for a prepared call hierarchy item. */
+    outgoingCalls(item: CallHierarchyItem): Promise<CallHierarchyOutgoingCall[]>;
     /** Graceful shutdown (await server exit so the OS releases handles). */
     shutdown(): Promise<void>;
     /** Synchronous best-effort kill, for a `process.on('exit')` last resort. */
@@ -596,6 +621,16 @@ declare class LspService {
     getReferences(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
     /** The file's symbol outline, as indented text. */
     getDocumentSymbols(file: string, request?: DiagnosticsRequest): Promise<string>;
+    /** Project-wide symbols matching `query`, across all available language servers. */
+    getWorkspaceSymbols(query: string, request?: DiagnosticsRequest): Promise<string>;
+    /** Implementation site(s) of the symbol at `position` (0-based), as text. */
+    getImplementation(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** Prepared call hierarchy item(s) for the symbol at `position` (0-based). */
+    getPrepareCallHierarchy(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** Incoming callers of the symbol at `position` (0-based). */
+    getIncomingCalls(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** Outgoing callees of the symbol at `position` (0-based). */
+    getOutgoingCalls(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
     /**
      * Resolve the primary client for a navigation request, opening the file so
      * the server has current content. Returns guidance text when no server is
@@ -603,6 +638,7 @@ declare class LspService {
      * NOT silent), or an unsupported message for non-LSP file types.
      */
     private navClient;
+    private workspaceClients;
     /** Shut down all spawned servers gracefully (call on session teardown). */
     shutdownAll(): Promise<void>;
     /** Synchronous best-effort kill of all servers — for `process.on('exit')`. */
@@ -879,6 +915,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;
@@ -903,10 +955,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'. */
@@ -918,64 +984,6 @@ interface ResolveKodaXManualResult {
     readonly nextTopics: readonly string[];
 }
 
-/**
- * FEATURE_093 (v0.7.24): minimal contract interfaces for the coding extension
- * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
- * extension runtime at the type level without importing `./extensions/runtime.js`,
- * which in turn imports from `types.ts` — a cycle that lasted since v0.7.20.
- *
- * Scope: the capability methods that tool execution consumes, plus optional
- * session lifecycle hooks that the coding run loop uses when the runtime
- * supports them.
- *
- * File must have NO imports from `../types.js` (that is the cycle we are
- * breaking). Shared capability/session value types come from `@kodax-ai/agent`.
- */
-
-interface ExtensionRuntimeModelSelection {
-    provider?: string;
-    model?: string;
-}
-interface RuntimeDefaultsSnapshot {
-    activeTools?: string[];
-    modelSelection: ExtensionRuntimeModelSelection;
-    thinkingLevel?: KodaXReasoningMode;
-}
-interface BoundExtensionRuntimeController {
-    queueUserMessage(message: string | KodaXMessage): void;
-    getSessionState<T = KodaXJsonValue>(extensionId: string, key: string): T | undefined;
-    setSessionState(extensionId: string, key: string, value: KodaXJsonValue | undefined): void;
-    getSessionStateSnapshot(extensionId: string): Record<string, KodaXJsonValue>;
-    appendSessionRecord(extensionId: string, type: string, data?: KodaXJsonValue, options?: {
-        dedupeKey?: string;
-    }): KodaXExtensionSessionRecord;
-    listSessionRecords(extensionId: string, type?: string): KodaXExtensionSessionRecord[];
-    clearSessionRecords(extensionId: string, type?: string): number;
-    getActiveTools(): string[];
-    setActiveTools(toolNames: string[]): void;
-    getModelSelection(): ExtensionRuntimeModelSelection;
-    setModelSelection(next: ExtensionRuntimeModelSelection): void;
-    getThinkingLevel(): KodaXReasoningMode | undefined;
-    setThinkingLevel(level: KodaXReasoningMode): void;
-}
-interface CapabilityRuntimeContract {
-    searchCapabilities(providerId: string, query: string, options?: {
-        kind?: CapabilityKind;
-        limit?: number;
-        server?: string;
-    }): Promise<unknown[]>;
-    describeCapability(providerId: string, capabilityId: string): Promise<unknown>;
-    executeCapability(providerId: string, capabilityId: string, input: Record<string, unknown>): Promise<CapabilityResult>;
-    readCapability(providerId: string, capabilityId: string, options?: Record<string, unknown>): Promise<CapabilityResult>;
-    getCapabilityPrompt(providerId: string, capabilityId: string, args?: Record<string, unknown>): Promise<unknown>;
-    getCapabilityPromptContext(providerId: string): Promise<string | undefined>;
-}
-interface ExtensionRuntimeContract extends CapabilityRuntimeContract {
-    getDefaults?(): RuntimeDefaultsSnapshot;
-    bindController?(controller: BoundExtensionRuntimeController): (() => void) | void;
-    hydrateSession?(sessionId: string): Promise<void>;
-}
-
 /**
  * KodaX Provider Resilience Types (Feature 045)
  *
@@ -1107,6 +1115,130 @@ interface ProviderResiliencePolicy extends ProviderResilienceConfig {
     provider: string;
 }
 
+interface KodaXWorkflowTimeoutConfig {
+    /** Workflow harness generation LLM call timeout, in seconds. Default 120s. */
+    readonly generationTimeoutSec?: number;
+}
+/**
+ * Public timeout budgets for user-facing waits. Internal cleanup and
+ * resource-protection watchdogs intentionally stay outside this SDK contract.
+ */
+interface KodaXTimeoutConfig {
+    readonly llm?: KodaXLlmTimeoutConfig;
+    readonly workflow?: KodaXWorkflowTimeoutConfig;
+}
+declare function providerResilienceConfigFromTimeouts(timeouts: KodaXTimeoutConfig | undefined): ProviderResilienceConfig | undefined;
+
+/**
+ * FEATURE_093 (v0.7.24): minimal contract interfaces for the coding extension
+ * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
+ * extension runtime at the type level without importing `./extensions/runtime.js`,
+ * which in turn imports from `types.ts` — a cycle that lasted since v0.7.20.
+ *
+ * Scope: the capability methods that tool execution consumes, plus optional
+ * session lifecycle hooks that the coding run loop uses when the runtime
+ * supports them.
+ *
+ * File must have NO imports from `../types.js` (that is the cycle we are
+ * breaking). Shared capability/session value types come from `@kodax-ai/agent`.
+ */
+
+interface ExtensionRuntimeModelSelection {
+    provider?: string;
+    model?: string;
+}
+interface RuntimeDefaultsSnapshot {
+    activeTools?: string[];
+    modelSelection: ExtensionRuntimeModelSelection;
+    thinkingLevel?: KodaXWireReasoningEffort;
+}
+interface BoundExtensionRuntimeController {
+    queueUserMessage(message: string | KodaXMessage): void;
+    getSessionState<T = KodaXJsonValue>(extensionId: string, key: string): T | undefined;
+    setSessionState(extensionId: string, key: string, value: KodaXJsonValue | undefined): void;
+    getSessionStateSnapshot(extensionId: string): Record<string, KodaXJsonValue>;
+    appendSessionRecord(extensionId: string, type: string, data?: KodaXJsonValue, options?: {
+        dedupeKey?: string;
+    }): KodaXExtensionSessionRecord;
+    listSessionRecords(extensionId: string, type?: string): KodaXExtensionSessionRecord[];
+    clearSessionRecords(extensionId: string, type?: string): number;
+    getActiveTools(): string[];
+    setActiveTools(toolNames: string[]): void;
+    getModelSelection(): ExtensionRuntimeModelSelection;
+    setModelSelection(next: ExtensionRuntimeModelSelection): void;
+    getThinkingLevel(): KodaXWireReasoningEffort | undefined;
+    setThinkingLevel(level: KodaXWireReasoningEffort): void;
+}
+interface CapabilityRuntimeContract {
+    searchCapabilities(providerId: string, query: string, options?: {
+        kind?: CapabilityKind;
+        limit?: number;
+        server?: string;
+    }): Promise<unknown[]>;
+    describeCapability(providerId: string, capabilityId: string): Promise<unknown>;
+    executeCapability(providerId: string, capabilityId: string, input: Record<string, unknown>): Promise<CapabilityResult>;
+    readCapability(providerId: string, capabilityId: string, options?: Record<string, unknown>): Promise<CapabilityResult>;
+    getCapabilityPrompt(providerId: string, capabilityId: string, args?: Record<string, unknown>): Promise<unknown>;
+    getCapabilityPromptContext(providerId: string): Promise<string | undefined>;
+}
+interface ExtensionRuntimeContract extends CapabilityRuntimeContract {
+    getDefaults?(): RuntimeDefaultsSnapshot;
+    bindController?(controller: BoundExtensionRuntimeController): (() => void) | void;
+    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
@@ -1203,12 +1335,11 @@ type TodoList = readonly TodoItem[];
  * from types.ts. Self-contained; re-exported from ../types.ts (and 4 members
  * re-imported there for internal use). `../types` importers unaffected.
  */
-type KodaXRepoIntelligenceMode = 'auto' | 'off' | 'oss' | 'premium-shared' | 'premium-native';
-type KodaXRepoIntelligenceResolvedMode = 'off' | 'oss' | 'premium-shared' | 'premium-native';
+type KodaXRepoIntelligenceMode = 'auto' | 'off' | 'light' | 'full';
+type KodaXRepoIntelligenceResolvedMode = 'off' | 'light' | 'full';
 interface KodaXRepoIntelligenceCapability {
     mode: KodaXRepoIntelligenceResolvedMode;
-    engine: 'oss' | 'premium';
-    bridge: 'none' | 'shared' | 'native';
+    engine: 'light' | 'full';
     level: 'basic' | 'enhanced';
     status: 'ok' | 'limited' | 'unavailable' | 'warming';
     warnings: string[];
@@ -1216,12 +1347,9 @@ interface KodaXRepoIntelligenceCapability {
 }
 interface KodaXRepoIntelligenceTrace {
     mode: KodaXRepoIntelligenceResolvedMode;
-    engine: 'oss' | 'premium';
-    bridge: 'none' | 'shared' | 'native';
+    engine: 'light' | 'full';
     triggeredAt: string;
-    source: 'fallback' | 'premium';
-    daemonLatencyMs?: number;
-    cliLatencyMs?: number;
+    source: 'light' | 'full';
     cacheHit?: boolean;
     capsuleBytes?: number;
     capsuleEstimatedTokens?: number;
@@ -1259,6 +1387,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;
@@ -1272,6 +1422,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';
@@ -1377,8 +1538,7 @@ interface KodaXEvents {
      * Fires whenever a provider's `withRateLimit` loop catches a 429 /
      * 503 / 529 (overloaded) response and decides to wait before
      * retrying. Supersedes the legacy `onProviderRateLimit` (kept for
-     * back-compat) by carrying the parsed source of the wait duration —
-     * UI layers (InkREPL spinner, cost tracker) can surface the
+     * back-compat) by carrying the parsed source of the wait duration —   * UI layers (InkREPL spinner, cost tracker) can surface the
      * difference between "provider told us to wait 45s" and "no header,
      * we're guessing 4s exp-backoff".
      *
@@ -1396,6 +1556,17 @@ interface KodaXEvents {
         attempt: number;
         maxAttempts: number;
     }, meta?: KodaXActivityEventMeta) => void;
+    /**
+     * 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;
+        model: string;
+        effort: string;
+    }) => void;
     onRepoIntelligenceTrace?: (event: KodaXRepoIntelligenceTraceEvent) => void;
     /**
      * Fired when the Sidecar Verifier produces an actionable message.
@@ -1429,8 +1600,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
@@ -1468,10 +1655,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 multiple independent questions sequentially - 多问题顺序提问 */
-    askUserMulti?: (options: AskUserMultiOptions, meta?: KodaXToolEventMeta) => Promise<Record<string, string> | undefined>;
+    /** 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 | string[]> | undefined>;
     /** Ask user for free-text input - 自由文本输入 (Issue 112) */
     askUserInput?: (options: {
         question: string;
@@ -1618,10 +1806,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;
@@ -1659,7 +1889,7 @@ interface KodaXTaskToolPolicy {
 }
 interface KodaXChildContextBundle {
     id: string;
-    fanoutClass: KodaXAmaFanoutClass;
+    fanoutClass: KodaXChildFanoutClass;
     objective: string;
     scopeSummary?: string;
     evidenceRefs: string[];
@@ -1700,6 +1930,15 @@ interface KodaXChildContextBundle {
      */
     provider?: string;
     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:
@@ -1714,7 +1953,7 @@ interface KodaXChildContextBundle {
 type KodaXChildModelHint = 'fast' | 'balanced' | 'deep';
 interface KodaXChildAgentResult {
     childId: string;
-    fanoutClass: KodaXAmaFanoutClass;
+    fanoutClass: KodaXChildFanoutClass;
     status: 'completed' | 'blocked' | 'failed';
     disposition: 'candidate' | 'valid' | 'false-positive' | 'needs-more-evidence';
     summary: string;
@@ -1746,6 +1985,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';
@@ -1767,46 +2013,6 @@ interface KodaXChildFinding {
     readonly evidence: readonly string[];
     readonly artifacts: readonly string[];
 }
-interface KodaXFanoutSchedulerInput {
-    profile: KodaXAmaProfile;
-    fanoutClass: KodaXAmaFanoutClass;
-    maxChildren?: number;
-    bundles: KodaXChildContextBundle[];
-    reductionStrategy: KodaXParentReductionContract['strategy'];
-}
-type KodaXFanoutBranchLifecycle = 'scheduled' | 'deferred' | 'completed' | 'cancelled';
-interface KodaXFanoutBranchRecord {
-    bundleId: string;
-    status: KodaXFanoutBranchLifecycle;
-    workerId?: string;
-    childId?: string;
-    reason?: string;
-}
-type KodaXFanoutBranchTransition = {
-    type: 'assign';
-    bundleId: string;
-    workerId: string;
-} | {
-    type: 'complete';
-    bundleId: string;
-    childId?: string;
-} | {
-    type: 'cancel';
-    bundleId: string;
-    reason: string;
-};
-interface KodaXFanoutSchedulerPlan {
-    enabled: boolean;
-    profile: KodaXAmaProfile;
-    fanoutClass: KodaXAmaFanoutClass;
-    branches: KodaXFanoutBranchRecord[];
-    scheduledBundleIds: string[];
-    deferredBundleIds: string[];
-    maxParallel: number;
-    mergeStrategy: KodaXParentReductionContract['strategy'];
-    cancellationPolicy: 'none' | 'winner-cancel' | 'budget-cancel';
-    reason: string;
-}
 type KodaXAgentMode = 'ama' | 'sa' | 'amaw';
 type KodaXMemoryStrategy = 'continuous' | 'compact' | 'reset-handoff';
 type KodaXBudgetDisclosureZone = 'green' | 'yellow' | 'orange' | 'red';
@@ -1835,9 +2041,14 @@ 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?: KodaXAmaFanoutClass;
+    childFanoutClass?: KodaXChildFanoutClass;
     childFanoutCount?: number;
     currentRound?: number;
     maxRounds?: number;
@@ -1878,11 +2089,33 @@ interface KodaXManagedTaskStatusEvent {
      * can tell how many outstanding pieces of work are pending. 0 with
      * `idleWaiting=true` is the transitional "background banner queued,
      * registry already drained" state (fast-child race recovery path,
-     * see FEATURE_155 hotfix follow-up #2) and renders as "idle —
-     * resuming".
+     * see FEATURE_155 hotfix follow-up #2) and renders as "idle —   * resuming".
      */
     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;
@@ -1944,13 +2177,56 @@ interface KodaXManagedBudgetSnapshot {
     extensionDenied?: boolean;
     extensionReason?: string;
 }
-/** Mutable tracker for Scout mutation scope — shared between worker events and protocol tool. */
+/** Mutable tracker for filesystem/shell mutations observed during managed Worker execution. */
 interface ManagedMutationTracker {
     readonly files: Map<string, number>;
     totalOps: number;
+    /**
+     * Count of high-risk shell mutations (git push/commit/rm, npm install/publish,
+     * rm/mv/cp, etc.) the Worker ran via `bash`. Tracked separately from `totalOps`
+     * because bash writes are a blind spot — we cannot know which file / how many
+     * lines a shell command touched — so the Verifier gate fires conservatively on
+     * any risky shell op rather than inferring risk back out of `totalOps`.
+     * Optional: defaults to 0 when absent (read as `riskyShellOps ?? 0`).
+     */
+    riskyShellOps?: number;
+    /**
+     * Count of filesystem mutations whose touched file could NOT be attributed
+     * from the tool input (the path is computed inside the handler): `undo`,
+     * `worktree_create` / `worktree_remove`, `stage_construction` /
+     * `stage_agent_construction`, or `stage_self_modify`. These bump `totalOps`
+     * but leave `files` empty,
+     * so without a separate count they would look like trivial no-op work to the
+     * Verifier gate. Like `riskyShellOps`, an unattributable write is a blind spot
+     * the gate fires on conservatively. Optional: read as `unattributedWriteOps ?? 0`.
+     */
+    unattributedWriteOps?: number;
     /** 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;
@@ -1982,8 +2258,7 @@ interface KodaXContextOptions {
     /**
      * FEATURE_087/088 (v0.7.28): when true, the prompt builder injects a
      * Tool Construction section that orients the LLM to the
-     * scaffold_tool → validate_tool → stage_construction → test_tool →
-     * activate_tool staircase. Off by default; the surrounding agent (REPL
+     * scaffold_tool → validate_tool → stage_construction → test_tool →   * activate_tool staircase. Off by default; the surrounding agent (REPL
      * config or task router) flips this on when self-construction is
      * authorized for the session. The corresponding builtin tool handlers
      * are still gated independently by the active-tool set.
@@ -2014,6 +2289,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.
@@ -2024,6 +2306,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
@@ -2089,12 +2378,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
@@ -2117,6 +2419,7 @@ interface KodaXOptions {
     provider: string;
     model?: string;
     modelOverride?: string;
+    effort?: KodaXWireReasoningEffort;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
     agentMode?: KodaXAgentMode;
@@ -2127,6 +2430,54 @@ 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;
     /**
@@ -2156,6 +2507,12 @@ interface KodaXOptions {
      * and `~/.kodax/config.json`. See {@link KodaXCompactionOverride}.
      */
     compaction?: KodaXCompactionOverride;
+    /**
+     * SDK-consumer timeout budgets for user-facing waits. Values are seconds at
+     * the public API boundary; KodaX converts them to milliseconds internally.
+     * This does not control internal cleanup/resource-protection watchdogs.
+     */
+    timeouts?: KodaXTimeoutConfig;
 }
 /**
  * Low-level mutators handed to a `KodaXSessionControl` by the substrate.
@@ -2226,16 +2583,6 @@ interface KodaXTaskEvidenceArtifact {
     path: string;
     description?: string;
 }
-type KodaXImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
-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;
-}
-type KodaXInputArtifact = KodaXImageInputArtifact;
 interface KodaXTaskEvidenceEntry {
     assignmentId: string;
     role: KodaXTaskRole;
@@ -2265,14 +2612,9 @@ interface KodaXOrchestrationVerdict {
     disposition?: 'complete' | 'blocked' | 'needs_continuation';
 }
 interface KodaXManagedTaskRuntimeState {
-    amaProfile?: KodaXAmaProfile;
-    amaTactics?: KodaXAmaTactic[];
-    amaFanout?: KodaXAmaFanoutPolicy;
-    amaControllerReason?: string;
     childContextBundles?: KodaXChildContextBundle[];
     childAgentResults?: KodaXChildAgentResult[];
     parentReductionContract?: KodaXParentReductionContract;
-    fanoutSchedulerPlan?: KodaXFanoutSchedulerPlan;
     budget?: KodaXManagedBudgetSnapshot;
     scorecard?: KodaXVerificationScorecard;
     qualityAssuranceMode?: 'required' | 'optional';
@@ -2327,8 +2669,7 @@ interface KodaXManagedTask {
     runtime?: KodaXManagedTaskRuntimeState;
 }
 interface KodaXManagedVerdictPayload {
-    /** FEATURE_184 (v0.7.45): `'sidecar'` is the new architectural source —
-     *  Sidecar Verifier replaces the in-chain Evaluator role. `'evaluator'`
+    /** FEATURE_184 (v0.7.45): `'sidecar'` is the new architectural source —   *  Sidecar Verifier replaces the in-chain Evaluator role. `'evaluator'`
      *  / `'worker'` are retained for backward-compat reads of session jsonl
      *  written before v0.7.45. New writes use `'sidecar'`. */
     source: 'evaluator' | 'worker' | 'sidecar';
@@ -2382,6 +2723,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. */
@@ -2416,8 +2763,33 @@ interface KodaXResult {
 interface KodaXToolExecutionContext {
     /** File backups for undo functionality - 文件备份用于撤销功能 */
     backups: Map<string, string>;
-    /** Git root directory - Git 根目录 */
+    /** 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;
     /** Working directory used to resolve relative paths and execute shell commands. */
@@ -2438,10 +2810,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 multiple independent questions sequentially - 多问题顺序提问 */
-    askUserMulti?: (options: AskUserMultiOptions) => Promise<Record<string, string> | undefined>;
+    /** 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 | string[]> | undefined>;
     /** Ask user for free-text input - 自由文本输入 (Issue 112) */
     askUserInput?: (options: {
         question: string;
@@ -2482,6 +2855,9 @@ interface KodaXToolExecutionContext {
         readonly provider: string;
         readonly model?: string;
         readonly reasoningMode?: KodaXReasoningMode;
+        readonly effort?: KodaXWireReasoningEffort;
+        readonly repoIntelligenceMode?: KodaXRepoIntelligenceMode;
+        readonly repoIntelligenceTrace?: boolean;
     };
     /**
      * Parent SDK/REPL callback surface available to child-dispatch tools.
@@ -2562,7 +2938,6 @@ interface KodaXToolExecutionContext {
      * child's `Runner.run` via `KodaXOptions.guardrails`. Sharing the SAME
      * guardrail instance means the auto-mode `engine` + `denialTracker` +
      * `circuitBreaker` state is observed across the parent/child boundary —
-     * design doc "防绕阈值" defense (a child can't escape the parent's
      * rate-limit by hitting the threshold from a fresh tracker).
      *
      * Single-process / single-thread execution makes the shared mutable state
@@ -2718,6 +3093,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>;
 }
 
 /**
@@ -2869,5 +3345,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { BASH_POLICY_SPEC as B, getDefaultLspService as a$, buildGoalRuntimeBinding as aX, createBashPrefixExtractor as aY, decideWorkflowInvocation as aZ, extractCommandPrefix as a_, LSP_SERVERS as av, LspService as ax, makeDisabledGoalToolsContext as b0, shutdownDefaultLspService as b1, withGoalBeforeNextTurn as b2, withGoalStopHook as b3, workflowStartOutcomeConsumesTurn as b4 };
-export type { KodaXRepoIntelligenceTrace as $, KodaXFanoutSchedulerPlan as A, CapabilityRuntimeContract as C, DiagnosticsRequest as D, ExtensionRuntimeContract as E, FailureStage as F, GoalBlockedResult as G, KodaXImageInputArtifact as H, KodaXImageMediaType as I, KodaXInputArtifact as J, KodaXActivityEventMeta as K, KodaXInputArtifactSource as L, KodaXManagedBudgetSnapshot as M, KodaXManagedProtocolPayload as N, KodaXManagedTask as O, KodaXManagedTaskRuntimeState as P, KodaXManagedTaskStatusEvent as Q, KodaXManualTopicId as R, KodaXManualTopicInput as S, KodaXMemoryStrategy as T, KodaXOptions as U, KodaXOrchestrationVerdict as V, KodaXParentReductionContract as W, KodaXProviderPolicyHints as X, KodaXRepoIntelligenceCapability as Y, KodaXRepoIntelligenceMode as Z, KodaXRepoIntelligenceResolvedMode as _, BashPrefixExtractor as a, KodaXRepoIntelligenceTraceEvent as a0, KodaXRepoRoutingSignals as a1, KodaXResult as a2, KodaXRoleRoundSummary as a3, KodaXRuntimeVerificationContract as a4, KodaXSelfManualConfig as a5, KodaXSessionControl as a6, KodaXSessionMutators as a7, KodaXSessionOptions as a8, KodaXSidecarMessageEvent as a9, ProviderRecoveryEvent as aA, ProviderResilienceConfig as aB, ProviderResiliencePolicy as aC, RecoveryAction as aD, RecoveryDecision as aE, RecoveryLadderStep as aF, RecoveryResult as aG, ResilienceClassification as aH, ResilienceErrorClass as aI, ResolveKodaXManualInput as aJ, ResolveKodaXManualOptions as aK, ResolveKodaXManualResult as aL, RuntimeDefaultsSnapshot as aM, TodoItem as aN, TodoList as aO, TodoStatus as aP, WorkflowHostPolicy as aQ, WorkflowInvocationAction as aR, WorkflowInvocationPolicyDecision as aS, WorkflowInvocationPolicyInput as aT, WorkflowInvocationSource as aU, WorkflowInvocationTrigger as aV, WorkflowStartOutcome as aW, KodaXSkillInvocationContext as aa, KodaXSkillMap as ab, KodaXSkillProjectionConfidence as ac, KodaXTaskCapabilityHint as ad, KodaXTaskContract as ae, KodaXTaskEvidenceArtifact as af, KodaXTaskEvidenceBundle as ag, KodaXTaskEvidenceEntry as ah, KodaXTaskRole as ai, KodaXTaskRoleAssignment as aj, KodaXTaskStatus as ak, KodaXTaskSurface as al, KodaXTaskToolPolicy as am, KodaXTaskVerificationContract as an, KodaXTaskVerificationCriterion as ao, KodaXTaskWorkItem as ap, KodaXToolEventMeta as aq, KodaXToolExecutionContext as ar, KodaXVerificationScorecard as as, KodaXVerificationScorecardCriterion as at, KodaXWorkflowEventMeta as au, LspServerInfo as aw, LspServiceConfig as ay, ProviderExecutionState 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, KodaXFanoutBranchLifecycle as w, KodaXFanoutBranchRecord as x, KodaXFanoutBranchTransition as y, KodaXFanoutSchedulerInput as z };
+export { BASH_POLICY_SPEC as B, LSP_SERVERS as av, LspService as ax, buildGoalRuntimeBinding as b0, createBashPrefixExtractor as b1, decideWorkflowInvocation as b2, extractCommandPrefix as b3, getDefaultLspService as b4, makeDisabledGoalToolsContext as b5, providerResilienceConfigFromTimeouts as b6, shutdownDefaultLspService as b7, withGoalBeforeNextTurn as b8, withGoalStopHook as b9, workflowStartOutcomeConsumesTurn as ba };
+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, WorkflowToolHostStartResult as a$, KodaXSelfManualConfig as a0, KodaXSessionControl as a1, KodaXSessionMutators as a2, KodaXSessionOptions as a3, KodaXSidecarMessageEvent as a4, KodaXSkillInvocationContext as a5, KodaXSkillMap as a6, KodaXSkillProjectionConfidence as a7, KodaXTaskCapabilityHint as a8, KodaXTaskContract as a9, ProviderRecoveryEvent as aA, ProviderResilienceConfig as aB, ProviderResiliencePolicy as aC, RecoveryAction as aD, RecoveryDecision as aE, RecoveryLadderStep as aF, RecoveryResult as aG, ResilienceClassification as aH, ResilienceErrorClass as aI, ResolveKodaXManualInput as aJ, ResolveKodaXManualOptions as aK, ResolveKodaXManualResult as aL, RuntimeDefaultsSnapshot as aM, TodoItem as aN, TodoList as aO, TodoStatus as aP, ToolSideEffect as aQ, WorkflowHostPolicy as aR, WorkflowInvocationAction as aS, WorkflowInvocationPolicyDecision as aT, WorkflowInvocationPolicyInput as aU, WorkflowInvocationSource as aV, WorkflowRunProgressView as aW, WorkflowStartOutcome as aX, WorkflowToolHost as aY, WorkflowToolHostInlineInput as aZ, WorkflowToolHostResult as a_, KodaXTaskEvidenceArtifact as aa, KodaXTaskEvidenceBundle as ab, KodaXTaskEvidenceEntry as ac, KodaXTaskRole as ad, KodaXTaskRoleAssignment as ae, KodaXTaskStatus as af, KodaXTaskSurface as ag, KodaXTaskToolPolicy as ah, KodaXTaskVerificationContract as ai, KodaXTaskVerificationCriterion as aj, KodaXTaskWorkItem as ak, KodaXTimeoutConfig as al, KodaXToolEventMeta as am, KodaXToolExecutionContext as an, KodaXToolVisibilityMeta as ao, KodaXToolVisibilityPolicy as ap, KodaXVerificationScorecard as aq, KodaXVerificationScorecardCriterion as ar, KodaXWorkflowAgentDigestEvent as as, KodaXWorkflowEventMeta as at, KodaXWorkflowTimeoutConfig as au, LspServerInfo as aw, LspServiceConfig as ay, ProviderExecutionState 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, 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 };