@kodax-ai/kodax 0.7.43 → 0.7.45

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

@@ -1,11 +1,79 @@
-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 { 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 { 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
  * `inputHint` extraction in `buildChildEvents.onToolUseStart`. */
@@ -323,6 +391,245 @@ interface TodoStore {
     reset(): void;
 }
 
+/**
+ * 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.
+ */
+
+/**
+ * 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 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
  * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
@@ -483,6 +790,162 @@ interface ProviderResiliencePolicy extends ProviderResilienceConfig {
     provider: string;
 }
 
+/**
+ * FEATURE_200 Phase F (v0.7.45) — MCP domain types extracted from types.ts.
+ * Thin KodaX-facing aliases over the @kodax-ai/agent MCP types. Re-exported
+ * from ../types.ts so all `../types` importers are unaffected.
+ */
+
+type KodaXMcpTransport = McpTransportKind;
+type KodaXMcpConnectMode = McpConnectMode;
+type KodaXMcpServerConfig = McpServerConfig;
+/** Flat map of MCP server configs, keyed under `mcpServers` in config.json. */
+type KodaXMcpServersConfig = McpServersConfig;
+
+/**
+ * FEATURE_200 Phase F (v0.7.45) — Todo domain types extracted from types.ts.
+ * Self-contained (no other coding-type deps); re-exported from ../types.ts
+ * so all `../types` importers are unaffected.
+ */
+/**
+ * Status of a planned todo item. Lifecycle: pending → in_progress →
+ * (completed | failed | skipped). Failed items are reset to pending
+ * when the next iteration begins (Evaluator revise verdict). Skipped
+ * is for Planner-side merging of two obligations into one.
+ */
+type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped' | 'cancelled';
+/**
+ * FEATURE_114 v0.7.36: Per-step deterministic evaluator hint. When a
+ * todo item carries an `evaluator`, the runner runs the corresponding
+ * deterministic check (build / test / lint) at the moment its status
+ * transitions to `completed`. Failure surfaces stderr in the next
+ * tool result so the Worker can self-correct. No LLM-as-judge
+ * variant — Phase 0.7 industry survey said 4/4 codebases reject
+ * per-step LLM verification.
+ */
+type TodoEvaluatorHint = 'build' | 'test' | 'lint';
+/**
+ * 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;
+    /** 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). */
+    readonly sourceObligationIndex?: number;
+    /** Optional note attached on a status transition (e.g. failure reason). */
+    readonly note?: string;
+    /**
+     * FEATURE_114 v0.7.36: per-step deterministic evaluator hint. When
+     * present, the runner runs the corresponding deterministic check on
+     * `pending → completed` and surfaces stderr / exit code in the next
+     * tool result on failure.
+     */
+    readonly evaluator?: TodoEvaluatorHint;
+    /**
+     * FEATURE_149 v0.7.38 (Slice C4) — present-continuous form of `content`,
+     * used by the spinner status line while this item is `in_progress`.
+     * Mirrors Claude Code's [`Spinner.tsx:169`](c:/Works/claudecode/src/components/Spinner.tsx#L169)
+     * `currentTodo?.activeForm` lookup. Examples:
+     *   content: "Run failing test"  → activeForm: "Running failing test"
+     *   content: "Refactor auth"     → activeForm: "Refactoring auth"
+     *   content: "Verify build"      → activeForm: "Verifying build"
+     *
+     * Optional. When absent, the spinner falls back to a generic verb (no
+     * regression vs pre-FEATURE_149 behavior). When the LLM provides
+     * activeForm via `todo_update`, the spinner picks it up live without
+     * waiting for the round to end — that's the user-visible "working on X
+     * now" feel CC achieves.
+     */
+    readonly activeForm?: string;
+    /**
+     * FEATURE_170 v0.7.41 — opaque per-task metadata bag carried alongside
+     * the item. Surface for downstream consumers (extension hooks, eval
+     * harnesses, future swarm features) to attach arbitrary structured
+     * context without forcing a schema change. UI does NOT render this.
+     * Empty / undefined when the LLM does not supply it.
+     */
+    readonly metadata?: Record<string, unknown>;
+}
+type TodoList = readonly TodoItem[];
+
+/**
+ * FEATURE_200 Phase F (v0.7.45) — repo-intelligence domain types extracted
+ * from types.ts. Self-contained; re-exported from ../types.ts (and 4 members
+ * re-imported there for internal use). `../types` importers unaffected.
+ */
+type KodaXRepoIntelligenceMode = 'auto' | 'off' | 'oss' | 'premium-shared' | 'premium-native';
+type KodaXRepoIntelligenceResolvedMode = 'off' | 'oss' | 'premium-shared' | 'premium-native';
+interface KodaXRepoIntelligenceCapability {
+    mode: KodaXRepoIntelligenceResolvedMode;
+    engine: 'oss' | 'premium';
+    bridge: 'none' | 'shared' | 'native';
+    level: 'basic' | 'enhanced';
+    status: 'ok' | 'limited' | 'unavailable' | 'warming';
+    warnings: string[];
+    contractVersion?: number;
+}
+interface KodaXRepoIntelligenceTrace {
+    mode: KodaXRepoIntelligenceResolvedMode;
+    engine: 'oss' | 'premium';
+    bridge: 'none' | 'shared' | 'native';
+    triggeredAt: string;
+    source: 'fallback' | 'premium';
+    daemonLatencyMs?: number;
+    cliLatencyMs?: number;
+    cacheHit?: boolean;
+    capsuleBytes?: number;
+    capsuleEstimatedTokens?: number;
+}
+/**
+ * Repo-intelligence retrieval trace event. Emitted by agent / managed-task
+ * pipelines (`emitRepoIntelligenceTrace` / `emitManagedRepoIntelligenceTrace`)
+ * at `routing` / `preturn` / `module` / `impact` / `task-snapshot` stages,
+ * consumed by REPL `json-events` (stdout JSONL contract), `cli-events`
+ * (interactive REPL), and `acp_server`.
+ *
+ * Note: FEATURE_083 (v0.7.24) initially marked this as superseded by
+ * `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,
+ * `capability`, or `trace` bundle. The `stage` enum in particular is a
+ * typed contract that UI consumers (json-events schema) depend on;
+ * flattening it into a bag of attributes would drop type safety and break
+ * downstream script compatibility. This type is therefore a product
+ * feature of repo-intelligence, not legacy trace plumbing.
+ */
+interface KodaXRepoIntelligenceTraceEvent {
+    stage: 'routing' | 'preturn' | 'module' | 'impact' | 'task-snapshot';
+    summary: string;
+    capability?: KodaXRepoIntelligenceCapability;
+    trace?: KodaXRepoIntelligenceTrace;
+}
+
 interface KodaXEvents {
     onTextDelta?: (text: string) => void;
     onThinkingDelta?: (text: string) => void;
@@ -701,6 +1164,22 @@ interface KodaXSessionOptions {
     scope?: KodaXSessionScope;
     storage?: KodaXSessionStorage;
     initialMessages?: KodaXMessage[];
+    /**
+     * Persistence ownership signal (FEATURE_173 dual-writer fix).
+     *
+     * When `true`, a higher-level host (the interactive REPL) owns writing
+     * this session to `storage` — it persists the full lineage / uiHistory /
+     * artifactLedger incrementally via `appendSessionDelta`. The runner MUST
+     * NOT also snapshot the session: `saveSessionSnapshot` early-returns so
+     * the runner's flat full-rewrite `storage.save` can never race / clobber
+     * the host's richer incremental writes (which regressed `activeEntryId`
+     * to the first round on resume).
+     *
+     * `storage` is still consulted for LOAD (resume / `resolveInitialMessages`
+     * tier 2). When absent (print CLI, ACP, SDK headless), the runner remains
+     * the sole writer — unchanged behaviour, fail-safe default.
+     */
+    persistedByHost?: boolean;
 }
 interface KodaXContextTokenSnapshot {
     /** Current best-known token count for the full conversation context. */
@@ -723,143 +1202,6 @@ interface KodaXProviderPolicyHints {
     workIntent?: KodaXTaskWorkIntent;
 }
 
-type KodaXMcpTransport = McpTransportKind;
-type KodaXMcpConnectMode = McpConnectMode;
-type KodaXMcpServerConfig = McpServerConfig;
-/** Flat map of MCP server configs, keyed under `mcpServers` in config.json. */
-type KodaXMcpServersConfig = McpServersConfig;
-type KodaXRepoIntelligenceMode = 'auto' | 'off' | 'oss' | 'premium-shared' | 'premium-native';
-type KodaXRepoIntelligenceResolvedMode = 'off' | 'oss' | 'premium-shared' | 'premium-native';
-interface KodaXRepoIntelligenceCapability {
-    mode: KodaXRepoIntelligenceResolvedMode;
-    engine: 'oss' | 'premium';
-    bridge: 'none' | 'shared' | 'native';
-    level: 'basic' | 'enhanced';
-    status: 'ok' | 'limited' | 'unavailable' | 'warming';
-    warnings: string[];
-    contractVersion?: number;
-}
-interface KodaXRepoIntelligenceTrace {
-    mode: KodaXRepoIntelligenceResolvedMode;
-    engine: 'oss' | 'premium';
-    bridge: 'none' | 'shared' | 'native';
-    triggeredAt: string;
-    source: 'fallback' | 'premium';
-    daemonLatencyMs?: number;
-    cliLatencyMs?: number;
-    cacheHit?: boolean;
-    capsuleBytes?: number;
-    capsuleEstimatedTokens?: number;
-}
-/**
- * Repo-intelligence retrieval trace event. Emitted by agent / managed-task
- * pipelines (`emitRepoIntelligenceTrace` / `emitManagedRepoIntelligenceTrace`)
- * at `routing` / `preturn` / `module` / `impact` / `task-snapshot` stages,
- * consumed by REPL `json-events` (stdout JSONL contract), `cli-events`
- * (interactive REPL), and `acp_server`.
- *
- * Note: FEATURE_083 (v0.7.24) initially marked this as superseded by
- * `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,
- * `capability`, or `trace` bundle. The `stage` enum in particular is a
- * typed contract that UI consumers (json-events schema) depend on;
- * flattening it into a bag of attributes would drop type safety and break
- * downstream script compatibility. This type is therefore a product
- * feature of repo-intelligence, not legacy trace plumbing.
- */
-interface KodaXRepoIntelligenceTraceEvent {
-    stage: 'routing' | 'preturn' | 'module' | 'impact' | 'task-snapshot';
-    summary: string;
-    capability?: KodaXRepoIntelligenceCapability;
-    trace?: KodaXRepoIntelligenceTrace;
-}
-/**
- * Status of a planned todo item. Lifecycle: pending → in_progress →
- * (completed | failed | skipped). Failed items are reset to pending
- * when the next iteration begins (Evaluator revise verdict). Skipped
- * is for Planner-side merging of two obligations into one.
- */
-type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped' | 'cancelled';
-/**
- * FEATURE_114 v0.7.36: Per-step deterministic evaluator hint. When a
- * todo item carries an `evaluator`, the runner runs the corresponding
- * deterministic check (build / test / lint) at the moment its status
- * transitions to `completed`. Failure surfaces stderr in the next
- * tool result so the Worker can self-correct. No LLM-as-judge
- * variant — Phase 0.7 industry survey said 4/4 codebases reject
- * per-step LLM verification.
- */
-type TodoEvaluatorHint = 'build' | 'test' | 'lint';
-/**
- * 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;
-    /** 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). */
-    readonly sourceObligationIndex?: number;
-    /** Optional note attached on a status transition (e.g. failure reason). */
-    readonly note?: string;
-    /**
-     * FEATURE_114 v0.7.36: per-step deterministic evaluator hint. When
-     * present, the runner runs the corresponding deterministic check on
-     * `pending → completed` and surfaces stderr / exit code in the next
-     * tool result on failure.
-     */
-    readonly evaluator?: TodoEvaluatorHint;
-    /**
-     * FEATURE_149 v0.7.38 (Slice C4) — present-continuous form of `content`,
-     * used by the spinner status line while this item is `in_progress`.
-     * Mirrors Claude Code's [`Spinner.tsx:169`](c:/Works/claudecode/src/components/Spinner.tsx#L169)
-     * `currentTodo?.activeForm` lookup. Examples:
-     *   content: "Run failing test"  → activeForm: "Running failing test"
-     *   content: "Refactor auth"     → activeForm: "Refactoring auth"
-     *   content: "Verify build"      → activeForm: "Verifying build"
-     *
-     * Optional. When absent, the spinner falls back to a generic verb (no
-     * regression vs pre-FEATURE_149 behavior). When the LLM provides
-     * activeForm via `todo_update`, the spinner picks it up live without
-     * waiting for the round to end — that's the user-visible "working on X
-     * now" feel CC achieves.
-     */
-    readonly activeForm?: string;
-    /**
-     * FEATURE_170 v0.7.41 — opaque per-task metadata bag carried alongside
-     * the item. Surface for downstream consumers (extension hooks, eval
-     * harnesses, future swarm features) to attach arbitrary structured
-     * context without forcing a schema change. UI does NOT render this.
-     * Empty / undefined when the LLM does not supply it.
-     */
-    readonly metadata?: Record<string, unknown>;
-}
-type TodoList = readonly TodoItem[];
 interface KodaXRepoRoutingSignals {
     workspaceRoot?: string;
     changedFileCount: number;
@@ -983,6 +1325,14 @@ interface KodaXChildContextBundle {
      * preserves byte-identical v0.7.42 baseline dispatch behavior.
      */
     specialistName?: string;
+    /**
+     * FEATURE_102 Phase 2 (v0.7.45) — explicit per-dispatch provider/model the
+     * dispatching agent chose for this child (e.g. a cross-family second review).
+     * Priority in child-executor: `bundle.provider/model` > specialist's declared
+     * model > parent default. Omitting both inherits the parent (byte-identical).
+     */
+    provider?: string;
+    model?: string;
 }
 /**
  * FEATURE_120 v0.7.39 Phase 4 — model tier hint. Tier semantics:
@@ -1302,6 +1652,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;
@@ -1657,6 +2050,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',
@@ -1817,6 +2260,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;
 }
 
 /**
@@ -2466,5 +2921,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-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 };
+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 };