@kodax-ai/kodax 0.7.41 → 0.7.43

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

@@ -1,6 +1,110 @@
-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 { t as KodaXSessionScope, u as KodaXSessionStorage, f as KodaXJsonValue, h as KodaXSessionArtifactLedgerEntry, 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 { k as CompactionUpdate, o as Guardrail, D as DiscoveredInstance, C as ChildTaskRegistry, a1 as TaskAbortRegistry, K as RunnerToolCall, a4 as ToolGuardrail } from './types.d-CKJtjo-6.js';
+import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-BfJUXxC0.js';
+import { C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
+import { K as KodaXBaseProvider } from './base.d-FUJahC0i.js';
+import { a as CostTracker } from './cost-tracker.d-wRtyEW9d.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;
+    /**
+     * FEATURE_191 — registered specialist agent name when the dispatch
+     * routed through a `subagent_type` argument. `undefined` for generic
+     * anonymous children. Surfaced by `task_output` so post-mortem peeks
+     * can identify which specialist owned the child.
+     */
+    readonly specialistName?: string;
+}
+
+/** 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 +174,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 +202,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 +216,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 +240,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,84 +323,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
- */
-
-interface CompactionDetails {
-    readFiles: string[];
-    modifiedFiles: string[];
-}
-interface CompactionAnchor {
-    summary: string;
-    tokensBefore: number;
-    tokensAfter: number;
-    entriesRemoved: number;
-    reason: string;
-    artifactLedgerId?: string;
-    details?: CompactionDetails;
-    memorySeed?: KodaXCompactMemorySeed;
-}
-interface CompactionUpdate {
-    anchor?: CompactionAnchor;
-    artifactLedger?: KodaXSessionArtifactLedgerEntry[];
-    memorySeed?: KodaXCompactMemorySeed;
-    /**
-     * FEATURE_072: ledger-summary + file-content messages produced by
-     * `buildPostCompactAttachments` + `buildFileContentMessages`. Agent.ts
-     * passes these separately from the kept-tail messages so REPL-side
-     * `applySessionCompaction` can store them natively on the CompactionEntry
-     * rather than inlining them as loose `[Post-compact: ...]` system messages
-     * in lineage. Agent.ts keeps inlining them into its local flat `messages`
-     * via `injectPostCompactAttachments` (P4 belt-and-suspenders); the lineage
-     * is the persistence source of truth.
-     */
-    postCompactAttachments?: readonly KodaXMessage[];
-}
-interface CompactionResult {
-    compacted: boolean;
-    messages: KodaXMessage[];
-    summary?: string;
-    tokensBefore: number;
-    tokensAfter: number;
-    entriesRemoved: number;
-    details?: CompactionDetails;
-    artifactLedger?: KodaXSessionArtifactLedgerEntry[];
-    anchor?: CompactionAnchor;
-    memorySeed?: KodaXCompactMemorySeed;
-}
-
 /**
  * FEATURE_093 (v0.7.24): minimal contract interface for the coding extension
  * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
@@ -430,46 +483,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 +641,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;
@@ -747,7 +759,7 @@ interface KodaXRepoIntelligenceTrace {
  * (interactive REPL), and `acp_server`.
  *
  * Note: FEATURE_083 (v0.7.24) initially marked this as superseded by
- * `EvidenceSpan` in `@kodax-ai/tracing`. **FEATURE_086 (v0.7.27) re-evaluated
+ * `EvidenceSpan` in `@kodax-ai/agent`. **FEATURE_086 (v0.7.27) re-evaluated
  * and retained it**: `EvidenceSpanData` is a generic
  * `{ source, queryPreview?, resultCount?, cacheHit?, error? }` abstraction
  * that does not carry the repo-intelligence-specific `stage` enum,
@@ -781,17 +793,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). */
@@ -943,6 +972,17 @@ interface KodaXChildContextBundle {
      * lands separately.
      */
     modelHint?: KodaXChildModelHint;
+    /**
+     * FEATURE_191 — optional registered specialist agent name. When set,
+     * the child is dispatched with that agent's `instructions` /
+     * `tools` / `reasoning` / `guardrails` instead of the stock Worker
+     * bundle. Resolved via `resolveConstructedAgent(name)` at dispatch
+     * time; unknown names are rejected by `toolDispatchChildTask` with
+     * a tool-result error (not throw) before the bundle reaches
+     * `executeReadChild` / `executeWriteChild`. Optional — omitting
+     * preserves byte-identical v0.7.42 baseline dispatch behavior.
+     */
+    specialistName?: string;
 }
 /**
  * FEATURE_120 v0.7.39 Phase 4 — model tier hint. Tier semantics:
@@ -967,6 +1007,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 +1030,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 +1089,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 +1282,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 +1326,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';
@@ -1365,7 +1441,6 @@ interface KodaXOrchestrationVerdict {
     signalReason?: string;
     signalDebugReason?: string;
     disposition?: 'complete' | 'blocked' | 'needs_continuation';
-    continuationSuggested?: boolean;
 }
 interface KodaXManagedTaskRuntimeState {
     amaProfile?: KodaXAmaProfile;
@@ -1387,24 +1462,6 @@ interface KodaXManagedTaskRuntimeState {
     currentHarness?: KodaXHarnessProfile;
     upgradeCeiling?: KodaXHarnessProfile;
     harnessTransitions?: KodaXManagedTaskHarnessTransition[];
-    scoutDecision?: {
-        summary: string;
-        recommendedHarness: KodaXHarnessProfile;
-        readyForUpgrade: boolean;
-        scope?: string[];
-        requiredEvidence?: string[];
-        reviewFilesOrAreas?: string[];
-        evidenceAcquisitionMode?: 'overview' | 'diff-bundle' | 'diff-slice' | 'file-read';
-        harnessRationale?: string;
-        blockingEvidence?: string[];
-        directCompletionReady?: 'yes' | 'no';
-        skillSummary?: string;
-        executionObligations?: string[];
-        verificationObligations?: string[];
-        ambiguities?: string[];
-        projectionConfidence?: KodaXSkillProjectionConfidence;
-    };
-    skillMap?: KodaXSkillMap;
     completionContractStatus?: Record<string, 'ready' | 'incomplete' | 'blocked' | 'missing'>;
     rawRoutingDecision?: KodaXTaskRoutingDecision;
     finalRoutingDecision?: KodaXTaskRoutingDecision;
@@ -1432,8 +1489,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 +1499,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;
@@ -1457,7 +1516,6 @@ interface KodaXManagedVerdictPayload {
     nextHarness?: KodaXTaskRoutingDecision['harnessProfile'];
     protocolParseFailed?: boolean;
     verificationDegraded?: boolean;
-    continuationSuggested?: boolean;
     preferredFallbackWorkerId?: string;
     /**
      * v0.7.26 Risk-3 fix — Evaluator explicit budget-extension request.
@@ -1470,72 +1528,19 @@ interface KodaXManagedVerdictPayload {
     budgetRequest?: string;
 }
 /**
- * Signals surfaced by the harness (not the LLM) when Scout's completion looks
- * suspicious. See runManagedScoutStage for the detection logic.
+ * Signals surfaced by the harness (not the LLM) when V1 Scout's completion
+ * looked suspicious.
+ *
+ * FEATURE_193 (v0.7.43) deep V1 cleanup: V1 Scout role is retired and the
+ * Runner-driven path no longer fires `onScoutSuspiciousCompletion`. The
+ * type is kept on the SDK surface so the `KodaXEvents.onScoutSuspiciousCompletion`
+ * callback signature continues to compile for pre-1.0 SDK consumers (e.g.
+ * the REPL renderers that still register a handler). New code MUST NOT
+ * emit this signal.
  */
 type KodaXScoutSuspiciousSignal = 'mutation-expected-but-none' | 'budget-exhausted' | 'no-formal-completion';
-interface KodaXManagedScoutPayload {
-    summary?: string;
-    scope: string[];
-    requiredEvidence: string[];
-    reviewFilesOrAreas?: string[];
-    evidenceAcquisitionMode?: 'overview' | 'diff-bundle' | 'diff-slice' | 'file-read';
-    confirmedHarness?: KodaXTaskRoutingDecision['harnessProfile'];
-    harnessRationale?: string;
-    blockingEvidence?: string[];
-    directCompletionReady?: 'yes' | 'no';
-    /**
-     * FEATURE_078 (v0.7.29): Scout's optional non-binding suggestion for
-     * the reasoning depth downstream workers (Planner / Generator /
-     * Evaluator) should use. Resolved by `resolveRoleReasoning(role,
-     * userCeiling, profile, scoutHint)` as the L3 input — clamped by L1
-     * (user ceiling) and L2 (agent profile max). Scout SHOULD set this
-     * sparingly: only when the scoped task signals atypically low
-     * complexity (`'quick'`) or atypically high stakes (`'deep'`); leave
-     * undefined for the default path so workers stick to their own
-     * `Agent.reasoning.default`.
-     */
-    downstreamReasoningHint?: KodaXReasoningMode;
-    userFacingText?: string;
-    skillMap?: {
-        skillSummary?: string;
-        executionObligations: string[];
-        verificationObligations: string[];
-        ambiguities: string[];
-        projectionConfidence?: KodaXSkillProjectionConfidence;
-    };
-    /**
-     * Harness-observed confidence in Scout's completion. 'confident' is the default
-     * (omitted). 'uncertain' means the harness detected signals that Scout may not
-     * have actually finished (e.g. mutation task with zero mutations, budget
-     * exhausted without explicit completion, tool calls followed by text-only exit
-     * without a completion statement).
-     *
-     * This field is set by the harness, not by the LLM — emit_managed_protocol
-     * payloads from models are ignored here and overwritten.
-     */
-    completionConfidence?: 'confident' | 'uncertain';
-    /** Which signals contributed to an 'uncertain' confidence verdict. */
-    suspiciousSignals?: KodaXScoutSuspiciousSignal[];
-}
-interface KodaXManagedContractPayload {
-    summary?: string;
-    successCriteria: string[];
-    requiredEvidence: string[];
-    constraints: string[];
-}
-interface KodaXManagedHandoffPayload {
-    status: 'ready' | 'incomplete' | 'blocked';
-    summary?: string;
-    evidence: string[];
-    followup: string[];
-    userFacingText: string;
-}
 interface KodaXManagedProtocolPayload {
     verdict?: KodaXManagedVerdictPayload;
-    scout?: KodaXManagedScoutPayload;
-    contract?: KodaXManagedContractPayload;
-    handoff?: KodaXManagedHandoffPayload;
 }
 interface KodaXResult {
     success: boolean;
@@ -1661,8 +1666,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 +1717,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 +1796,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 +2466,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, readTrustState as a$, WINDOW_MS as aO, collectAllSignals as aP, computeRulesFingerprint as aQ, createAutoModeToolGuardrail as aR, createBashPrefixExtractor as aS, createCircuitBreaker as aT, createDenialTracker as aU, extractCommandPrefix as aV, formatAgentsForPrompt as aW, getKodaxGlobalDir as aX, loadAgentsFiles as aY, loadAutoRules as aZ, parseAutoRules as a_, recordAllow as b0, recordBlock as b1, recordError as b2, shouldFallback$1 as b3, shouldFallback as b4, trustProjectRules as b5, CUMULATIVE_THRESHOLD as n };
+export type { KodaXRepoIntelligenceMode as $, AgentsFile as A, DenialTracker as D, FailureStage as F, KodaXFanoutBranchRecord as G, KodaXFanoutBranchTransition as H, KodaXFanoutSchedulerInput as I, KodaXFanoutSchedulerPlan as J, KodaXAgentMode as K, KodaXInputArtifact as L, KodaXManagedBudgetSnapshot as M, KodaXManagedProtocolPayload as N, KodaXManagedTask as O, KodaXManagedTaskRuntimeState as P, KodaXManagedTaskStatusEvent as Q, KodaXMcpConnectMode as R, KodaXMcpServerConfig as S, KodaXMcpServersConfig as T, KodaXMcpTransport as U, KodaXMemoryStrategy as V, KodaXOptions as W, KodaXOrchestrationVerdict as X, KodaXParentReductionContract as Y, KodaXProviderPolicyHints as Z, KodaXRepoIntelligenceCapability as _, AskUserMultiOptions as a, KodaXRepoIntelligenceResolvedMode as a0, KodaXRepoIntelligenceTrace as a1, KodaXRepoIntelligenceTraceEvent as a2, KodaXRepoRoutingSignals as a3, KodaXResult as a4, KodaXRoleRoundSummary as a5, KodaXRuntimeVerificationContract as a6, KodaXSessionControl as a7, KodaXSessionMutators as a8, KodaXSessionOptions as a9, RecoveryDecision as aA, RecoveryLadderStep as aB, RecoveryResult as aC, ResilienceClassification as aD, ResilienceErrorClass as aE, RulesLoadError as aF, RulesLoadResult as aG, SignalCollector as aH, SkippedRulesSource as aI, TodoItem as aJ, TodoList as aK, TodoStatus as aL, ToolCallSignal as aM, TrustState as aN, 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, KodaXToolExecutionContext as aq, KodaXVerificationScorecard as ar, KodaXVerificationScorecardCriterion as as, LoadAgentsOptions as at, LoadedRulesSource as au, ProviderExecutionState as av, ProviderRecoveryEvent as aw, ProviderResilienceConfig as ax, ProviderResiliencePolicy as ay, RecoveryAction 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, CreateBashPrefixExtractorOptions as p, ExtensionRuntimeContract as q, ExtractCommandPrefixOptions as r, KodaXBudgetDisclosureZone as s, KodaXBudgetExtensionRequest as t, KodaXChildAgentResult as u, KodaXChildContextBundle as v, KodaXContextOptions as w, KodaXContextTokenSnapshot as x, KodaXEvents as y, KodaXFanoutBranchLifecycle as z };