@kodax-ai/kodax 0.7.46 → 0.7.48

package/dist/sdk-session.js

@@ -1,2 +1,2 @@
 // @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{bc as s,cc as e,dc as n,ec as i,fc as o,gc as S,hc as t,ic as a,jc as r,kc as l,lc as c}from"./chunks/chunk-JRT447X5.js";import"./chunks/chunk-K4RBLNSY.js";import"./chunks/chunk-Z4UT32NN.js";import"./chunks/chunk-EVIDQWMF.js";import"./chunks/chunk-XUEINS3X.js";import"./chunks/chunk-2GEKCIIW.js";import"./chunks/chunk-VBIVZOSD.js";import"./chunks/chunk-V4WSBIXB.js";export{a as archiveSession,c as createSessionManager,t as deleteSession,n as forkSession,S as listRunningSessions,s as listSessions,e as loadSession,i as rewindSession,o as setActiveEntry,r as unarchiveSession,l as watchSessions};
+import{bc as s,cc as e,dc as n,ec as i,fc as o,gc as S,hc as t,ic as a,jc as r,kc as l,lc as c}from"./chunks/chunk-UHAP234X.js";import"./chunks/chunk-6Z75SHX3.js";import"./chunks/chunk-DEODZG6Q.js";import"./chunks/chunk-EVIDQWMF.js";import"./chunks/chunk-LNJNRREL.js";import"./chunks/chunk-66B6ZOU7.js";import"./chunks/chunk-EP46H5P3.js";import"./chunks/chunk-V4WSBIXB.js";export{a as archiveSession,c as createSessionManager,t as deleteSession,n as forkSession,S as listRunningSessions,s as listSessions,e as loadSession,i as rewindSession,o as setActiveEntry,r as unarchiveSession,l as watchSessions};

package/dist/sdk-skills.js

@@ -1,2 +1,2 @@
 // @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{$b as E,Ab as e,Bb as i,Cb as t,Db as a,Eb as o,Ib as k,Jb as r,Kb as S,Lb as s,Mb as n,Nb as g,Ob as u,Pb as c,Qb as x,Rb as d,Sb as P,Tb as R,Ub as h,Vb as p,Wb as v,Xb as y,Yb as M,Zb as f,_b as m,zb as l}from"./chunks/chunk-VBIVZOSD.js";import"./chunks/chunk-V4WSBIXB.js";export{y as SkillExecutor,R as SkillRegistry,x as VariableResolver,t as clearPluginSkillPaths,M as createExecutor,d as createResolver,n as discoverSkills,u as discoverSkillsWithMonorepo,f as executeSkill,m as expandSkillForLLM,E as formatSkillActivationMessage,a as getDefaultSkillPaths,g as getNestedSkillPaths,o as getSkillPathsFlat,h as getSkillRegistry,p as initializeSkillRegistry,i as listPluginSkillPaths,S as loadFullSkill,s as loadSkillFileContent,r as loadSkillMetadata,c as parseArguments,k as parseSkillMarkdown,l as registerPluginSkillPath,v as resetSkillRegistry,P as resolveSkillContent,e as unregisterPluginSkillPath};
+import{Ub as l,Vb as e,Wb as i,Xb as t,Yb as a,Zb as o,bc as k,cc as r,dc as S,ec as s,fc as n,gc as g,hc as u,ic as c,jc as x,kc as d,lc as P,mc as R,nc as h,oc as p,pc as v,qc as y,rc as M,sc as f,tc as m,uc as E}from"./chunks/chunk-EP46H5P3.js";import"./chunks/chunk-V4WSBIXB.js";export{y as SkillExecutor,R as SkillRegistry,x as VariableResolver,t as clearPluginSkillPaths,M as createExecutor,d as createResolver,n as discoverSkills,u as discoverSkillsWithMonorepo,f as executeSkill,m as expandSkillForLLM,E as formatSkillActivationMessage,a as getDefaultSkillPaths,g as getNestedSkillPaths,o as getSkillPathsFlat,h as getSkillRegistry,p as initializeSkillRegistry,i as listPluginSkillPaths,S as loadFullSkill,s as loadSkillFileContent,r as loadSkillMetadata,c as parseArguments,k as parseSkillMarkdown,l as registerPluginSkillPath,v as resetSkillRegistry,P as resolveSkillContent,e as unregisterPluginSkillPath};

package/dist/types-chunks/{bash-prefix-extractor.d-BICYx8pt.d.ts → bash-prefix-extractor.d-DNO2-ycp.d.ts}

@@ -1,7 +1,8 @@
-import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-BfJUXxC0.js';
+import { M as McpConnectMode, a as McpServerConfig, b as McpServersConfig, c as McpTransportKind } from './config.d-CJy1WENT.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-B_MIIApc.js';
 import { X as KodaXTokenUsage, n as KodaXMessage, E as KodaXReasoningMode, k as KodaXHarnessProfile, S as KodaXTaskWorkIntent, I as KodaXReviewScale, O as KodaXTaskComplexity, a as KodaXAmaFanoutClass, Q as KodaXTaskRoutingDecision, R as KodaXTaskType, J as KodaXRiskLevel, i as KodaXExecutionMode, c as KodaXAmaProfile, d as KodaXAmaTactic, b as KodaXAmaFanoutPolicy } from './types.d-Cf-GCzac.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-D2RNa5Y7.js';
+import { f as AgentMessage, ay as StopHookFn, C as ChildTaskRegistry, s as CompactionUpdate, m as AskUserQuestionOptions, k as AskUserMultiOptions, y as Guardrail, v as DiscoveredInstance, aC as TaskAbortRegistry, ad as RunnerToolCall, aH as ToolGuardrail } from './types.d-BCnbYG_A.js';
+import { Diagnostic, Position, Location, Hover, DocumentSymbol, SymbolInformation } from 'vscode-languageserver-protocol';
 import { C as CapabilityKind, b as CapabilityResult } from './capability.d-3C62G8Eq.js';
 import { K as KodaXBaseProvider } from './base.d-BdJKSPO2.js';
 import { a as CostTracker } from './cost-tracker.d-wRtyEW9d.js';
@@ -391,6 +392,200 @@ interface TodoStore {
     reset(): void;
 }
 
+/**
+ * FEATURE_132 — language-server registry + discovery (cascade step ①).
+ *
+ * Each `LspServerInfo` is data describing one server: which languageIds it
+ * serves, the project-root markers it should be rooted at, how to discover
+ * an installed binary, an optional opt-in `acquire()` (cascade step ②), and
+ * one line of actionable install guidance for when it is absent (step ③).
+ * Adding a language = appending one entry here (data-driven, LLM-First).
+ *
+ * Phase A: TypeScript/JavaScript. Phase B: Python (pyright) + Go (gopls).
+ * Phase C appends Rust, Java.
+ */
+
+/** A resolved server launch: program + args + optional init options. */
+interface LspServerLaunch {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly initializationOptions?: Record<string, unknown>;
+}
+interface DiscoverContext {
+    /** Project root the server will be rooted at. */
+    readonly root: string;
+    /** `import.meta.url` of the LSP module, used for bundled-TypeScript fallback. */
+    readonly moduleUrl?: string;
+}
+interface AcquireContext {
+    readonly root: string;
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (message: string) => void;
+    readonly debug?: (message: string) => void;
+}
+interface LspServerInfo {
+    readonly id: string;
+    readonly languageIds: readonly string[];
+    readonly rootMarkers: readonly string[];
+    /** Locate an installed server, or `undefined` if not installed. */
+    discover(ctx: DiscoverContext): LspServerLaunch | undefined;
+    /**
+     * Opt-in auto-install (only attempted when `KODAX_LSP_DOWNLOAD=1`). Installs
+     * the server, then returns its launch (typically by re-running discovery).
+     * Absent for servers KodaX won't auto-install.
+     */
+    acquire?(ctx: AcquireContext): Promise<LspServerLaunch | undefined>;
+    /** One actionable line shown when discovery + acquire fail (step ③). */
+    readonly installGuidance: string;
+}
+/** All servers KodaX knows how to drive. */
+declare const LSP_SERVERS: readonly LspServerInfo[];
+
+/**
+ * FEATURE_132 — JSON-RPC LSP client (one spawned server, one project root).
+ *
+ * Push-diagnostics model: after `didOpen`/`didChange`, the server emits
+ * `textDocument/publishDiagnostics`; we cache the latest set per file and
+ * let callers wait (debounced) for a fresh publish. All five servers KodaX
+ * targets (typescript-language-server, pyright, gopls, rust-analyzer, jdtls)
+ * push diagnostics, so we deliberately do NOT port opencode's pull-diagnostic
+ * machinery (YAGNI — add it only if a future server requires it).
+ *
+ * Navigation requests (definition/hover/references/symbols) are added in
+ * Phase E.
+ */
+
+interface DiagnosticsWaitOptions {
+    /** Only a publish with timestamp ≥ this counts as fresh (set before notify). */
+    readonly afterMs: number;
+    /** Give up waiting after this long and return what we have. */
+    readonly timeoutMs: number;
+}
+interface LspClient {
+    readonly serverId: string;
+    readonly root: string;
+    /**
+     * Send didOpen (first touch) or didChange (subsequent) for a file, and
+     * return the timestamp the notification was sent — pass it as
+     * `waitForDiagnostics`'s `afterMs` so only a publish triggered by THIS
+     * change counts as fresh.
+     */
+    notifyOpenOrChange(file: string): Promise<number>;
+    /** Resolve once a fresh diagnostics publish arrives for the file, or on timeout. */
+    waitForDiagnostics(file: string, options: DiagnosticsWaitOptions): Promise<void>;
+    /** Latest cached diagnostics for a file (empty when none/unknown). */
+    diagnostics(file: string): readonly Diagnostic[];
+    /** Resolve the definition site(s) of the symbol at a position. */
+    definition(file: string, position: Position): Promise<Location[]>;
+    /** Type/signature/doc hover for the symbol at a position (null if none). */
+    hover(file: string, position: Position): Promise<Hover | null>;
+    /** All references to the symbol at a position (incl. its declaration). */
+    references(file: string, position: Position): Promise<Location[]>;
+    /** The document's symbol outline. */
+    documentSymbols(file: string): Promise<Array<DocumentSymbol | SymbolInformation>>;
+    /** Graceful shutdown (await server exit so the OS releases handles). */
+    shutdown(): Promise<void>;
+    /** Synchronous best-effort kill, for a `process.on('exit')` last resort. */
+    killSync(): void;
+}
+interface CreateLspClientParams {
+    readonly serverId: string;
+    readonly root: string;
+    readonly launch: LspServerLaunch;
+    readonly initializeTimeoutMs?: number;
+    readonly debug?: (message: string) => void;
+}
+
+/**
+ * FEATURE_132 — LSP service: spawns/caches one client per (root, server) and
+ * exposes the post-edit diagnostics façade the write-family tools call.
+ *
+ * State machine mirrors opencode:
+ *   - `clients`  — live clients, keyed `root|serverId`.
+ *   - `broken`   — keys that failed discovery or startup; skipped forever
+ *                  (no retry storm — a one-shot blacklist).
+ *   - `spawning` — in-flight startups, so concurrent edits never double-spawn.
+ *
+ * `getDiagnosticsBlock` is deliberately SILENT when no server is installed
+ * (returns `""`): nagging an install hint on every edit would be noise.
+ * Install guidance is surfaced on explicit, user-initiated surfaces instead
+ * (Phase E navigation tools / status), not the diagnostics reflux path.
+ */
+
+/** Per-edit hints the service needs to root + cancel work. */
+interface DiagnosticsRequest {
+    /** Project root (git root) — bounds the upward root-marker search. */
+    readonly gitRoot?: string;
+    /** Cancels the work when the host aborts the turn. */
+    readonly signal?: AbortSignal;
+    /** Live progress line (e.g. "Starting typescript language server…"). */
+    readonly onProgress?: (message: string) => void;
+}
+interface LspServiceConfig {
+    /** `import.meta.url` used to resolve the bundled TypeScript fallback. */
+    readonly moduleUrl?: string;
+    /** How long to wait for a fresh diagnostics publish per file. Default 5s. */
+    readonly documentTimeoutMs?: number;
+    /** Server registry override (tests). Defaults to {@link LSP_SERVERS}. */
+    readonly servers?: readonly LspServerInfo[];
+    /** Client factory override (tests). Defaults to {@link createLspClient}. */
+    readonly createClient?: (params: CreateLspClientParams) => Promise<LspClient>;
+    /** Debug sink (off unless wired). */
+    readonly debug?: (message: string) => void;
+}
+declare class LspService {
+    private readonly config;
+    private readonly clients;
+    private readonly broken;
+    private readonly spawning;
+    private readonly servers;
+    private shuttingDown;
+    constructor(config?: LspServiceConfig);
+    /**
+     * Touch a just-written file and return an appendable diagnostics block
+     * (`"\n\n…"`) when the language server reports errors, or `""` when there
+     * are none / no server is available. Never throws.
+     */
+    getDiagnosticsBlock(file: string, request?: DiagnosticsRequest): Promise<string>;
+    /** Definition site(s) of the symbol at `position` (0-based), as text. */
+    getDefinition(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** Hover (type/signature/doc) for the symbol at `position` (0-based). */
+    getHover(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** All references to the symbol at `position` (0-based), as text. */
+    getReferences(file: string, position: Position, request?: DiagnosticsRequest): Promise<string>;
+    /** The file's symbol outline, as indented text. */
+    getDocumentSymbols(file: string, request?: DiagnosticsRequest): Promise<string>;
+    /**
+     * Resolve the primary client for a navigation request, opening the file so
+     * the server has current content. Returns guidance text when no server is
+     * installed (navigation is user-initiated, so — unlike diagnostics — it is
+     * NOT silent), or an unsupported message for non-LSP file types.
+     */
+    private navClient;
+    /** Shut down all spawned servers gracefully (call on session teardown). */
+    shutdownAll(): Promise<void>;
+    /** Synchronous best-effort kill of all servers — for `process.on('exit')`. */
+    killAllSync(): void;
+    /**
+     * Clear the broken blacklist so a server that failed earlier (e.g. installed
+     * mid-session, or a transient startup failure) can be retried. Pass a
+     * `root|serverId` key to clear one entry, or omit to clear all.
+     */
+    resetBroken(key?: string): void;
+    private getClient;
+    private spawnClient;
+    /** Cascade step ②: opt-in auto-install, only when the user enabled it. */
+    private acquireIfEnabled;
+}
+/**
+ * Process-wide default service used by the write-family tools when the host
+ * does not inject one. `KODAX_LSP=0` disables it entirely (returns undefined,
+ * so tools no-op). `KODAX_DEBUG_LSP` routes internal logs to stderr.
+ */
+declare function getDefaultLspService(): LspService | undefined;
+/** Gracefully shut down the process-wide default service (host teardown). */
+declare function shutdownDefaultLspService(): Promise<void>;
+
 /**
  * FEATURE_192 v0.7.44 Phase B — Goal lifecycle hook composer.
  *
@@ -630,6 +825,58 @@ interface GoalRuntimeBinding {
  */
 declare function buildGoalRuntimeBinding(deps: GoalRuntimeBindingDeps): GoalRuntimeBinding;
 
+/**
+ * FEATURE_218 — KodaX Self-Knowledge Manual types.
+ *
+ * A bundled, version-bound product manual that answers "how do I use /
+ * configure / install / troubleshoot KodaX?" questions. Pure data + a
+ * deterministic resolver — no RAG, no vector store, no network fetch.
+ */
+type KodaXManualTopicId = 'overview' | 'install' | 'quickstart' | 'providers' | 'custom-providers' | 'config' | 'permissions' | 'commands' | 'tools' | 'agents' | 'skills' | 'mcp' | 'repo-intelligence' | 'sessions' | 'doctor' | 'sdk' | 'troubleshooting';
+/** A pointer to the code/doc the topic is derived from (for traceability). */
+interface KodaXManualSource {
+    readonly label: string;
+    readonly path: string;
+}
+interface ResolveKodaXManualInput {
+    /** Exact topic id or alias. Takes precedence over `query`. */
+    readonly topic?: string;
+    /** Free-text question; resolved by alias + token overlap. */
+    readonly query?: string;
+}
+/**
+ * FEATURE_221 — a topic an SDK consumer (e.g. a product built on KodaX)
+ * injects via `KodaXOptions.selfManual.topics`. Same shape as a KodaX base
+ * topic but `id` is a free string (new id = add; existing base id = override),
+ * and aliases/nextTopics/sources are optional to lower the authoring burden.
+ * Bodies are still byte-capped by the resolver (no unbounded items).
+ */
+interface KodaXManualTopicInput {
+    readonly id: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly body: string;
+    readonly aliases?: readonly string[];
+    readonly nextTopics?: readonly string[];
+    readonly sources?: readonly KodaXManualSource[];
+}
+/** Per-call resolver options — consumer topic injection + product re-branding. */
+interface ResolveKodaXManualOptions {
+    /** Injected consumer topics, merged over the KodaX base (override by id). */
+    readonly extraTopics?: readonly KodaXManualTopicInput[];
+    /** Product name used in the scope anchor (default "KodaX"). */
+    readonly productName?: string;
+}
+interface ResolveKodaXManualResult {
+    /** A topic id (KodaX base or injected consumer topic), or 'index'. */
+    readonly matchedTopic: string;
+    readonly title: string;
+    /** Assembled, byte-capped content (scope anchor + body, or index list). */
+    readonly content: string;
+    readonly sources: readonly KodaXManualSource[];
+    readonly nextTopics: readonly string[];
+}
+
 /**
  * FEATURE_093 (v0.7.24): minimal contract interface for the coding extension
  * runtime. Extracted so `@kodax-ai/coding/src/types.ts` can reference the
@@ -1695,6 +1942,26 @@ interface KodaXContextOptions {
      * the lifecycle hooks pass through unmodified.
      */
     goalRuntime?: GoalRuntimeBinding;
+    /**
+     * FEATURE_132 (v0.7.47) — native LSP service for edit-time diagnostics
+     * reflux. When omitted, `buildToolExecutionContext` falls back to the
+     * process-wide default (`getDefaultLspService()`), so diagnostics work
+     * out of the box; hosts/tests inject their own to control or disable it.
+     *
+     * See `packages/coding/src/lsp/service.ts`.
+     */
+    lspService?: LspService;
+}
+/**
+ * FEATURE_221 — an SDK consumer (a product built on KodaX, e.g. KodaX-Space)
+ * injects its own product manual so that when ITS users ask "how do I use /
+ * configure <product>?", the kodax_manual tool answers with the consumer's
+ * topics. `topics` extend the KodaX base (override by id); `productName`
+ * re-brands the routing rule + scope anchor. Topics are still byte-capped.
+ */
+interface KodaXSelfManualConfig {
+    readonly productName?: string;
+    readonly topics?: readonly KodaXManualTopicInput[];
 }
 interface KodaXOptions {
     provider: string;
@@ -1708,6 +1975,8 @@ interface KodaXOptions {
     context?: KodaXContextOptions;
     events?: KodaXEvents;
     extensionRuntime?: ExtensionRuntimeContract;
+    /** FEATURE_221: SDK-consumer self-manual injection (product name + topics). */
+    selfManual?: KodaXSelfManualConfig;
     /**
      * FEATURE_092 (v0.7.33): caller-supplied run-scoped guardrails forwarded
      * to `Runner.run` via `RunOptions.guardrails`. Merged with the START
@@ -1969,38 +2238,14 @@ interface KodaXResult {
     /** Error metadata for recovery - 错误元数据用于恢复 */
     errorMetadata?: SessionErrorMetadata;
 }
-/** A single question item used in multi-question mode. */
-interface AskUserQuestionItem {
-    question: string;
-    header?: string;
-    options: Array<{
-        label: string;
-        description?: string;
-        value: string;
-    }>;
-    multiSelect?: boolean;
-}
-/** Options for multi-question mode — multiple independent questions in one tool call. */
-interface AskUserMultiOptions {
-    questions: AskUserQuestionItem[];
-}
-interface AskUserQuestionOptions {
-    question: string;
-    kind?: "select" | "input";
-    /** Required for kind="select", ignored for kind="input". */
-    options?: Array<{
-        label: string;
-        description?: string;
-        value: string;
-    }>;
-    multiSelect?: boolean;
-    default?: string;
-}
+
 interface KodaXToolExecutionContext {
     /** File backups for undo functionality - 文件备份用于撤销功能 */
     backups: Map<string, string>;
     /** Git root directory - Git 根目录 */
     gitRoot?: string;
+    /** FEATURE_221: SDK-consumer self-manual injection, forwarded from KodaXOptions. */
+    selfManual?: KodaXSelfManualConfig;
     /** Working directory used to resolve relative paths and execute shell commands. */
     executionCwd?: string;
     /** Shared extension capability runtime used by retrieval-family tools. */
@@ -2160,6 +2405,13 @@ interface KodaXToolExecutionContext {
      * See `packages/coding/src/multi-instance/content-hash-cache.ts`.
      */
     contentHashCache?: ContentHashCache;
+    /**
+     * FEATURE_132 (v0.7.47) — native LSP service. The write-family tools call
+     * `getDiagnosticsBlock(filePath, …)` after a successful write to reflux any
+     * type errors into the tool result. Forwarded by `buildToolExecutionContext`
+     * from `options.context.lspService` or the process-wide default.
+     */
+    lspService?: LspService;
     /**
      * FEATURE_177 v0.7.42 — per-task read-file-state cache (anti-loop).
      *
@@ -2921,5 +3173,5 @@ interface CreateBashPrefixExtractorOptions {
  */
 declare function createBashPrefixExtractor(opts: CreateBashPrefixExtractorOptions): BashPrefixExtractor;
 
-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 };
+export { BASH_POLICY_SPEC as B, CONSECUTIVE_THRESHOLD as C, ERROR_THRESHOLD as E, LSP_SERVERS as aB, LspService as aF, WINDOW_MS as b1, buildGoalRuntimeBinding as b2, collectAllSignals as b3, computeRulesFingerprint as b4, createAutoModeToolGuardrail as b5, createBashPrefixExtractor as b6, createCircuitBreaker as b7, createDenialTracker as b8, extractCommandPrefix as b9, formatAgentsForPrompt as ba, getDefaultLspService as bb, getKodaxGlobalDir as bc, loadAgentsFiles as bd, loadAutoRules as be, makeDisabledGoalToolsContext as bf, parseAutoRules as bg, readTrustState as bh, recordAllow as bi, recordBlock as bj, recordError as bk, shouldFallback$1 as bl, shouldFallback as bm, shutdownDefaultLspService as bn, trustProjectRules as bo, withGoalBeforeNextTurn as bp, withGoalStopHook as bq, CUMULATIVE_THRESHOLD as k };
+export type { KodaXMcpTransport as $, AgentsFile as A, DenialTracker as D, FailureStage as F, GoalBlockedResult as G, KodaXContextOptions as H, KodaXContextTokenSnapshot as I, KodaXEvents as J, KodaXAgentMode as K, KodaXFanoutBranchLifecycle as L, KodaXFanoutBranchRecord as M, KodaXFanoutBranchTransition as N, KodaXFanoutSchedulerInput as O, KodaXFanoutSchedulerPlan as P, KodaXInputArtifact as Q, KodaXManagedBudgetSnapshot as R, KodaXManagedProtocolPayload as S, KodaXManagedTask as T, KodaXManagedTaskRuntimeState as U, KodaXManagedTaskStatusEvent as V, KodaXManualTopicId as W, KodaXManualTopicInput as X, KodaXMcpConnectMode as Y, KodaXMcpServerConfig as Z, KodaXMcpServersConfig as _, AutoModeAskUser as a, ToolCallSignal 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, KodaXVerificationScorecardCriterion as aA, LoadAgentsOptions as aC, LoadedRulesSource as aD, LspServerInfo as aE, LspServiceConfig as aG, ProviderExecutionState as aH, ProviderRecoveryEvent as aI, ProviderResilienceConfig as aJ, ProviderResiliencePolicy as aK, RecoveryAction as aL, RecoveryDecision as aM, RecoveryLadderStep as aN, RecoveryResult as aO, ResilienceClassification as aP, ResilienceErrorClass as aQ, ResolveKodaXManualInput as aR, ResolveKodaXManualOptions as aS, ResolveKodaXManualResult as aT, RulesLoadError as aU, RulesLoadResult as aV, SignalCollector as aW, SkippedRulesSource as aX, TodoItem as aY, TodoList as aZ, TodoStatus as a_, KodaXRepoRoutingSignals as aa, KodaXResult as ab, KodaXRoleRoundSummary as ac, KodaXRuntimeVerificationContract as ad, KodaXSelfManualConfig as ae, KodaXSessionControl as af, KodaXSessionMutators as ag, KodaXSessionOptions as ah, KodaXSkillInvocationContext as ai, KodaXSkillMap as aj, KodaXSkillProjectionConfidence as ak, KodaXTaskCapabilityHint as al, KodaXTaskContract as am, KodaXTaskEvidenceArtifact as an, KodaXTaskEvidenceBundle as ao, KodaXTaskEvidenceEntry as ap, KodaXTaskRole as aq, KodaXTaskRoleAssignment as ar, KodaXTaskStatus as as, KodaXTaskSurface as at, KodaXTaskToolPolicy as au, KodaXTaskVerificationContract as av, KodaXTaskVerificationCriterion as aw, KodaXTaskWorkItem as ax, KodaXToolExecutionContext as ay, KodaXVerificationScorecard as az, AutoModeAskUserVerdict as b, TrustState as b0, AutoModeEngine as c, AutoModeGuardrailConfig as d, AutoModeSharedState as e, AutoModeStats as f, AutoModeToolGuardrail as g, AutoRules as h, BashPrefixExtractor as i, BashPrefixResult as j, CircuitBreaker as l, CreateBashPrefixExtractorOptions as m, DiagnosticsRequest as n, ExtensionRuntimeContract as o, ExtractCommandPrefixOptions as p, GoalCompleteResult as q, GoalCreateInput as r, GoalLifecycleContext as s, GoalRuntimeBinding as t, GoalRuntimeBindingDeps as u, GoalToolsContext as v, KodaXBudgetDisclosureZone as w, KodaXBudgetExtensionRequest as x, KodaXChildAgentResult as y, KodaXChildContextBundle as z };

package/dist/types-chunks/{config.d-BfJUXxC0.d.ts → config.d-CJy1WENT.d.ts}

@@ -5,7 +5,12 @@
  * `Mcp*` names here; the `KodaXMcp*` aliases continue to re-export from
  * `@kodax-ai/coding` for backward compatibility.
  */
-type McpTransportKind = 'stdio' | 'sse' | 'streamable-http';
+/**
+ * Transport config kind. `http` is a compatibility alias used by other MCP
+ * clients' config files; KodaX auto-detects Streamable HTTP first, then falls
+ * back to the legacy HTTP+SSE transport. It is not a distinct wire protocol.
+ */
+type McpTransportKind = 'stdio' | 'sse' | 'streamable-http' | 'http';
 type McpConnectMode = 'lazy' | 'prewarm' | 'disabled';
 interface McpServerConfig {
     /** Transport type. Defaults to 'stdio' when omitted. */
@@ -18,19 +23,24 @@ interface McpServerConfig {
     cwd?: string;
     /** stdio: extra environment variables for the spawned process. */
     env?: Record<string, string>;
-    /** sse / streamable-http: server endpoint URL. */
+    /** sse / streamable-http / http(auto): server endpoint URL. */
     url?: string;
-    /** sse / streamable-http: extra HTTP headers (e.g. Authorization). */
+    /** sse / streamable-http / http(auto): extra HTTP headers (e.g. Authorization). */
     headers?: Record<string, string>;
     connect?: McpConnectMode;
     startupTimeoutMs?: number;
     requestTimeoutMs?: number;
-    /** OAuth 2.0 configuration for authenticated MCP servers. */
+    /**
+     * OAuth 2.0 for authenticated MCP servers. All endpoint fields are optional:
+     * when omitted, KodaX discovers them at runtime (RFC 9728 → RFC 8414) and
+     * dynamically registers a client (RFC 7591). Provide them only to pin a
+     * pre-registered client / static endpoints.
+     */
     auth?: {
         readonly type: 'oauth2';
-        readonly clientId: string;
-        readonly authorizationUrl: string;
-        readonly tokenUrl: string;
+        readonly clientId?: string;
+        readonly authorizationUrl?: string;
+        readonly tokenUrl?: string;
         readonly scopes?: readonly string[];
         readonly redirectPort?: number;
     };

package/dist/types-chunks/{file-tracker.d-BNTIvsdb.d.ts → file-tracker.d-D7L_SbRm.d.ts}

@@ -1,5 +1,5 @@
 import { n as KodaXMessage } from './types.d-Cf-GCzac.js';
-import { f as AgentMessage, ag as SessionEntry, ae as Session, ah as SessionExtension, m as CompactionDetails, u as FileOperations } from './types.d-D2RNa5Y7.js';
+import { f as AgentMessage, aj as SessionEntry, ah as Session, ak as SessionExtension, p as CompactionDetails, x as FileOperations } from './types.d-BCnbYG_A.js';
 import { s as KodaXSessionLineage, i as KodaXJsonValue, a as KodaXCompactMemorySeed, o as KodaXSessionEntry, z as KodaXSessionTreeNode, r as KodaXSessionLabelEntry, q as KodaXSessionGoalEntry, v as KodaXSessionNavigationOptions, k as KodaXSessionArtifactLedgerEntry } from './types.d-B_MIIApc.js';
 
 /**