@kodax-ai/kodax 0.7.41 → 0.7.42

package/dist/types-chunks/{bash-prefix-extractor.d-B2iliwdi.d.ts → bash-prefix-extractor.d-CkhaqKkg.d.ts}

@@ -1,6 +1,102 @@
-import { l as KodaXCompactMemorySeed, s as KodaXSessionArtifactLedgerEntry, L as KodaXSessionScope, M as KodaXSessionStorage, q as KodaXJsonValue, G as Guardrail, a3 as SessionErrorMetadata, D as DiscoveredInstance, C as ChildTaskRegistry, ac as TaskAbortRegistry, $ as RunnerToolCall, ae as ToolGuardrail } from './instance-discovery.d-DZhp77vb.js';
-import { o as KodaXMessage, C as CapabilityKind, b as CapabilityResult, Z as KodaXTokenUsage, G as KodaXReasoningMode, m as KodaXHarnessProfile, U as KodaXTaskWorkIntent, L as KodaXReviewScale, Q as KodaXTaskComplexity, c as KodaXAmaFanoutClass, S as KodaXTaskRoutingDecision, T as KodaXTaskType, M as KodaXRiskLevel, k as KodaXExecutionMode, e as KodaXAmaProfile, f as KodaXAmaTactic, d as KodaXAmaFanoutPolicy } from './capability.d-BxNgd1-c.js';
-import { K as KodaXBaseProvider, a as CostTracker } from './cost-tracker.d-C4dMlQuV.js';
+import { a as KodaXCompactMemorySeed, h as KodaXSessionArtifactLedgerEntry, t as KodaXSessionScope, u as KodaXSessionStorage, f as KodaXJsonValue, S as SessionErrorMetadata } from './types.d-mM8vqvhT.js';
+import { m as KodaXMessage, W as KodaXTokenUsage, D as KodaXReasoningMode, k as KodaXHarnessProfile, R as KodaXTaskWorkIntent, H as KodaXReviewScale, N as KodaXTaskComplexity, a as KodaXAmaFanoutClass, P as KodaXTaskRoutingDecision, Q as KodaXTaskType, I as KodaXRiskLevel, i as KodaXExecutionMode, c as KodaXAmaProfile, d as KodaXAmaTactic, b as KodaXAmaFanoutPolicy } from './types.d-B1uGoVTE.js';
+import { G as Guardrail, D as DiscoveredInstance, C as ChildTaskRegistry, T as TaskAbortRegistry, r as RunnerToolCall, J as ToolGuardrail } from './instance-discovery.d-BsKnIwpg.js';
+import { C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
+import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-BfJUXxC0.js';
+import { K as KodaXBaseProvider, a as CostTracker } from './cost-tracker.d-B6vMoLLF.js';
+
+/** One tool-call breadcrumb. Captures only the name + a 60-char input
+ * hint so the snapshot stays compact under fan-out. Mirrors the
+ * `inputHint` extraction in `buildChildEvents.onToolUseStart`. */
+interface ChildToolCallBreadcrumb {
+    readonly iteration: number;
+    readonly toolName: string;
+    /** Truncated path/pattern/command, ≤60 chars. May be empty when the
+     * tool input has no obvious key field. */
+    readonly inputHint: string;
+    /** Monotonic wall-clock ms at the time the tool call started. */
+    readonly startedAt: number;
+}
+/** Snapshot status. `running` is the initial state on dispatch. The
+ * three terminal states map from the child promise outcome:
+ *   - `completed` — child returned success
+ *   - `failed` — child returned non-success OR threw (non-AbortError)
+ *   - `aborted` — child threw an AbortError (parent or task_stop fired)
+ */
+type ChildProgressStatus = 'running' | 'completed' | 'failed' | 'aborted';
+interface ChildProgressSnapshot {
+    readonly childId: string;
+    /** Mutable in the writer (dispatch-child-tasks) — terminal status is
+     * set once in the inner-IIFE `.finally` block. Readers
+     * (task-output tool) treat it as authoritative. */
+    status: ChildProgressStatus;
+    /** Monotonic wall-clock ms at dispatch. */
+    readonly startedAt: number;
+    /** Monotonic wall-clock ms at terminal. Undefined while `status===
+     * 'running'`. */
+    endedAt?: number;
+    /** Iterations consumed by the child agent. Updated by
+     * `snapshotUpdater({kind:'iteration', iteration, max})` from
+     * `buildChildEvents.onIterationStart`. */
+    iterations: number;
+    /** Iteration ceiling forwarded from `ChildExecutorOptions
+     * .maxIterationsPerChild`. */
+    maxIterations: number;
+    /** Mutable ring buffer; writer must respect `RECENT_TOOL_CALLS_RING_CAP`
+     * via `pushBreadcrumb`. */
+    recentToolCalls: ChildToolCallBreadcrumb[];
+    /** Populated at terminal (any of `completed` / `failed` / `aborted`)
+     * with the same pre-guardrail `rawSummary` string that
+     * `dispatch-child-tasks.ts` produces for the `<task-completed>` body.
+     * For success-empty / failed-empty paths this is the diagnostic
+     * envelope (mode= ... iterations=... etc.) so post-completion
+     * `task_output` reads stay in lock-step with the banner the Worker
+     * already saw. */
+    finalText?: string;
+    /** Optional dispatcher role (`scout` / `worker` / `generator`),
+     * captured at init so a debug-style `task_output` peek can correlate
+     * the child with the parent fan-out class. Not surfaced in the
+     * envelope; reserved for future tracing. */
+    readonly parentRole?: string;
+    /** Read-only flag forwarded from the dispatch bundle. Same rationale
+     * as `parentRole` — currently captured for future surfacing. */
+    readonly readOnly?: boolean;
+}
+
+/** Result of a cache lookup. */
+type ReadStateLookup = {
+    readonly kind: 'miss';
+} | {
+    readonly kind: 'hit';
+    /** Wall-clock time (ms since epoch) of the prior matching read. */
+    readonly previousReadAtMs: number;
+};
+interface ReadFileStateCache {
+    /**
+     * Have we read this exact `(filePath, offset, limit)` in this task,
+     * with no mtime change since? `'hit'` means yes — caller should
+     * return a stub instead of re-reading the file off disk.
+     *
+     * On stat failure (file deleted / permission denied between record
+     * and lookup), returns `'miss'` so the read tool runs its own stat
+     * and reports the right error to the LLM rather than serving a stale
+     * stub.
+     */
+    lookup(filePath: string, offset: number, limit: number): ReadStateLookup;
+    /**
+     * Record a successful read at this `(filePath, offset, limit)` with
+     * the mtime observed at read time. The mtime is supplied by the
+     * caller (the read tool already stats the file) so the cache does
+     * not pay a second stat call.
+     */
+    record(filePath: string, offset: number, limit: number, mtimeMs: number): void;
+    /** Drop all entries for this file. Called by Edit / Write / MultiEdit on success. */
+    forget(filePath: string): void;
+    /** Drop everything. Called by the compaction post-hook. */
+    clear(): void;
+    /** Test/diagnostic accessor — number of distinct files currently cached. */
+    size(): number;
+}
 
 /** Result of a stale-check against the current on-disk content. */
 type StaleCheckResult = {
@@ -70,7 +166,9 @@ interface ContentHashCache {
 
 interface TodoInit {
     readonly id: string;
-    readonly content: string;
+    /** v0.7.42 — see TodoItem.subject JSDoc. */
+    readonly subject: string;
+    readonly description?: string;
     readonly owner?: string;
     readonly sourceObligationIndex?: number;
     /**
@@ -96,9 +194,12 @@ interface TodoInit {
 /**
  * FEATURE_170 v0.7.41 — input shape for `add()`. No `id` (auto-generated
  * by the store), no `status` (always created as `pending`).
+ *
+ * v0.7.42 — `content` renamed to `subject` + optional `description`.
  */
 interface TodoAddSeed {
-    readonly content: string;
+    readonly subject: string;
+    readonly description?: string;
     readonly activeForm?: string;
     readonly evaluator?: TodoEvaluatorHint;
     readonly owner?: string;
@@ -107,9 +208,22 @@ interface TodoAddSeed {
 }
 /**
  * FEATURE_170 v0.7.41 — input shape for `patch()`. Every field optional;
- * only those present in the patch object are applied. `metadata` is
- * shallow-merged (mirrors React setState mental model); explicit
- * `metadata: null` clears it.
+ * only those present in the patch object are applied.
+ *
+ * Metadata patch semantics (mirrors React setState mental model):
+ *   - `metadata: undefined` (omitted) → preserve existing metadata as-is.
+ *   - `metadata: null` (explicit)     → CLEAR all metadata.
+ *   - `metadata: {key: value}`        → shallow-merge `key=value` into
+ *                                       existing metadata.
+ *   - `metadata: {key: null}`         → v0.7.42 — DELETE that key from
+ *                                       existing metadata. Other existing
+ *                                       keys not mentioned in the patch
+ *                                       are preserved. If all keys end up
+ *                                       removed, the metadata field is
+ *                                       set back to `undefined` so the
+ *                                       JSON envelope stays compact.
+ *   - Mixed (`{keyA: null, keyB: v}`) → deletes keyA, sets keyB. Useful
+ *                                       for atomic "rename a flag" patches.
  *
  * `owner` and `sourceObligationIndex` are intentionally NOT patchable
  * post-creation — they identify provenance (which dispatch_child_task
@@ -118,11 +232,20 @@ interface TodoAddSeed {
  * seed and treat them as immutable thereafter.
  */
 interface TodoPatch {
-    readonly content?: string;
+    /** v0.7.42 — `content` renamed; patch the row label. */
+    readonly subject?: string;
+    /** v0.7.42 — patch the optional fuller description. Empty string clears. */
+    readonly description?: string;
     readonly activeForm?: string;
     readonly status?: TodoStatus;
     readonly note?: string;
     readonly evaluator?: TodoEvaluatorHint;
+    /**
+     * Opaque metadata patch. See type-level JSDoc for the four semantics
+     * (preserve / clear-all / merge / per-key-delete). Individual values
+     * inside the object MAY be `null` (v0.7.42 — interpreted as "delete
+     * this key from existing metadata").
+     */
     readonly metadata?: Record<string, unknown> | null;
 }
 interface TodoStore {
@@ -192,37 +315,6 @@ interface TodoStore {
     reset(): void;
 }
 
-/**
- * Telemetry payload for the `events.onEvaluatorFallbackSynthesized`
- * event. Fires AFTER `recorder.verdict` is written but BEFORE
- * `formatDeterministicEvaluatorResult` builds the final `KodaXResult`,
- * so consumers see the synth event in causal order before the result.
- */
-interface EvaluatorFallbackSynthesizedInfo {
-    /**
-     * Number of retries that were attempted before falling back. `0` means
-     * the very first detection of `verdict missing` led to fallback with
-     * no retry (only possible if `cap === 0`, which we don't allow — but
-     * keeping the field non-optional to keep the telemetry shape stable).
-     */
-    readonly retriesAttempted: number;
-    /** The cap value resolved for this run's model alias. */
-    readonly cap: number;
-    /**
-     * The model alias the run used, if known. `undefined` when the run
-     * dispatcher didn't surface the alias to the outer loop.
-     */
-    readonly modelAlias: string | undefined;
-    /**
-     * The last assistant text the Evaluator produced (the text-only
-     * response that triggered B2). Stored verbatim so post-hoc audit can
-     * see what the model said when it failed to terminate.
-     */
-    readonly userFacingText: string;
-    /** Stable reason string written into the synthesized verdict. */
-    readonly reason: string;
-}
-
 /**
  * @kodax-ai/agent Compaction Types
  */
@@ -430,46 +522,6 @@ interface ProviderResiliencePolicy extends ProviderResilienceConfig {
     provider: string;
 }
 
-/**
- * MCP server configuration shapes.
- *
- * FEATURE_082 (v0.7.24): moved from `@kodax-ai/coding/src/types.ts`. Kept as the
- * `Mcp*` names here; the `KodaXMcp*` aliases continue to re-export from
- * `@kodax-ai/coding` for backward compatibility.
- */
-type McpTransportKind = 'stdio' | 'sse' | 'streamable-http';
-type McpConnectMode = 'lazy' | 'prewarm' | 'disabled';
-interface McpServerConfig {
-    /** Transport type. Defaults to 'stdio' when omitted. */
-    type?: McpTransportKind;
-    /** stdio: executable command. */
-    command?: string;
-    /** stdio: command arguments. */
-    args?: string[];
-    /** stdio: working directory for the spawned process. */
-    cwd?: string;
-    /** stdio: extra environment variables for the spawned process. */
-    env?: Record<string, string>;
-    /** sse / streamable-http: server endpoint URL. */
-    url?: string;
-    /** sse / streamable-http: extra HTTP headers (e.g. Authorization). */
-    headers?: Record<string, string>;
-    connect?: McpConnectMode;
-    startupTimeoutMs?: number;
-    requestTimeoutMs?: number;
-    /** OAuth 2.0 configuration for authenticated MCP servers. */
-    auth?: {
-        readonly type: 'oauth2';
-        readonly clientId: string;
-        readonly authorizationUrl: string;
-        readonly tokenUrl: string;
-        readonly scopes?: readonly string[];
-        readonly redirectPort?: number;
-    };
-}
-/** Flat map of MCP server configs, keyed under `mcpServers` in config.json. */
-type McpServersConfig = Record<string, McpServerConfig>;
-
 interface KodaXEvents {
     onTextDelta?: (text: string) => void;
     onThinkingDelta?: (text: string) => void;
@@ -628,7 +680,6 @@ interface KodaXEvents {
      * — consumers see the synth signal in causal order before the result
      * surfaces.
      */
-    onEvaluatorFallbackSynthesized?: (info: EvaluatorFallbackSynthesizedInfo) => void;
     /** Returns a formatted cost report for the current session. Set by agent at session start. */
     getCostReport?: {
         current: (() => string) | null;
@@ -781,17 +832,34 @@ type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped'
  */
 type TodoEvaluatorHint = 'build' | 'test' | 'lint';
 /**
- * One row in the planner-produced todo list. Content is sourced from
- * Scout's existing `executionObligations: string[]` payload (no schema
- * change at the protocol layer). Status is advanced via the
- * `todo_update` tool by Scout (H0 path) / Generator / Planner.
+ * One row in the planner-produced todo list. Subject is the short
+ * imperative title (shown in the UI row + throttle reminder); the
+ * optional description carries fuller context for downstream consumers
+ * that need the full work instruction. Sourced from Scout's existing
+ * `executionObligations: string[]` payload (each string becomes the
+ * `subject` of one seed item, no `description`). Status is advanced
+ * via the `todo_update` tool by Scout (H0 path) / Worker / Generator /
+ * Planner.
+ *
+ * v0.7.42 — `content` field renamed to `subject` to match claudecode V2
+ * `TaskSchema` (TaskCreateTool's required `subject` + `description`
+ * pair). KodaX makes `description` optional because trivial single-line
+ * steps don't need it; weaker models reach the API more easily without
+ * the forced second-string burden.
  *
  * `owner` partitions the list when child agents run in parallel under
  * `dispatch_child_task`; "main" is the parent thread.
  */
 interface TodoItem {
     readonly id: string;
-    readonly content: string;
+    /** Brief imperative title — the row label users see in the plan list. */
+    readonly subject: string;
+    /**
+     * Optional fuller description / context. Read by the executing role
+     * when picking up an item (claudecode V2 `TaskGet`-style detail view).
+     * Not rendered in the compact plan-list row.
+     */
+    readonly description?: string;
     readonly status: TodoStatus;
     readonly owner?: string;
     /** Index into the originating `executionObligations: string[]` array (0-based). */
@@ -967,6 +1035,15 @@ interface KodaXChildAgentResult {
     sessionId?: string;
     /** Actual iterations consumed by this child agent. */
     actualIterations?: number;
+    /**
+     * True when the child's `runKodaX` exited via CAP-083 AbortError silent
+     * terminal (`KodaXResult.interrupted === true`). Surfaces the
+     * "success but empty lastText" path that produces empty
+     * `<task-completed task_id="X"></task-completed>` banners.
+     * Diagnostic field — populated by child-executor on the success branch
+     * and consumed by dispatch-child-tasks' empty-summary fallback.
+     */
+    interrupted?: boolean;
 }
 interface KodaXParentReductionContract {
     owner: 'parent';
@@ -981,8 +1058,6 @@ interface KodaXChildExecutionResult {
     readonly mergedArtifacts: readonly string[];
     readonly totalTokensUsed: number;
     readonly cancelledChildren: readonly string[];
-    /** Worktree paths for write children, keyed by childId. Available for evaluator review. */
-    readonly worktreePaths?: ReadonlyMap<string, string>;
 }
 interface KodaXChildFinding {
     readonly childId: string;
@@ -1042,7 +1117,7 @@ interface KodaXManagedTaskHarnessTransition {
     approved: boolean;
     denialReason?: string;
 }
-type KodaXManagedTaskPhase = 'starting' | 'routing' | 'preflight' | 'round' | 'worker' | 'upgrade' | 'completed';
+type KodaXManagedTaskPhase = 'starting' | 'routing' | 'preflight' | 'round' | 'worker' | 'upgrade' | 'verifying' | 'completed';
 type KodaXManagedLiveEventPresentation = 'status' | 'assistant' | 'thinking';
 interface KodaXManagedLiveEvent {
     key: string;
@@ -1235,8 +1310,6 @@ interface KodaXContextOptions {
     };
     /** Mutable mutation tracker shared between worker events and the protocol tool handler. */
     mutationTracker?: ManagedMutationTracker;
-    /** FEATURE_067 v2: Callback for dispatch_child_tasks to register write worktree paths. */
-    registerChildWriteWorktrees?: (worktreePaths: ReadonlyMap<string, string>) => void;
     /** FEATURE_067 v3: Tool names to exclude from API-level tool list (child agents). */
     excludeTools?: readonly string[];
     /**
@@ -1281,6 +1354,37 @@ interface KodaXOptions {
     guardrails?: readonly Guardrail[];
     /** AbortSignal for cancelling the API request */
     abortSignal?: AbortSignal;
+    /**
+     * v0.7.42 — `RunningSession` plumbing (closes gap 6 reported by KodaX
+     * Space). When provided, the substrate `_attach`es low-level mutators
+     * onto this control object so the embedder can flip provider / model
+     * / reasoning between turns without restarting the run. The mutations
+     * land on the live `RuntimeSessionState` and are picked up by the
+     * next-turn CAP-055 provider re-resolution. `startKodaX` (the
+     * non-blocking entry) is the canonical producer of this field; direct
+     * SDK callers can also instantiate one via {@link createSessionControl}.
+     */
+    sessionControl?: KodaXSessionControl;
+}
+/**
+ * Low-level mutators handed to a `KodaXSessionControl` by the substrate.
+ * Each setter writes directly into the live `RuntimeSessionState`. Called
+ * exactly once per session (just after `buildRuntimeSessionState`).
+ */
+interface KodaXSessionMutators {
+    setProvider(name: string): void;
+    setModel(model: string | undefined): void;
+    setReasoning(mode: KodaXReasoningMode | undefined): void;
+}
+/**
+ * Embedder-facing control surface. Created by the embedder (or by
+ * `startKodaX`), passed in via `KodaXOptions.sessionControl`. The
+ * substrate calls `_attach` once, after which the control's setter
+ * methods apply live to the in-flight run.
+ */
+interface KodaXSessionControl {
+    /** @internal — wired by `run-substrate`. Do not call from user code. */
+    _attach(mutators: KodaXSessionMutators): void;
 }
 type KodaXTaskSurface = 'cli' | 'repl' | 'plan';
 type KodaXTaskStatus = 'planned' | 'running' | 'blocked' | 'failed' | 'completed';
@@ -1432,8 +1536,6 @@ interface KodaXManagedTaskRuntimeState {
     childWriteReviewPrompt?: string;
     /** FEATURE_067: Number of write child diffs pending evaluator review. */
     childWriteDiffCount?: number;
-    /** FEATURE_067 v2: Worktree paths from dispatch_child_tasks write fan-out, keyed by childId. */
-    childWriteWorktreePaths?: ReadonlyMap<string, string>;
 }
 interface KodaXManagedTask {
     contract: KodaXTaskContract;
@@ -1444,7 +1546,11 @@ interface KodaXManagedTask {
     runtime?: KodaXManagedTaskRuntimeState;
 }
 interface KodaXManagedVerdictPayload {
-    source: 'evaluator' | 'worker';
+    /** 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';
     status: 'accept' | 'revise' | 'blocked';
     reason?: string;
     debugReason?: string;
@@ -1661,8 +1767,6 @@ interface KodaXToolExecutionContext {
     /** FEATURE_067 v2: Callback for long-running tools to report execution progress to the REPL transcript.
      *  The string will be displayed as the tool's "Running:" line in the transcript. */
     reportToolProgress?: (message: string) => void;
-    /** FEATURE_067 v2: Callback to store write child worktree paths for Evaluator diff injection. */
-    registerChildWriteWorktrees?: (worktreePaths: ReadonlyMap<string, string>) => void;
     /** Mutation tracker for scope-aware protocol responses. Populated by createWorkerEvents. */
     mutationTracker?: ManagedMutationTracker;
     /**
@@ -1714,6 +1818,20 @@ interface KodaXToolExecutionContext {
      * See `packages/coding/src/multi-instance/content-hash-cache.ts`.
      */
     contentHashCache?: ContentHashCache;
+    /**
+     * FEATURE_177 v0.7.42 — per-task read-file-state cache (anti-loop).
+     *
+     * Tracks `(filePath, offset, limit)` tuples the LLM has already read
+     * in this task. On a re-read with unchanged mtime, the Read tool
+     * returns a short stub instead of the full content — breaking
+     * `narrate-then-re-read` loops on models with structural decoder
+     * floors (kimi-code 2026-05). Edit / Write / MultiEdit call `forget`
+     * after a successful mutation; the compaction post-hook calls
+     * `clear`. Disabled by `KODAX_READ_DEDUP_KILLSWITCH=1`.
+     *
+     * See `packages/coding/src/multi-instance/read-file-state-cache.ts`.
+     */
+    readFileStateCache?: ReadFileStateCache;
     /**
      * FEATURE_125 v0.7.41 — Team Mode Layer 3 input.
      *
@@ -1779,6 +1897,27 @@ interface KodaXToolExecutionContext {
      * `childTaskRegistry`).
      */
     childAbortControllers?: TaskAbortRegistry;
+    /**
+     * FEATURE_177 v0.7.45 substrate for the `task_output` tool. Per-child
+     * runtime snapshot a parent agent can query mid-flight to peek at
+     * iteration count + recent tool-call breadcrumbs without waiting for
+     * the child's `<task-completed>` banner.
+     *
+     * Populated by `dispatch_child_task` at launch (`initChildSnapshot`)
+     * and at terminal (`finalizeChildSnapshot` in the child promise's
+     * inner-IIFE `.finally`). The `task_output` tool reads from this map.
+     *
+     * Snapshots survive the child task settling (so post-completion peeks
+     * work) and are bounded by `CHILD_PROGRESS_SNAPSHOT_CAP` (FIFO prune
+     * by `startedAt` when the cap is exceeded). No TTL — snapshots are
+     * cleared with the ctx itself when the parent runner exits.
+     *
+     * Undefined in legacy sync-mode dispatch (same gate as
+     * `childTaskRegistry`). Children's own SA contexts do NOT inherit
+     * this map (verified by `buildToolExecutionContext` not forwarding
+     * it into child `runKodaX` calls).
+     */
+    childProgressSnapshots?: Map<string, ChildProgressSnapshot>;
 }
 
 /**
@@ -2428,5 +2567,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, extractCommandPrefix as a$, WINDOW_MS as aU, collectAllSignals as aV, computeRulesFingerprint as aW, createAutoModeToolGuardrail as aX, createBashPrefixExtractor as aY, createCircuitBreaker as aZ, createDenialTracker as a_, formatAgentsForPrompt as b0, getKodaxGlobalDir as b1, loadAgentsFiles as b2, loadAutoRules as b3, parseAutoRules as b4, readTrustState as b5, recordAllow as b6, recordBlock as b7, recordError as b8, shouldFallback$1 as b9, shouldFallback as ba, trustProjectRules as bb, CUMULATIVE_THRESHOLD as n };
-export type { KodaXOrchestrationVerdict as $, AgentsFile as A, DenialTracker as D, FailureStage as F, KodaXContextOptions as G, KodaXContextTokenSnapshot as H, KodaXEvents as I, KodaXFanoutBranchLifecycle as J, KodaXAgentMode as K, KodaXFanoutBranchRecord as L, KodaXFanoutBranchTransition as M, KodaXFanoutSchedulerInput as N, KodaXFanoutSchedulerPlan as O, KodaXInputArtifact as P, KodaXManagedBudgetSnapshot as Q, KodaXManagedProtocolPayload as R, KodaXManagedTask as S, KodaXManagedTaskRuntimeState as T, KodaXManagedTaskStatusEvent as U, KodaXMcpConnectMode as V, KodaXMcpServerConfig as W, KodaXMcpServersConfig as X, KodaXMcpTransport as Y, KodaXMemoryStrategy as Z, KodaXOptions as _, AskUserMultiOptions as a, KodaXParentReductionContract as a0, KodaXProviderPolicyHints as a1, KodaXRepoIntelligenceCapability as a2, KodaXRepoIntelligenceMode as a3, KodaXRepoIntelligenceResolvedMode as a4, KodaXRepoIntelligenceTrace as a5, KodaXRepoIntelligenceTraceEvent as a6, KodaXRepoRoutingSignals as a7, KodaXResult as a8, KodaXRoleRoundSummary as a9, McpTransportKind as aA, ProviderExecutionState as aB, ProviderRecoveryEvent as aC, ProviderResilienceConfig as aD, ProviderResiliencePolicy as aE, RecoveryAction as aF, RecoveryDecision as aG, RecoveryLadderStep as aH, RecoveryResult as aI, ResilienceClassification as aJ, ResilienceErrorClass as aK, RulesLoadError as aL, RulesLoadResult as aM, SignalCollector as aN, SkippedRulesSource as aO, TodoItem as aP, TodoList as aQ, TodoStatus as aR, ToolCallSignal as aS, TrustState as aT, KodaXRuntimeVerificationContract as aa, KodaXSessionOptions as ab, KodaXSkillInvocationContext as ac, KodaXSkillMap as ad, KodaXSkillProjectionConfidence as ae, KodaXTaskCapabilityHint as af, KodaXTaskContract as ag, KodaXTaskEvidenceArtifact as ah, KodaXTaskEvidenceBundle as ai, KodaXTaskEvidenceEntry as aj, KodaXTaskRole as ak, KodaXTaskRoleAssignment as al, KodaXTaskStatus as am, KodaXTaskSurface as an, KodaXTaskToolPolicy as ao, KodaXTaskVerificationContract as ap, KodaXTaskVerificationCriterion as aq, KodaXTaskWorkItem as ar, KodaXToolExecutionContext as as, KodaXVerificationScorecard as at, KodaXVerificationScorecardCriterion as au, LoadAgentsOptions as av, LoadedRulesSource as aw, McpConnectMode as ax, McpServerConfig as ay, McpServersConfig as az, AskUserQuestionItem as b, AskUserQuestionOptions as c, AutoModeAskUser as d, AutoModeAskUserVerdict as e, AutoModeEngine as f, AutoModeGuardrailConfig as g, AutoModeSharedState as h, AutoModeStats as i, AutoModeToolGuardrail as j, AutoRules as k, BashPrefixExtractor as l, BashPrefixResult as m, CircuitBreaker as o, CompactionAnchor as p, CompactionDetails as q, CompactionResult as r, CompactionUpdate as s, CreateBashPrefixExtractorOptions as t, ExtensionRuntimeContract as u, ExtractCommandPrefixOptions as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXChildAgentResult as y, KodaXChildContextBundle as z };
+export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, getKodaxGlobalDir as a$, WINDOW_MS as aS, collectAllSignals as aT, computeRulesFingerprint as aU, createAutoModeToolGuardrail as aV, createBashPrefixExtractor as aW, createCircuitBreaker as aX, createDenialTracker as aY, extractCommandPrefix as aZ, formatAgentsForPrompt as a_, loadAgentsFiles as b0, loadAutoRules as b1, parseAutoRules as b2, readTrustState as b3, recordAllow as b4, recordBlock as b5, recordError as b6, shouldFallback$1 as b7, shouldFallback as b8, trustProjectRules as b9, CUMULATIVE_THRESHOLD as n };
+export type { KodaXOrchestrationVerdict as $, AgentsFile as A, DenialTracker as D, FailureStage as F, KodaXContextOptions as G, KodaXContextTokenSnapshot as H, KodaXEvents as I, KodaXFanoutBranchLifecycle as J, KodaXAgentMode as K, KodaXFanoutBranchRecord as L, KodaXFanoutBranchTransition as M, KodaXFanoutSchedulerInput as N, KodaXFanoutSchedulerPlan as O, KodaXInputArtifact as P, KodaXManagedBudgetSnapshot as Q, KodaXManagedProtocolPayload as R, KodaXManagedTask as S, KodaXManagedTaskRuntimeState as T, KodaXManagedTaskStatusEvent as U, KodaXMcpConnectMode as V, KodaXMcpServerConfig as W, KodaXMcpServersConfig as X, KodaXMcpTransport as Y, KodaXMemoryStrategy as Z, KodaXOptions as _, AskUserMultiOptions as a, KodaXParentReductionContract as a0, KodaXProviderPolicyHints as a1, KodaXRepoIntelligenceCapability as a2, KodaXRepoIntelligenceMode as a3, KodaXRepoIntelligenceResolvedMode as a4, KodaXRepoIntelligenceTrace as a5, KodaXRepoIntelligenceTraceEvent as a6, KodaXRepoRoutingSignals as a7, KodaXResult as a8, KodaXRoleRoundSummary 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, RulesLoadError as aJ, RulesLoadResult as aK, SignalCollector as aL, SkippedRulesSource as aM, TodoItem as aN, TodoList as aO, TodoStatus as aP, ToolCallSignal as aQ, TrustState as aR, KodaXRuntimeVerificationContract as aa, KodaXSessionControl as ab, KodaXSessionMutators as ac, KodaXSessionOptions as ad, KodaXSkillInvocationContext as ae, KodaXSkillMap as af, KodaXSkillProjectionConfidence as ag, KodaXTaskCapabilityHint as ah, KodaXTaskContract as ai, KodaXTaskEvidenceArtifact as aj, KodaXTaskEvidenceBundle as ak, KodaXTaskEvidenceEntry as al, KodaXTaskRole as am, KodaXTaskRoleAssignment as an, KodaXTaskStatus as ao, KodaXTaskSurface as ap, KodaXTaskToolPolicy as aq, KodaXTaskVerificationContract as ar, KodaXTaskVerificationCriterion as as, KodaXTaskWorkItem as at, KodaXToolExecutionContext as au, KodaXVerificationScorecard as av, KodaXVerificationScorecardCriterion as aw, LoadAgentsOptions as ax, LoadedRulesSource as ay, ProviderExecutionState as az, AskUserQuestionItem as b, AskUserQuestionOptions as c, AutoModeAskUser as d, AutoModeAskUserVerdict as e, AutoModeEngine as f, AutoModeGuardrailConfig as g, AutoModeSharedState as h, AutoModeStats as i, AutoModeToolGuardrail as j, AutoRules as k, BashPrefixExtractor as l, BashPrefixResult as m, CircuitBreaker as o, CompactionAnchor as p, CompactionDetails as q, CompactionResult as r, CompactionUpdate as s, CreateBashPrefixExtractorOptions as t, ExtensionRuntimeContract as u, ExtractCommandPrefixOptions as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXChildAgentResult as y, KodaXChildContextBundle as z };

package/dist/types-chunks/capability.d-3C62G8Eq.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Layer A Primitive: Capability provider contract.
+ *
+ * FEATURE_082 (v0.7.24): extracted from `@kodax-ai/coding/src/extensions/types.ts`
+ * so third-party capability sources (MCP, RAG, custom indexes, …) can
+ * implement `CapabilityProvider` without importing from the coding preset.
+ *
+ * The richer "extension runtime" concept (command registration, file
+ * contributions, logger plumbing) stays in `@kodax-ai/coding/src/extensions/`
+ * because it is coupled to the coding CLI surface.
+ */
+type CapabilityKind = 'tool' | 'resource' | 'prompt';
+interface CapabilityResult {
+    kind: CapabilityKind;
+    content?: string;
+    structuredContent?: unknown;
+    evidence?: unknown[];
+    artifacts?: unknown[];
+    metadata?: Record<string, unknown>;
+}
+interface CapabilityProvider {
+    id: string;
+    kinds: CapabilityKind[];
+    search?: (query: string, options?: {
+        kind?: CapabilityKind;
+        limit?: number;
+        server?: string;
+    }) => Promise<unknown[]>;
+    describe?: (id: string) => Promise<unknown>;
+    execute?: (id: string, input: Record<string, unknown>) => Promise<CapabilityResult>;
+    read?: (id: string, options?: Record<string, unknown>) => Promise<CapabilityResult>;
+    getPrompt?: (id: string, args?: Record<string, unknown>) => Promise<unknown>;
+    getPromptContext?: () => Promise<string | undefined> | string | undefined;
+    getDiagnostics?: () => Record<string, unknown> | undefined;
+    refresh?: () => Promise<void>;
+    dispose?: () => Promise<void>;
+}
+
+export type { CapabilityKind as C, CapabilityProvider as a, CapabilityResult as b };

package/dist/types-chunks/config.d-BfJUXxC0.d.ts

@@ -0,0 +1,41 @@
+/**
+ * MCP server configuration shapes.
+ *
+ * FEATURE_082 (v0.7.24): moved from `@kodax-ai/coding/src/types.ts`. Kept as the
+ * `Mcp*` names here; the `KodaXMcp*` aliases continue to re-export from
+ * `@kodax-ai/coding` for backward compatibility.
+ */
+type McpTransportKind = 'stdio' | 'sse' | 'streamable-http';
+type McpConnectMode = 'lazy' | 'prewarm' | 'disabled';
+interface McpServerConfig {
+    /** Transport type. Defaults to 'stdio' when omitted. */
+    type?: McpTransportKind;
+    /** stdio: executable command. */
+    command?: string;
+    /** stdio: command arguments. */
+    args?: string[];
+    /** stdio: working directory for the spawned process. */
+    cwd?: string;
+    /** stdio: extra environment variables for the spawned process. */
+    env?: Record<string, string>;
+    /** sse / streamable-http: server endpoint URL. */
+    url?: string;
+    /** sse / streamable-http: extra HTTP headers (e.g. Authorization). */
+    headers?: Record<string, string>;
+    connect?: McpConnectMode;
+    startupTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    /** OAuth 2.0 configuration for authenticated MCP servers. */
+    auth?: {
+        readonly type: 'oauth2';
+        readonly clientId: string;
+        readonly authorizationUrl: string;
+        readonly tokenUrl: string;
+        readonly scopes?: readonly string[];
+        readonly redirectPort?: number;
+    };
+}
+/** Flat map of MCP server configs, keyed under `mcpServers` in config.json. */
+type McpServersConfig = Record<string, McpServerConfig>;
+
+export type { McpConnectMode as M, McpServerConfig as a, McpServersConfig as b, McpTransportKind as c };

package/dist/types-chunks/{cost-tracker.d-C4dMlQuV.d.ts → cost-tracker.d-B6vMoLLF.d.ts}

@@ -1,4 +1,4 @@
-import { t as KodaXProviderConfig, o as KodaXMessage, _ as KodaXToolDefinition, I as KodaXReasoningRequest, B as KodaXProviderStreamOptions, N as KodaXStreamResult, p as KodaXModelDescriptor, s as KodaXProviderCapabilityProfile, F as KodaXReasoningCapability, H as KodaXReasoningOverride } from './capability.d-BxNgd1-c.js';
+import { r as KodaXProviderConfig, m as KodaXMessage, X as KodaXToolDefinition, F as KodaXReasoningRequest, z as KodaXProviderStreamOptions, J as KodaXStreamResult, n as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, C as KodaXReasoningCapability, E as KodaXReasoningOverride } from './types.d-B1uGoVTE.js';
 
 /**
  * Retry-After header parsing — FEATURE_130 (v0.7.36).
@@ -145,8 +145,26 @@ declare abstract class KodaXBaseProvider {
      * Returns undefined when no cap is configured. Consumed by the
      * resilience layer to abort a doomed stream before the server-side
      * kill window fires; routed through `non_streaming_fallback`.
+     *
+     * Cascade (highest to lowest):
+     *   1. Active model descriptor's `streamMaxDurationMs`
+     *   2. Provider config default
+     *   3. undefined (watchdog disabled)
+     */
+    getStreamMaxDurationMs(model?: string): number | undefined;
+    /**
+     * Resolves whether OpenAI-compat `reasoning_content` should echo back
+     * on replayed assistant messages for the given model. Same cascade as
+     * `getStreamMaxDurationMs`. Defaults to false when neither layer sets it.
+     */
+    getEffectiveReplayReasoningContent(model?: string): boolean;
+    /**
+     * Resolves whether Anthropic-style thinking signatures must verify
+     * strictly (Anthropic proper only). Same cascade as
+     * `getStreamMaxDurationMs`. Defaults to false (lenient) when neither
+     * layer sets it — matches third-party Anthropic-compat behavior.
      */
-    getStreamMaxDurationMs(): number | undefined;
+    getEffectiveStrictThinkingSignature(model?: string): boolean;
     abstract stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
     complete(_messages: KodaXMessage[], _tools: KodaXToolDefinition[], _system: string, _reasoning?: boolean | KodaXReasoningRequest, _streamOptions?: KodaXProviderStreamOptions, _signal?: AbortSignal): Promise<KodaXStreamResult>;