@kodax-ai/kodax 0.7.42 → 0.7.44

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

@@ -1,9 +1,78 @@
-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 { g as KodaXGoalState, s as KodaXSessionLineage, x as KodaXSessionScope, y as KodaXSessionStorage, i as KodaXJsonValue, k as KodaXSessionArtifactLedgerEntry, S as SessionErrorMetadata } from './types.d-HBbWT-iA.js';
+import { W as KodaXTokenUsage, m as KodaXMessage, 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 { f as AgentMessage, av as StopHookFn, C as ChildTaskRegistry, p as CompactionUpdate, v as Guardrail, s as DiscoveredInstance, az as TaskAbortRegistry, aa as RunnerToolCall, aE as ToolGuardrail } from './types.d-DM8zEJgF.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';
+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';
+
+/**
+ * FEATURE_192 v0.7.44 Phase C — Goal-tools execution context.
+ *
+ * The 3 goal tools (`get_goal`, `create_goal`, `update_goal`) read +
+ * mutate persistent goal state. The coding layer does NOT own that
+ * state — it lives in the REPL-side session lineage. Tools call into
+ * this interface, which the runner-driven adapter wires at task start.
+ *
+ * Why an interface (not direct lineage access from the tool):
+ *   1. Lineage mutations need to round-trip through session storage
+ *      (persistence + UI events); the tool shouldn't know that pipe.
+ *   2. The Sidecar Verifier call for `update_goal({complete})` needs
+ *      runtime provider + transcript snapshot — wired at the boundary
+ *      where verifier-provider-resolver runs, not inside the tool.
+ *   3. The 3-turn blocker rule has process-lifetime state that lives
+ *      with the goal runtime, not with the tool registration.
+ *
+ * All three methods are async — both reads (because they may touch
+ * the session storage) and writes (because they persist).
+ */
+
+interface GoalCompleteResult {
+    readonly ok: boolean;
+    /** Present iff `!ok` — explains why complete was rejected. */
+    readonly reason?: string;
+    /** Optional one-line how-to-fix from the verifier. */
+    readonly suggestedFix?: string;
+}
+interface GoalBlockedResult {
+    readonly ok: boolean;
+    /** Status message: success summary or rejection reason. Always set. */
+    readonly statusMessage: string;
+    /** Counter snapshot for transparency / debugging. */
+    readonly counter: {
+        readonly current: number;
+        readonly required: number;
+    };
+}
+interface GoalCreateInput {
+    readonly objective: string;
+    readonly tokenBudget?: number | null;
+}
+interface GoalToolsContext {
+    /** Read current goal state from the session lineage. */
+    readonly readGoal: () => Promise<KodaXGoalState | null>;
+    /** Create a new goal. Throws if an active goal already exists. */
+    readonly createGoal: (input: GoalCreateInput) => Promise<KodaXGoalState>;
+    /**
+     * Request transition to `complete`. Implementation runs the Sidecar
+     * Verifier and returns `{ok:false, reason}` on non-accept. On accept
+     * the lineage gets a new goal entry with `status: 'complete'`.
+     */
+    readonly requestComplete: () => Promise<GoalCompleteResult>;
+    /**
+     * Request transition to `blocked`. Implementation applies the
+     * 3-turn rule via `recordBlockerAttempt` and persists the updated
+     * counter regardless of whether the transition was allowed.
+     */
+    readonly requestBlocked: (blockerKind: string) => Promise<GoalBlockedResult>;
+}
+/**
+ * Module-scoped fallback: when the tool runs without a goal context
+ * wired (e.g. dispatched from a non-REPL test harness), each method
+ * returns a uniform "feature disabled" error so the model gets a
+ * clear signal rather than a silent failure.
+ */
+declare function makeDisabledGoalToolsContext(): GoalToolsContext;
 
 /** One tool-call breadcrumb. Captures only the name + a 60-char input
  * hint so the snapshot stays compact under fan-out. Mirrors the
@@ -61,6 +130,13 @@ interface ChildProgressSnapshot {
     /** 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. */
@@ -316,51 +392,243 @@ interface TodoStore {
 }
 
 /**
- * @kodax-ai/agent Compaction Types
+ * FEATURE_192 v0.7.44 Phase B — Goal lifecycle hook composer.
+ *
+ * Wraps the existing `Runner.run` lifecycle hooks (`beforeNextTurn`,
+ * `stopHook`) with goal-aware behaviour. Does NOT modify substrate —
+ * the agent runtime exposes `beforeNextTurn` (FEATURE_164 v0.7.41) and
+ * `stopHook` (FEATURE_184 v0.7.42) as already-stable hook surfaces;
+ * this module is a thin composer the caller (REPL / driver) opts into.
+ *
+ * Wiring:
+ *   - turn-end accounting → `beforeNextTurn` (fires after each tool
+ *     execution, before the next LLM call)
+ *   - agent_end continuation → `stopHook` (fires on text-only
+ *     termination, can return a continuation prompt to reanimate)
+ *
+ * `enabled: false` returns pass-through wrappers — useful for hosts
+ * that build the binding eagerly but want to no-op when no goal is
+ * active. Goal feature ships default ON in v0.7.44; the `enabled`
+ * knob is for embedders, not user-facing gating.
  */
 
-interface CompactionDetails {
-    readFiles: string[];
-    modifiedFiles: string[];
+/**
+ * Caller-supplied accessors for the goal lifecycle context. The
+ * composer does NOT own goal state — it reads via getters and writes
+ * via the persist callback. This keeps the composer reentrant and
+ * test-friendly (no global mutable cache).
+ */
+interface GoalLifecycleContext {
+    /** Returns the current goal state, or null when no active goal. */
+    readonly getGoal: () => KodaXGoalState | null;
+    /**
+     * Returns the latest LLM token usage from the just-completed turn.
+     * Returns undefined when usage is unavailable (e.g. mid-turn
+     * before any LLM call). Optional — accounting is skipped when null.
+     */
+    readonly getLatestUsage?: () => KodaXTokenUsage | undefined;
+    /**
+     * Returns the wall-clock timestamp (Date.now() ms) at the start of
+     * the turn just completed. The composer pairs this with Date.now()
+     * at hook fire time to derive `timeUsedSeconds` delta. Optional —
+     * when unset, wall-time is not charged (mirror legacy behaviour;
+     * callers without a per-turn clock anchor get token accounting only).
+     */
+    readonly getTurnStartMs?: () => number | undefined;
+    /**
+     * Returns the current permission mode. When `'plan'`, accounting is
+     * skipped (plan mode runs are not charged against the goal budget).
+     * Optional — when not provided, accounting always runs on active goals.
+     */
+    readonly getPermissionMode?: () => string | undefined;
+    /**
+     * Persist a goal state transition. Caller wires this to
+     * `appendGoalEntry` + session storage. The composer awaits — failures
+     * propagate to the runner (deliberate: a broken persist is a real
+     * bug worth surfacing, not silently swallowing).
+     */
+    readonly persistEvent: (state: KodaXGoalState | null, event: 'updated' | 'budget_limited' | 'complete' | 'blocked') => Promise<void>;
+    /**
+     * Build the continuation prompt body the stop-hook returns when the
+     * active goal should resume. Caller controls the prompt content so
+     * the same composer works for both Codex-parity literal continuation
+     * and any future variants.
+     */
+    readonly buildContinuationPrompt: (goal: KodaXGoalState) => string;
+    /**
+     * Returns true when the queue has pending user-priority messages.
+     * When pending messages exist, the goal SHOULD NOT autonomously
+     * continue — the user is steering and the next turn will pick up
+     * their input naturally. Optional — defaults to "no pending".
+     */
+    readonly hasPendingUserInput?: () => boolean;
 }
-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;
+interface BeforeNextTurnFnCtx {
+    readonly transcript: readonly AgentMessage[];
+    readonly iteration: number;
 }
+type BeforeNextTurnFn = (ctx: BeforeNextTurnFnCtx) => Promise<readonly AgentMessage[]>;
+/**
+ * Wrap an existing `beforeNextTurn` callback with goal accounting.
+ * Returned hook:
+ *   1. Calls into the goal lifecycle ctx FIRST (read latest usage,
+ *      apply token delta, persist on budget cross)
+ *   2. Delegates to the inner hook for the original behaviour
+ *      (mid-turn user-prompt injection, etc.)
+ *
+ * Errors thrown by `persistEvent` propagate. Errors from `inner` also
+ * propagate. We don't swallow either — goal lifecycle bugs are real.
+ */
+declare function withGoalBeforeNextTurn(ctx: GoalLifecycleContext, inner: BeforeNextTurnFn, options?: {
+    enabled: boolean;
+}): BeforeNextTurnFn;
+/**
+ * Wrap an existing `stopHook` with goal-driven continuation.
+ *
+ * Returned hook fires the inner hook FIRST (sidecar verifier wins on
+ * `revise` / `blocked`). If the inner hook returns `undefined` AND
+ * there's an active goal AND no pending user input, the wrapper
+ * returns a continuation string so the Runner reanimates the loop —
+ * Codex `/goal` parity.
+ *
+ * Budget exhaustion semantics: when the active goal has already
+ * flipped to `budget_limited`, the wrapper does NOT continue. The user
+ * must explicitly resume (`/goal resume`) or set a new budget.
+ *
+ * Reanimate budget: the Runner caps reanimate via
+ * `stopHookReanimateBudget` (default 2). The composer does not need to
+ * track its own budget — exceeding the budget is converted by the
+ * Runner to an abort with reason "reanimate budget exhausted", which
+ * surfaces to the user.
+ */
+declare function withGoalStopHook(ctx: GoalLifecycleContext, inner: StopHookFn | undefined, options?: {
+    enabled: boolean;
+}): StopHookFn;
+
+/**
+ * FEATURE_192 v0.7.44 Phase F — Goal runtime binding factory.
+ *
+ * REPL (or any host that owns a `KodaXSessionLineage`) calls
+ * `buildGoalRuntimeBinding(deps)` once per `runManagedTask` invocation
+ * and passes the returned binding via
+ * `KodaXOptions.context.goalRuntime`. The runner-driven adapter wires:
+ *   - `binding.goalContext` onto the tool-execution context (so the
+ *     3 goal tools can read/mutate state),
+ *   - `binding.lifecycleCtx` into `withGoalBeforeNextTurn` /
+ *     `withGoalStopHook` (turn-end accounting + continuation reanimate).
+ *
+ * Why a factory instead of host-side ad-hoc wiring:
+ *   - Pulls the lineage-read + persist + sidecar-verifier-call wiring
+ *     into one well-tested entry point so the host (REPL today; any
+ *     future SDK consumer) doesn't have to re-implement the same glue.
+ *   - The factory is the seam where v0.7.45+ extensions (e.g.
+ *     objective-updated steering, multi-goal across forks) land
+ *     without breaking the runner-driven contract.
+ *
+ * The factory does NOT own state — every accessor is a function the
+ * caller wires (`getLineage` reads from REPL's `context.lineage`,
+ * `saveSession` flushes to disk, etc.). This keeps the binding
+ * reentrant and test-friendly.
+ *
+ * Codex parity: the default `buildContinuationPrompt` mirrors codex's
+ * `core/templates/goals/continuation.md` verbatim in structure and
+ * intent — Continuation behavior / Budget / Work from evidence /
+ * Progress visibility / Fidelity / Completion audit / Blocked audit —
+ * with 6 documented KodaX-specific deviations (see the function
+ * JSDoc below for the full list). Two of the six are trailing
+ * "Runtime enforcement" paragraphs that make the KodaX runtime gates
+ * legible to the model (Sidecar Verifier on Completion audit + 3-turn
+ * counter on Blocked audit) so the model does not waste a turn being
+ * rejected; they do not replace the Codex teaching, they complement it.
+ *
+ * The earlier v0.7.44 draft trimmed this prompt aggressively under
+ * ADR-033 §4 ("no enumerated taxonomies"). That was a mechanical
+ * misapplication — Codex's Completion-audit enumerated list
+ * ("requirements / artifacts / commands / tests / gates / invariants /
+ * deliverables") names AUDIT DIMENSIONS, not the classification
+ * taxonomies §4 was written against ("RULE A/B/C/D" labels). The
+ * trim correlated with a Layer 2 C1 simple-continuation panel rate
+ * of 53% on the canonical 3-active-alias panel; restoring the Codex-
+ * faithful sections is the v0.7.44 follow-up before tagging.
+ * See: [[feedback_adr_033_scope_clarification_new_feature]].
+ *
+ * Progress visibility cites KodaX's `todo_*` tools (FEATURE_170 v0.7.41
+ * todo V2) rather than Codex's `update_plan`, since KodaX does not have
+ * `update_plan` but the equivalent multi-step planning surface lives
+ * in `todo_create` / `todo_update` / `todo_list` / `todo_get`.
+ */
+
+/**
+ * Dependencies the host (REPL) wires into the binding. Everything is
+ * a callback because the binding has no opinion on storage — the host
+ * owns the lineage handle + flush pipe.
+ */
+interface GoalRuntimeBindingDeps {
+    /** Returns the current session lineage. May throw if no lineage. */
+    readonly getLineage: () => KodaXSessionLineage;
+    /** Replace the host's lineage handle after a goal entry is appended. */
+    readonly setLineage: (next: KodaXSessionLineage) => void;
+    /** Flush the host's session storage. Awaited by the binding. */
+    readonly saveSession: () => Promise<void>;
+    /**
+     * Returns the latest LLM token usage from the just-completed turn.
+     * Wired by the host to the runner-driven `tokenStateRef.current.lastUsage`.
+     * Returns undefined before the first LLM call.
+     */
+    readonly getLatestUsage: () => KodaXTokenUsage | undefined;
+    /**
+     * Returns the wall-clock `Date.now()` ms at the start of the
+     * just-completed turn. The binding pairs it with `Date.now()` at
+     * hook fire time to derive `timeUsedSeconds` delta.
+     */
+    readonly getTurnStartMs: () => number | undefined;
+    /**
+     * Returns the current permission mode (`'plan'` skips accounting).
+     * Optional — host may omit if it never enters plan mode.
+     */
+    readonly getPermissionMode?: () => string | undefined;
+    /**
+     * Returns true when user-priority messages are pending on the main
+     * queue. When pending, the binding does NOT autonomously continue —
+     * the next turn's drain handles user input naturally.
+     */
+    readonly hasPendingUserInput: () => boolean;
+    /**
+     * Verifier hook for `update_goal({complete})`. Implemented by the
+     * coding layer's sidecar-verifier-bind helper; host passes the same
+     * function through.
+     */
+    readonly verifyComplete: (goal: KodaXGoalState) => Promise<GoalCompleteResult>;
+}
+interface GoalRuntimeBinding {
+    readonly goalContext: GoalToolsContext;
+    readonly lifecycleCtx: GoalLifecycleContext;
+    /**
+     * Replace the verifyComplete implementation at runtime.
+     *
+     * The REPL constructs the binding eagerly (before the runner exists)
+     * and supplies a stub verifyComplete. The runner-driven adapter
+     * then has access to runner-local context the REPL doesn't
+     * (transcript ref, mutation tracker, resolved verifier provider/
+     * model) and installs a real F184-backed verifier via this method.
+     *
+     * Idempotent: calling more than once just replaces the slot. The
+     * `goalContext.requestComplete` closure reads the slot fresh on
+     * every invocation, so any later swap is observed immediately.
+     *
+     * Called only from `buildRunnerGoalAdapter` in production; tests
+     * may also call it directly when exercising the goal-complete
+     * verifier path without a full runner harness.
+     */
+    readonly installVerifyComplete: (fn: GoalRuntimeBindingDeps['verifyComplete']) => void;
+}
+/**
+ * Build the binding. Pure factory — no global state, no side effects
+ * at construction; effects happen when the runner-driven adapter
+ * invokes the wrapped hooks or when a tool calls
+ * `goalContext.{readGoal,createGoal,requestComplete,requestBlocked}`.
+ */
+declare function buildGoalRuntimeBinding(deps: GoalRuntimeBindingDeps): GoalRuntimeBinding;
 
 /**
  * FEATURE_093 (v0.7.24): minimal contract interface for the coding extension
@@ -798,7 +1066,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,
@@ -1011,6 +1279,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:
@@ -1330,6 +1609,49 @@ interface KodaXContextOptions {
      * plan-mode enforcement.
      */
     planModeBlockCheck?: (tool: string, input: Record<string, unknown>) => string | null;
+    /**
+     * FEATURE_123 v0.7.44 — propagate the current agent's id into the
+     * spawned runtime so its tools can self-identify (and so peer
+     * `send_message` calls can stamp a `from=...` framing tag + reject
+     * self-targeted sends).
+     */
+    currentAgentId?: string;
+    /**
+     * FEATURE_123 v0.7.44 — propagate the dispatching agent's id (the
+     * parent of the soon-to-be-spawned runtime) so `send_message(to:
+     * "worker")` from a grand-child routes to its direct parent rather
+     * than the top-level Worker.
+     */
+    parentAgentId?: string;
+    /**
+     * FEATURE_123 v0.7.44 — when set, the spawned runtime's
+     * `ctx.childTaskRegistry` reuses this Map instead of allocating a
+     * fresh one. Children pass the parent's registry through so peer
+     * routing (`send_message` to a sibling task_id) finds the target.
+     * Children remain unable to mutate the registry because
+     * `dispatch_child_task` stays in `CHILD_EXCLUDE_TOOLS_BASE`.
+     */
+    inheritedChildTaskRegistry?: ChildTaskRegistry<KodaXChildExecutionResult>;
+    /**
+     * FEATURE_192 v0.7.44 Phase F — `/goal` runtime binding.
+     *
+     * When set, the runner-driven adapter:
+     *   1. Wires `binding.goalContext` onto the tool-execution context
+     *      so the 3 goal tools (get_goal / create_goal / update_goal)
+     *      read + mutate live state.
+     *   2. Wraps the `beforeNextTurn` hook with `withGoalBeforeNextTurn`
+     *      for turn-end token + wall-time accounting and budget-limit
+     *      transitions.
+     *   3. Wraps the `stopHook` with `withGoalStopHook` so a Worker
+     *      text-only termination with an active goal returns a
+     *      continuation prompt (auto-continue on goal).
+     *
+     * Constructed by the REPL via `buildGoalRuntimeBinding(deps)` from
+     * `packages/coding/src/goal/runtime-wiring.ts`. When undefined, the
+     * tool context falls back to `makeDisabledGoalToolsContext()` and
+     * the lifecycle hooks pass through unmodified.
+     */
+    goalRuntime?: GoalRuntimeBinding;
 }
 interface KodaXOptions {
     provider: string;
@@ -1469,7 +1791,6 @@ interface KodaXOrchestrationVerdict {
     signalReason?: string;
     signalDebugReason?: string;
     disposition?: 'complete' | 'blocked' | 'needs_continuation';
-    continuationSuggested?: boolean;
 }
 interface KodaXManagedTaskRuntimeState {
     amaProfile?: KodaXAmaProfile;
@@ -1491,24 +1812,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;
@@ -1563,7 +1866,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.
@@ -1576,72 +1878,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;
@@ -1758,6 +2007,56 @@ interface KodaXToolExecutionContext {
         readonly model?: string;
         readonly reasoningMode?: KodaXReasoningMode;
     };
+    /**
+     * FEATURE_123 v0.7.44 — agentId of the agent whose tool call this
+     * context backs. `undefined` for the top-level Worker (main runtime
+     * loop); set to the child's `bundle.id` for sub-agent runtimes.
+     *
+     * Consumed by `send_message` to:
+     *   - know who "self" is for broadcast self-exclusion and for the
+     *     `from=...` framing tag,
+     *   - reject self-targeted sends as a single-hop cycle guard.
+     *
+     * Wired by `child-executor.executeReadChild` / `executeWriteChild`
+     * via `options.context.currentAgentId`.
+     */
+    currentAgentId?: string;
+    /**
+     * FEATURE_123 v0.7.44 — agentId of the agent that dispatched the one
+     * owning this context. `undefined` for the Worker (top of the tree)
+     * and for first-tier children (parent == Worker; routing uses the
+     * `'worker'` sentinel rather than an agentId). Set for grand-child
+     * runtimes whose parent is itself a child.
+     *
+     * Consumed by `send_message` when `to === 'worker'`:
+     *   - If `parentAgentId` is set, route to that specific id.
+     *   - If `parentAgentId` is undefined, route to `agentId: undefined`
+     *     (the main loop / top Worker).
+     */
+    parentAgentId?: string;
+    /**
+     * FEATURE_123 v0.7.44 — per-turn `send_message` flood throttle counter.
+     *
+     * Mutable ref that the `send_message` tool increments on every
+     * outbound enqueue (broadcast counts as N — one per recipient).
+     * `runner-driven.ts`' `beforeNextTurn` resets `count = 0` at every
+     * turn boundary so the limit is "per LLM turn", matching the
+     * design's "≤5 per child-turn / ≤20 per Worker-turn".
+     *
+     * The cap chosen by `send_message` is per-call:
+     *   - Worker (`currentAgentId === undefined`): 20 outbound enqueues
+     *     per turn — Worker is the coordinator + has the higher fan-out
+     *     budget.
+     *   - Child (`currentAgentId !== undefined`): 5 outbound enqueues
+     *     per turn — peer chatter that goes over this is almost always
+     *     a misfire (storm vs coordination).
+     *
+     * When undefined (sync-mode dispatch, no async substrate), the
+     * throttle is bypassed.
+     */
+    sendMessageTurnCounter?: {
+        count: number;
+    };
     /**
      * @deprecated FEATURE_067: Removed — use reportToolProgress instead.
      * Previously fired onManagedTaskStatus with activeWorkerId='child',
@@ -1918,6 +2217,18 @@ interface KodaXToolExecutionContext {
      * it into child `runKodaX` calls).
      */
     childProgressSnapshots?: Map<string, ChildProgressSnapshot>;
+    /**
+     * FEATURE_192 v0.7.44 — `/goal` Persistent Goal runtime hook.
+     *
+     * Wired by the REPL adapter for every session with a lineage. When
+     * undefined (sync-dispatch / isolated test harness), the 3 goal
+     * tools (`get_goal` / `create_goal` / `update_goal`) fall back to a
+     * uniform-error context (`makeDisabledGoalToolsContext`) so the
+     * model gets a clear signal rather than a silent failure.
+     *
+     * See `packages/coding/src/goal/tools-context.ts`.
+     */
+    goalContext?: GoalToolsContext;
 }
 
 /**
@@ -2567,5 +2878,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-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 };
+export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, createCircuitBreaker as a$, WINDOW_MS as aV, buildGoalRuntimeBinding as aW, collectAllSignals as aX, computeRulesFingerprint as aY, createAutoModeToolGuardrail as aZ, createBashPrefixExtractor as a_, createDenialTracker as b0, extractCommandPrefix as b1, formatAgentsForPrompt as b2, getKodaxGlobalDir as b3, loadAgentsFiles as b4, loadAutoRules as b5, makeDisabledGoalToolsContext as b6, parseAutoRules as b7, readTrustState as b8, recordAllow as b9, recordBlock as ba, recordError as bb, shouldFallback$1 as bc, shouldFallback as bd, trustProjectRules as be, withGoalBeforeNextTurn as bf, withGoalStopHook as bg, CUMULATIVE_THRESHOLD as n };
+export type { KodaXMcpTransport as $, AgentsFile as A, DenialTracker as D, FailureStage as F, GoalBlockedResult as G, KodaXChildAgentResult as H, KodaXChildContextBundle as I, KodaXContextOptions as J, KodaXAgentMode as K, KodaXContextTokenSnapshot as L, KodaXEvents as M, KodaXFanoutBranchLifecycle as N, KodaXFanoutBranchRecord as O, KodaXFanoutBranchTransition as P, KodaXFanoutSchedulerInput as Q, KodaXFanoutSchedulerPlan as R, KodaXInputArtifact as S, KodaXManagedBudgetSnapshot as T, KodaXManagedProtocolPayload as U, KodaXManagedTask as V, KodaXManagedTaskRuntimeState as W, KodaXManagedTaskStatusEvent as X, KodaXMcpConnectMode as Y, KodaXMcpServerConfig as Z, KodaXMcpServersConfig as _, AskUserMultiOptions as a, KodaXMemoryStrategy as a0, KodaXOptions as a1, KodaXOrchestrationVerdict as a2, KodaXParentReductionContract as a3, KodaXProviderPolicyHints as a4, KodaXRepoIntelligenceCapability as a5, KodaXRepoIntelligenceMode as a6, KodaXRepoIntelligenceResolvedMode as a7, KodaXRepoIntelligenceTrace as a8, KodaXRepoIntelligenceTraceEvent as a9, LoadAgentsOptions as aA, LoadedRulesSource as aB, ProviderExecutionState as aC, ProviderRecoveryEvent as aD, ProviderResilienceConfig as aE, ProviderResiliencePolicy as aF, RecoveryAction as aG, RecoveryDecision as aH, RecoveryLadderStep as aI, RecoveryResult as aJ, ResilienceClassification as aK, ResilienceErrorClass as aL, RulesLoadError as aM, RulesLoadResult as aN, SignalCollector as aO, SkippedRulesSource as aP, TodoItem as aQ, TodoList as aR, TodoStatus as aS, ToolCallSignal as aT, TrustState as aU, KodaXRepoRoutingSignals as aa, KodaXResult as ab, KodaXRoleRoundSummary as ac, KodaXRuntimeVerificationContract as ad, KodaXSessionControl as ae, KodaXSessionMutators as af, KodaXSessionOptions as ag, KodaXSkillInvocationContext as ah, KodaXSkillMap as ai, KodaXSkillProjectionConfidence as aj, KodaXTaskCapabilityHint as ak, KodaXTaskContract as al, KodaXTaskEvidenceArtifact as am, KodaXTaskEvidenceBundle as an, KodaXTaskEvidenceEntry as ao, KodaXTaskRole as ap, KodaXTaskRoleAssignment as aq, KodaXTaskStatus as ar, KodaXTaskSurface as as, KodaXTaskToolPolicy as at, KodaXTaskVerificationContract as au, KodaXTaskVerificationCriterion as av, KodaXTaskWorkItem as aw, KodaXToolExecutionContext as ax, KodaXVerificationScorecard as ay, KodaXVerificationScorecardCriterion 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, GoalCompleteResult as s, GoalCreateInput as t, GoalLifecycleContext as u, GoalRuntimeBinding as v, GoalRuntimeBindingDeps as w, GoalToolsContext as x, KodaXBudgetDisclosureZone as y, KodaXBudgetExtensionRequest as z };