@kodax-ai/kodax 0.7.56 → 0.7.58

package/dist/types-chunks/{types.d-BJmoMf5H.d.ts → types.d-Ci5YPFEh.d.ts}

@@ -1,7 +1,7 @@
 /**
  * KodaX AI Types
  *
- * AI 层类型定义 - 所有 Provider 共享的类型接口
+  * AI 层类型定义 - 所有 Provider 共享的类型接口
  */
 interface KodaXTextBlock {
     type: 'text';
@@ -12,6 +12,31 @@ interface KodaXToolUseBlock {
     id: string;
     name: string;
     input: Record<string, unknown>;
+    /**
+     * Set true when `input` was salvaged from malformed JSON (strict `JSON.parse`
+     * threw). RAW signal — set regardless of stop reason. On its own it means the
+     * payload is syntactically suspect: even a "complete" turn can carry malformed
+     * JSON (e.g. unescaped quotes) that the partial-json salvage silently truncates
+     * mid-value. `checkIncompleteToolCalls` therefore treats a salvaged input on a
+     * MUTATING tool (write/edit/bash — `isToolMutation`) as incomplete even on a
+     * clean stop, because executing a silently-cut payload corrupts files; a
+     * salvaged input on a read-only tool is allowed through on a clean stop.
+     */
+    _salvaged?: boolean;
+    /**
+     * Set true when `input` was salvaged AND the stream did NOT end on a
+     * recognized clean stop (`max_tokens`/`length`, or an ambiguous/`unknown`
+     * stop). A truncating stop means the payload may be cut mid-value, so this is
+     * unsafe to execute for ANY tool (not just mutating ones) — the agent loop
+     * routes it into the incomplete-tool retry (CAP-072). Subset of `_salvaged`.
+     *
+     * Both markers are internal: provider serializers never write them to the wire
+     * (they read only type/id/name/input). They may transiently remain on an
+     * assistant tool_use block in session history on the retry-cap path; harmless
+     * and never reaches the model. Mirrors the `KodaXMessage._synthetic`
+     * convention.
+     */
+    _truncated?: boolean;
 }
 /**
  * Tool-result content blocks — a structural subset of the full
@@ -93,6 +118,14 @@ interface KodaXMessage {
     content: string | KodaXContentBlock[];
     /** Marks messages injected by the system (auto-continue, retry prompts). Hidden in REPL display. */
     _synthetic?: boolean;
+    /**
+     * Identifies which subsystem injected a synthetic message so consumers can
+     * render/attribute it distinctly instead of treating it like a user query.
+     * Absent on genuine user/assistant/system messages. Known values include
+     * `'sidecar-verifier'` (Sidecar Verifier revise feedback). Exposed verbatim
+     * through `KodaXResult.messages` and session-load APIs for SDK consumers.
+     */
+    _source?: string;
 }
 interface KodaXTokenUsage {
     inputTokens: number;
@@ -120,6 +153,57 @@ interface KodaXToolDefinition {
     };
 }
 type KodaXReasoningCapability = 'native-effort' | 'native-budget' | 'native-toggle' | 'native-adaptive' | 'none' | 'prompt-only' | 'unknown';
+type KodaXStableEffortIntent = 'auto' | 'none' | 'low' | 'medium' | 'high';
+type KodaXWireReasoningEffort = string;
+type KodaXReasoningPresetName = 'zai-glm-5.2' | 'zai-glm-toggle' | 'deepseek-v4-openai' | 'deepseek-v4-anthropic' | 'deepseek-toggle' | 'kimi-k2.7-code' | 'kimi-hybrid-toggle' | 'minimax-m3' | 'minimax-m2-always' | 'mimo-v2.5-toggle' | 'qwen-hybrid-thinking' | 'openai-chat-reasoning' | 'openai-responses-reasoning' | 'codex-cli-effort' | 'claude-adaptive-xhigh' | 'claude-adaptive-max' | 'anthropic-budget' | 'generic-thinking-toggle' | 'none';
+interface KodaXReasoningEffortRequest {
+    readonly value: KodaXWireReasoningEffort;
+    readonly isExplicit: boolean;
+}
+interface KodaXReasoningEffortPreset {
+    readonly value: KodaXWireReasoningEffort;
+    readonly description?: string;
+    readonly isDefault?: boolean;
+    readonly isUserVisible?: boolean;
+}
+type KodaXReasoningEffortWireStrategy = 'openai-responses-effort' | 'openai-chat-effort' | 'codex-cli-config' | 'anthropic-output-effort' | 'anthropic-reasoning-effort' | 'provider-budget' | 'provider-toggle' | 'prompt-only' | 'none';
+type KodaXThinkingWireStrategy = 'anthropic-adaptive' | 'anthropic-budget' | 'provider-budget' | 'provider-toggle' | 'none';
+interface KodaXReasoningProfile {
+    readonly reasoningPreset?: KodaXReasoningPresetName;
+    readonly effortStrategy: KodaXReasoningEffortWireStrategy;
+    readonly thinkingStrategy?: KodaXThinkingWireStrategy;
+    readonly defaultEffort?: KodaXWireReasoningEffort;
+    readonly supportedEfforts?: readonly KodaXReasoningEffortPreset[];
+    readonly effortAliases?: Partial<Record<KodaXWireReasoningEffort, KodaXWireReasoningEffort>>;
+    readonly disabledEfforts?: readonly KodaXWireReasoningEffort[];
+    readonly localRejectEfforts?: readonly KodaXWireReasoningEffort[];
+    readonly allowCustomEffort?: boolean;
+    readonly budgetByEffort?: Partial<Record<KodaXWireReasoningEffort, number>>;
+    readonly supportsReasoningEffort?: boolean;
+    readonly supportsReasoningSummary?: boolean;
+    readonly supportsEncryptedReasoningReplay?: boolean;
+    readonly supportsAdaptiveThinking?: boolean;
+    readonly supportsManualThinkingBudget?: boolean;
+    readonly supportsDisabledThinking?: boolean;
+    readonly requiresEffortBetaHeader?: boolean;
+}
+/**
+ * Friendly reasoning declaration for CUSTOM providers / models — the canonical
+ * user-facing form. List the effort rungs the model accepts (order = the Ctrl+T
+ * ladder; include `"off"` to allow disabling thinking) plus an optional
+ * `default`. The wire strategy (effortStrategy / thinkingStrategy) is derived
+ * from the provider `protocol`, so users never touch preset names or strategy
+ * enums. Use the string `"none"` for a model with no thinking capability. For
+ * full, explicit control fall back to `reasoningProfile`.
+ *
+ * Example: `"reasoning": { "efforts": ["off", "low", "high", "max"], "default": "high" }`
+ */
+interface KodaXSimpleReasoningConfig {
+    readonly efforts: readonly string[];
+    readonly default?: string;
+}
+/** User-facing reasoning declaration: friendly form, `"none"`, or (advanced) a raw profile override. */
+type KodaXReasoningConfig = KodaXSimpleReasoningConfig | 'none' | Partial<KodaXReasoningProfile>;
 type KodaXProviderTransport = 'native-api' | 'cli-bridge';
 type KodaXProviderConversationSemantics = 'full-history' | 'last-user-message';
 type KodaXProviderMcpSupport = 'native' | 'none';
@@ -140,7 +224,6 @@ interface KodaXProviderCapabilityProfile {
     multimodalSupport?: KodaXProviderMultimodalSupport;
     evidenceSupport?: KodaXProviderEvidenceSupport;
 }
-type KodaXReasoningOverride = 'budget' | 'effort' | 'toggle' | 'adaptive' | 'none';
 type KodaXReasoningMode = 'off' | 'auto' | 'quick' | 'balanced' | 'deep';
 type KodaXThinkingDepth = 'off' | 'low' | 'medium' | 'high';
 type KodaXTaskType = 'conversation' | 'lookup' | 'review' | 'bugfix' | 'edit' | 'refactor' | 'plan' | 'qa' | 'unknown';
@@ -155,23 +238,7 @@ type KodaXMutationSurface = 'read-only' | 'docs-only' | 'code' | 'system';
 type KodaXAssuranceIntent = 'default' | 'explicit-check';
 type KodaXHarnessProfile = 'H0_DIRECT' | 'H1_EXECUTE_EVAL' | 'H2_PLAN_EXECUTE_EVAL' | 'PLANNED';
 type KodaXReviewScale = 'small' | 'large' | 'massive';
-type KodaXAmaProfile = 'tactical' | 'managed';
-type KodaXAmaTactic = 'direct' | 'child-fanout' | 'planning-pass' | 'verification-pass' | 'repair-loop';
-type KodaXAmaFanoutClass = 'finding-validation' | 'evidence-scan' | 'module-triage' | 'hypothesis-check';
-interface KodaXAmaFanoutPolicy {
-    admissible: boolean;
-    class?: KodaXAmaFanoutClass;
-    reason: string;
-    maxChildren?: number;
-    requiresReadOnly?: boolean;
-}
-interface KodaXAmaControllerDecision {
-    profile: KodaXAmaProfile;
-    tactics: KodaXAmaTactic[];
-    fanout: KodaXAmaFanoutPolicy;
-    reason: string;
-    upgradeTriggers: string[];
-}
+type KodaXChildFanoutClass = 'finding-validation' | 'evidence-scan' | 'module-triage' | 'hypothesis-check';
 interface KodaXTaskRoutingDecision {
     primaryTask: KodaXTaskType;
     secondaryTask?: KodaXTaskType;
@@ -207,18 +274,40 @@ interface KodaXThinkingBudgetMap {
 type KodaXTaskBudgetOverrides = Partial<Record<KodaXTaskType, Partial<KodaXThinkingBudgetMap>>>;
 interface KodaXReasoningRequest {
     enabled?: boolean;
-    mode?: KodaXReasoningMode;
-    depth?: KodaXThinkingDepth;
+    /**
+     * Canonical reasoning control. Reasoning single-tracking removed the legacy
+     * `mode` (KodaXReasoningMode) + `depth` (KodaXThinkingDepth) request fields —
+     * callers pass `effort` (or `enabled` as a boolean shorthand). Providers
+     * derive any thinking budget from the effort via `effortToThinkingDepth`.
+     */
+    effort?: KodaXWireReasoningEffort;
     taskType?: KodaXTaskType;
     executionMode?: KodaXExecutionMode;
 }
+interface KodaXNormalizedReasoningRequest {
+    enabled: boolean;
+    effort: KodaXWireReasoningEffort;
+    effortSource?: 'explicit' | 'legacy';
+    taskType: KodaXTaskType;
+    executionMode: KodaXExecutionMode;
+}
 interface KodaXModelDescriptor {
     id: string;
     displayName?: string;
     contextWindow?: number;
     maxOutputTokens?: number;
     thinkingBudgetCap?: number;
+    /** @deprecated Auto-migrated on load. Prefer `reasoning: { efforts, default }`. */
     reasoningCapability?: KodaXReasoningCapability;
+    /** @deprecated Internal preset name; auto-migrated on load. Prefer `reasoning`. */
+    reasoningPreset?: KodaXReasoningPresetName;
+    /**
+     * Canonical reasoning declaration: friendly `{ efforts, default }`, `"none"`,
+     * or (advanced) a raw `Partial<KodaXReasoningProfile>` override. See
+     * `KodaXReasoningConfig`.
+     */
+    reasoning?: KodaXReasoningConfig;
+    reasoningProfile?: KodaXReasoningProfile;
     /**
      * Per-model override for `replayReasoningContent`. Falls through to the
      * provider-level flag when undefined. Lets a single gateway endpoint
@@ -309,6 +398,14 @@ interface KodaXCustomProviderConfig {
     baseUrl: string;
     apiKeyEnv: string;
     model: string;
+    /** @deprecated Internal preset name; auto-migrated on load. Prefer `reasoning`. */
+    reasoningPreset?: KodaXReasoningPresetName;
+    /**
+     * Canonical reasoning declaration for this provider: friendly
+     * `{ efforts, default }`, `"none"`, or (advanced) a raw profile override.
+     * See `KodaXReasoningConfig`.
+     */
+    reasoning?: KodaXReasoningConfig;
     /**
      * Additional available models beyond the default. Accepts either a
      * plain model id string (legacy) or a KodaXModelDescriptor object
@@ -322,8 +419,11 @@ interface KodaXCustomProviderConfig {
      * - sdk: keep the upstream SDK default User-Agent
      */
     userAgentMode?: KodaXProviderUserAgentMode;
+    /** @deprecated Auto-migrated on load. Prefer `reasoning: "none"` (off) or `reasoning: { efforts, default }`. */
     supportsThinking?: boolean;
+    /** @deprecated Auto-migrated on load. Prefer `reasoning: { efforts, default }`. */
     reasoningCapability?: KodaXReasoningCapability;
+    reasoningProfile?: KodaXReasoningProfile;
     capabilityProfile?: KodaXProviderCapabilityProfile;
     contextWindow?: number;
     maxOutputTokens?: number;
@@ -370,6 +470,7 @@ interface KodaXProviderConfig {
     userAgentMode?: KodaXProviderUserAgentMode;
     supportsThinking: boolean;
     reasoningCapability?: KodaXReasoningCapability;
+    reasoningProfile?: KodaXReasoningProfile;
     capabilityProfile?: KodaXProviderCapabilityProfile;
     /** 模型的上下文窗口大小 (tokens) */
     contextWindow?: number;
@@ -471,6 +572,18 @@ interface KodaXProviderStreamOptions {
         maxAttempts: number;
     }) => void;
     /** 会话标识，用于多轮对话上下文恢复 */
+    /**
+     * Passive capability learning: fired when a provider HARD-rejects a
+     * reasoning-effort value (400/422 naming the param). Hosts can record it via
+     * the agent-layer capability cache so the rung is removed from the effective
+     * ladder and never offered or sent again (see
+     * `classifyReasoningEffortRejection`).
+     */
+    onReasoningEffortRejected?: (event: {
+        provider: string;
+        model: string;
+        effort: string;
+    }) => void;
     sessionId?: string;
     /** Override the provider's default model for a single request */
     modelOverride?: string;
@@ -482,4 +595,4 @@ interface KodaXProviderStreamOptions {
     signal?: AbortSignal;
 }
 
-export type { KodaXToolResultImageItem as $, KodaXProviderStreamOptions as A, KodaXProviderToolCallingFidelity as B, KodaXProviderTransport as C, KodaXReasoningCapability as D, KodaXReasoningMode as E, KodaXReasoningOverride as F, KodaXReasoningRequest as G, KodaXRedactedThinkingBlock as H, KodaXReviewScale as I, KodaXRiskLevel as J, KodaXAmaControllerDecision as K, KodaXStreamResult as L, KodaXTaskActionability as M, KodaXTaskBudgetOverrides as N, KodaXTaskComplexity as O, KodaXTaskFamily as P, KodaXTaskRoutingDecision as Q, KodaXTaskType as R, KodaXTaskWorkIntent as S, KodaXTextBlock as T, KodaXThinkingBlock as U, KodaXThinkingBudgetMap as V, KodaXThinkingDepth as W, KodaXTokenUsage as X, KodaXToolDefinition as Y, KodaXToolResultBlock as Z, KodaXToolResultContentItem as _, KodaXAmaFanoutClass as a, KodaXToolResultTextItem as a0, KodaXToolUseBlock as a1, KodaXVerifyCredentialResult as a2, KodaXVerifyStrategy as a3, KodaXAmaFanoutPolicy as b, KodaXAmaProfile as c, KodaXAmaTactic as d, KodaXAssuranceIntent as e, KodaXCacheBoundary as f, KodaXContentBlock as g, KodaXCustomProviderConfig as h, KodaXExecutionMode as i, KodaXExecutionPattern as j, KodaXHarnessProfile as k, KodaXImageBlock as l, KodaXListModelsResult as m, KodaXMessage as n, KodaXModelDescriptor as o, KodaXMutationSurface as p, KodaXProtocolFamily as q, KodaXProviderCapabilityProfile as r, KodaXProviderConfig as s, KodaXProviderContextFidelity as t, KodaXProviderConversationSemantics as u, KodaXProviderEvidenceSupport as v, KodaXProviderLongRunningSupport as w, KodaXProviderMcpSupport as x, KodaXProviderMultimodalSupport as y, KodaXProviderSessionSupport as z };
+export type { KodaXToolResultBlock as $, KodaXReasoningCapability as A, KodaXReasoningEffortPreset as B, KodaXReasoningEffortRequest as C, KodaXReasoningEffortWireStrategy as D, KodaXReasoningMode as E, KodaXReasoningProfile as F, KodaXReasoningRequest as G, KodaXRedactedThinkingBlock as H, KodaXReviewScale as I, KodaXRiskLevel as J, KodaXAssuranceIntent as K, KodaXStableEffortIntent as L, KodaXStreamResult as M, KodaXTaskActionability as N, KodaXTaskBudgetOverrides as O, KodaXTaskComplexity as P, KodaXTaskFamily as Q, KodaXTaskRoutingDecision as R, KodaXTaskType as S, KodaXTaskWorkIntent as T, KodaXTextBlock as U, KodaXThinkingBlock as V, KodaXThinkingBudgetMap as W, KodaXThinkingDepth as X, KodaXThinkingWireStrategy as Y, KodaXTokenUsage as Z, KodaXToolDefinition as _, KodaXCacheBoundary as a, KodaXToolResultContentItem as a0, KodaXToolResultImageItem as a1, KodaXToolResultTextItem as a2, KodaXToolUseBlock as a3, KodaXVerifyCredentialResult as a4, KodaXVerifyStrategy as a5, KodaXWireReasoningEffort as a6, KodaXChildFanoutClass as b, KodaXContentBlock as c, KodaXCustomProviderConfig as d, KodaXExecutionMode as e, KodaXExecutionPattern as f, KodaXHarnessProfile as g, KodaXImageBlock as h, KodaXListModelsResult as i, KodaXMessage as j, KodaXModelDescriptor as k, KodaXMutationSurface as l, KodaXNormalizedReasoningRequest as m, KodaXProtocolFamily as n, KodaXProviderCapabilityProfile as o, KodaXProviderConfig as p, KodaXProviderContextFidelity as q, KodaXProviderConversationSemantics as r, KodaXProviderEvidenceSupport as s, KodaXProviderLongRunningSupport as t, KodaXProviderMcpSupport as u, KodaXProviderMultimodalSupport as v, KodaXProviderSessionSupport as w, KodaXProviderStreamOptions as x, KodaXProviderToolCallingFidelity as y, KodaXProviderTransport as z };

package/dist/types-chunks/{types.d-BKuHSiR0.d.ts → types.d-D4ZA8LJV.d.ts}

@@ -1,4 +1,4 @@
-import { y as Guardrail, aG as RunnerToolCall, d as Agent, f as AgentMessage, aJ as RunnerToolResult, aS as Span } from './process.d-BdiIUr8T.js';
+import { z as Guardrail, aO as RunnerToolCall, e as Agent, g as AgentMessage, aR as RunnerToolResult, a_ as Span, _ as KodaXInputArtifact } from './process.d-DHow2y2G.js';
 
 /**
  * Guardrail Runtime — FEATURE_085 (v0.7.26).
@@ -165,8 +165,10 @@ declare function runToolAfterGuardrails(call: RunnerToolCall, result: RunnerTool
  * Phase 0.6 study (`c:/tmp/claude-code-actual-usage.md`): Claude Code's
  * `'now'` priority has zero production usage; KodaX simplifies to 2 tiers.
  */
+
 type MessagePriority = 'user' | 'background';
 type MessageMode = 'prompt' | 'task-notification' | 'system-reminder';
+type QueuedInputArtifact = KodaXInputArtifact;
 interface QueuedMessage {
     /** Stable id for tracing / dedup. Format: `msg-<sequence>`. */
     readonly id: string;
@@ -182,6 +184,7 @@ interface QueuedMessage {
     readonly agentId?: string;
     readonly mode: MessageMode;
     readonly content: string;
+    readonly inputArtifacts?: readonly QueuedInputArtifact[];
     /** Wall-clock timestamp (`Date.now()`) for tracing only — not used for ordering. */
     readonly enqueuedAt: number;
 }
@@ -267,7 +270,8 @@ interface EnqueueInput {
     readonly mode: MessageMode;
     readonly content: string;
     readonly agentId?: string;
+    readonly inputArtifacts?: readonly QueuedInputArtifact[];
 }
 
-export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as g, runOutputGuardrails as h, runToolAfterGuardrails as i, runToolBeforeGuardrails as j, runInputGuardrails as r };
-export type { DequeueFilter as D, EnqueueInput as E, InputGuardrail as I, MessageMode as M, OutputGuardrail as O, QueueEventListener as Q, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, MessagePriority as d, QueuedMessage as e, ToolGuardrail as f };
+export { GuardrailBlockedError as G, GuardrailEscalateError as b, collectGuardrails as h, runOutputGuardrails as i, runToolAfterGuardrails as j, runToolBeforeGuardrails as k, runInputGuardrails as r };
+export type { DequeueFilter as D, EnqueueInput as E, InputGuardrail as I, MessageMode as M, OutputGuardrail as O, QueueEventListener as Q, ToolBeforeOutcome as T, GuardrailContext as a, GuardrailVerdict as c, MessagePriority as d, QueuedInputArtifact as e, QueuedMessage as f, ToolGuardrail as g };

package/dist/types-chunks/{utils.d-bC97IuQZ.d.ts → utils.d-BURxOxFd.d.ts}

@@ -1,8 +1,8 @@
-import { U as KodaXOptions, u as KodaXContextTokenSnapshot, m as KodaXAgentMode, Z as KodaXRepoIntelligenceMode, aa as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-DZF1gDDz.js';
-import { c as SessionStorage$1, b as PermissionMode } from './storage.d-CkydxFsV.js';
-import { ac as KodaXSessionUiHistoryItem, a4 as KodaXSessionLineage, Y as KodaXSessionArtifactLedgerEntry, Q as KodaXExtensionSessionState, P as KodaXExtensionSessionRecord, a8 as KodaXSessionRuntimeInfo, aa as KodaXSessionStorage, $ as KodaXSessionData, bD as WorkflowProcessSource } from './process.d-BdiIUr8T.js';
-import { n as KodaXMessage, E as KodaXReasoningMode, r as KodaXProviderCapabilityProfile, F as KodaXReasoningOverride, h as KodaXCustomProviderConfig } from './types.d-BJmoMf5H.js';
-import { A as AgentsFile, f as AutoModeStats, l as KodaXMcpServersConfig } from './guardrail.d-DQQknOfb.js';
+import { P as KodaXOptions, v as KodaXContextTokenSnapshot, m as KodaXAgentMode, U as KodaXRepoIntelligenceMode, a5 as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-D3cddmyV.js';
+import { c as SessionStorage$1, b as PermissionMode } from './storage.d-BsZrBPYu.js';
+import { ai as KodaXSessionUiHistoryItem, aa as KodaXSessionLineage, a2 as KodaXSessionArtifactLedgerEntry, R as KodaXExtensionSessionState, Q as KodaXExtensionSessionRecord, ae as KodaXSessionRuntimeInfo, ag as KodaXSessionStorage, a5 as KodaXSessionData, bL as WorkflowProcessSource } from './process.d-DHow2y2G.js';
+import { j as KodaXMessage, E as KodaXReasoningMode, o as KodaXProviderCapabilityProfile, d as KodaXCustomProviderConfig } from './types.d-Ci5YPFEh.js';
+import { A as AgentsFile, f as AutoModeStats, l as KodaXMcpServersConfig } from './guardrail.d-iK7FwMdW.js';
 import * as readline from 'readline';
 import { SpawnSyncReturns } from 'child_process';
 
@@ -155,13 +155,14 @@ interface CommandExecutionMetadata {
 interface CurrentConfig {
     provider: string;
     model?: string;
+    effort?: string;
+    effortOverride?: boolean;
+    planModeEffort?: string;
     thinking: boolean;
     reasoningMode: KodaXReasoningMode;
     agentMode: KodaXAgentMode;
     permissionMode: PermissionMode;
     repoIntelligenceMode?: KodaXRepoIntelligenceMode;
-    repointelEndpoint?: string;
-    repointelBin?: string;
     repoIntelligenceTrace?: boolean;
     /** FEATURE_102 Phase 3 — cross-provider child fallback chain. */
     fallbackProviders?: string[];
@@ -180,14 +181,13 @@ interface CommandCallbacks {
     clearHistory: () => void;
     printHistory: () => void;
     switchProvider?: (provider: string, model?: string) => void;
+    setEffort?: (effort?: string) => void;
     setThinking?: (enabled: boolean) => void;
     setReasoningMode?: (mode: KodaXReasoningMode) => void;
     setAgentMode?: (mode: KodaXAgentMode) => void;
     setPermissionMode?: (mode: PermissionMode) => void;
     setRepoIntelligenceRuntime?: (update: {
         mode?: KodaXRepoIntelligenceMode;
-        endpoint?: string | null;
-        bin?: string | null;
         trace?: boolean;
     }) => void;
     deleteSession?: (id: string) => Promise<void>;
@@ -277,6 +277,14 @@ interface CommandInvocationRequest extends CommandExecutionMetadata {
     displayName: string;
     path?: string;
     skillInvocation?: KodaXSkillInvocationContext;
+    /**
+     * FEATURE_246: per-turn agent-mode elevation for this invocation only.
+     * The `/workflow` command in AMA sets this to `'amaw'` so its authoring turn
+     * gets `run_workflow` (scout-then-author) — matching AMAW's capability without
+     * making plain AMA self-activate workflows from natural language. The session
+     * mode is unchanged; only this one turn runs elevated.
+     */
+    agentModeOverride?: KodaXAgentMode;
 }
 interface CommandWorkflowInvocationRequest {
     request: string;
@@ -339,7 +347,7 @@ declare function executeCommand(parsed: {
 
 /**
  * KodaX CLI Utilities
- * CLI 层工具函数
+ * CLI 灞傚伐鍏峰嚱鏁?
  */
 
 /**
@@ -411,6 +419,8 @@ declare function isProviderConfigured(name: string): boolean;
 declare function loadConfig(): {
     provider?: string;
     model?: string;
+    effort?: string;
+    planModeEffort?: string;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
     /**
@@ -424,14 +434,11 @@ declare function loadConfig(): {
     agentMode?: KodaXAgentMode;
     permissionMode?: string;
     locale?: string;
-    providerReasoningOverrides?: Record<string, KodaXReasoningOverride>;
     providerModels?: Record<string, string[]>;
     customProviders?: KodaXCustomProviderConfig[];
     extensions?: string[];
     mcpServers?: KodaXMcpServersConfig;
-    repoIntelligenceMode?: 'auto' | 'off' | 'oss' | 'premium-shared' | 'premium-native';
-    repointelEndpoint?: string;
-    repointelBin?: string;
+    repoIntelligenceMode?: 'auto' | 'off' | 'light' | 'full';
     repoIntelligenceTrace?: boolean;
     streamIdleTimeoutMs?: number;
     /**
@@ -459,24 +466,71 @@ declare function loadConfig(): {
      * layer, which has no config access. Set via the `/fallback` command.
      */
     fallbackProviders?: string[];
+    /**
+     * Per-agent model TIERS for the workflow / dispatch `model_hint` (M2 config
+     * surface). Operators point a tier at a concrete provider+model; a workflow
+     * script / dispatch then expresses intent via `modelHint: 'fast' | 'deep'`.
+     * 'fast' routes read-only children only (write/codegen stays on the parent —
+     * a quality guard); 'deep' routes any child. Mirrored to
+     * KODAX_FAST/DEEP_PROVIDER/MODEL for the coding layer (which has no config
+     * access); env wins if pre-set. An unset tier inherits the parent model.
+     */
+    fastProvider?: string;
+    fastModel?: string;
+    deepProvider?: string;
+    deepModel?: string;
+    /**
+     * Config surface for settings the coding/llm layer reads only via env (it has
+     * no config access). Bridged to their KODAX_* env vars in prepareRuntimeConfig
+     * (env-wins). See CONFIG_ENV_BRIDGES for the mapping.
+     */
+    maxOutputTokens?: number;
+    disablePromptCache?: boolean;
+    lsp?: boolean;
+    lspAutoDownload?: boolean;
+    acpLogLevel?: string;
+    sessionRetentionDays?: number;
+    repoIntelligence?: {
+        toolWaitMs?: number;
+        workerTimeoutMs?: number;
+        workerOldSpaceMb?: number;
+        storageDir?: string;
+    };
+    workflow?: {
+        maxConcurrency?: number;
+    };
 };
+/**
+ * F1 — first-launch onboarding. config.json must be STRICT JSON (no comments), so we
+ * cannot ship a self-documenting config.json. Instead, on first launch (no config.json
+ * yet) we write a heavily-commented `config.example.jsonc` REFERENCE file next to it.
+ * It is never loaded by KodaX — it exists purely so a new user can see the minimal
+ * fields and the inline guidance (especially custom-provider thinking/reasoning) and
+ * copy what they need into config.json.
+ *
+ * Returns the example path only when it was just created (so the caller can print a
+ * one-time pointer); returns undefined if config.json already exists, the example
+ * already exists, or the write failed. Never throws — a template-write failure must
+ * not block startup.
+ */
+declare const KODAX_EXAMPLE_CONFIG_FILE: string;
+declare function ensureExampleConfigFile(): string | undefined;
 declare function prepareRuntimeConfig(): ReturnType<typeof loadConfig>;
 declare function saveConfig(config: {
     provider?: string;
     model?: string;
+    effort?: string;
+    planModeEffort?: string;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
     agentMode?: KodaXAgentMode;
     permissionMode?: string;
     locale?: string;
-    providerReasoningOverrides?: Record<string, KodaXReasoningOverride>;
     providerModels?: Record<string, string[]>;
     customProviders?: KodaXCustomProviderConfig[];
     extensions?: string[];
     mcpServers?: KodaXMcpServersConfig;
-    repoIntelligenceMode?: 'auto' | 'off' | 'oss' | 'premium-shared' | 'premium-native';
-    repointelEndpoint?: string;
-    repointelBin?: string;
+    repoIntelligenceMode?: 'auto' | 'off' | 'light' | 'full';
     repoIntelligenceTrace?: boolean;
     /** FEATURE_184 Phase D.3 follow-up — opt-in verifier log line. */
     verifierLog?: boolean;
@@ -484,6 +538,27 @@ declare function saveConfig(config: {
     stallLog?: boolean;
     /** FEATURE_102 Phase 3 — cross-provider child fallback chain. */
     fallbackProviders?: string[];
+    /** M2 — per-agent model tiers (workflow / dispatch model_hint). */
+    fastProvider?: string;
+    fastModel?: string;
+    deepProvider?: string;
+    deepModel?: string;
+    /** Config surface bridged to KODAX_* env for the coding/llm layer. */
+    maxOutputTokens?: number;
+    disablePromptCache?: boolean;
+    lsp?: boolean;
+    lspAutoDownload?: boolean;
+    acpLogLevel?: string;
+    sessionRetentionDays?: number;
+    repoIntelligence?: {
+        toolWaitMs?: number;
+        workerTimeoutMs?: number;
+        workerOldSpaceMb?: number;
+        storageDir?: string;
+    };
+    workflow?: {
+        maxConcurrency?: number;
+    };
 }): void;
 /**
  * Get git root directory.
@@ -502,5 +577,5 @@ declare function saveConfig(config: {
 declare function getGitRoot(cwd?: string): Promise<string | null>;
 declare function rateLimitedCall<T>(fn: () => Promise<T>): Promise<T>;
 
-export { BUILTIN_COMMANDS as B, KODAX_CONFIG_FILE as K, PREVIEW_MAX_LENGTH as P, KODAX_DIR as e, KODAX_SESSIONS_DIR as f, KODAX_VERSION as g, createInteractiveContext as h, executeCommand as i, getGitRoot as j, getProviderList as k, getProviderModel as l, getVersion as m, hydrateProcessEnvFromShell as n, isProviderConfigured as o, loadConfig as p, parseCommand as q, prepareRuntimeConfig as r, processSpecialSyntax as s, rateLimitedCall as t, registerConfiguredCustomProviders as u, runInkInteractiveMode as v, runInteractiveMode as w, saveConfig as x, touchContext as y };
+export { touchContext as A, BUILTIN_COMMANDS as B, KODAX_CONFIG_FILE as K, PREVIEW_MAX_LENGTH as P, KODAX_DIR as e, KODAX_EXAMPLE_CONFIG_FILE as f, KODAX_SESSIONS_DIR as g, KODAX_VERSION as h, createInteractiveContext as i, ensureExampleConfigFile as j, executeCommand as k, getGitRoot as l, getProviderList as m, getProviderModel as n, getVersion as o, hydrateProcessEnvFromShell as p, isProviderConfigured as q, loadConfig as r, parseCommand as s, prepareRuntimeConfig as t, processSpecialSyntax as u, rateLimitedCall as v, registerConfiguredCustomProviders as w, runInkInteractiveMode as x, runInteractiveMode as y, saveConfig as z };
 export type { Command as C, InkREPLOptions as I, RepLOptions as R, CommandCallbacks as a, CurrentConfig as b, InteractiveContext as c, InteractiveMode as d };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kodax-ai/kodax",
-  "version": "0.7.56",
-  "description": "极致轻量化 Coding Agent - TypeScript 实现，支持 12 个 LLM 提供商，可发布为免 Node 单文件二进制",
+  "version": "0.7.58",
+  "description": "KodaX lightweight coding agent - TypeScript implementation with 15 built-in LLM provider aliases, published as a Node-free single-file CLI and SDK",
   "type": "module",
   "private": false,
   "publishConfig": {
@@ -64,9 +64,7 @@
     "dev:mem-diag": "node scripts/mem-diag-launch.cjs",
     "dev:mem-snapshot": "node scripts/mem-diag-launch.cjs 2",
     "probe:reasoning": "tsx scripts/probe-reasoning.ts",
-    "repointel:install": "node clients/repointel/scripts/install.mjs",
-    "repointel:demo": "node clients/repointel/scripts/demo.mjs",
-    "repointel:doctor": "node clients/repointel/scripts/doctor.mjs",
+    "probe:max-tokens": "node scripts/probe-max-tokens.mjs",
     "start": "node --max-old-space-size=4096 --require ./scripts/production-env.cjs dist/kodax_cli.js",
     "build:binary": "node scripts/build-binary.mjs",
     "build:binary:all": "node scripts/build-binary.mjs --all",
@@ -75,6 +73,7 @@
     "test:eval": "vitest run -c vitest.eval.config.ts",
     "bench:perf": "tsx benchmark/perf/repl-render-perf.bench.ts",
     "bench:perf:e2e": "tsx benchmark/perf/repl-render-engine-e2e.bench.ts",
+    "bench:repo-intel": "tsx benchmark/perf/repo-intelligence-index.bench.ts",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "clean:packages": "npm run clean --workspaces"
   },
@@ -149,10 +148,16 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/icetomoyo/KodaX.git"
+    "url": "git+https://github.com/icetomoyo/KodaX.git"
   },
   "files": [
-    "dist",
+    "dist/*.d.ts",
+    "dist/*.js",
+    "dist/builtin",
+    "dist/chunks",
+    "dist/provider-capabilities.json",
+    "dist/semantic-worker.js",
+    "dist/types-chunks",
     "scripts/kodax-bin.cjs",
     "scripts/production-env.cjs",
     "README.md",

package/dist/chunks/agent-MAAKRAF2.js

@@ -1,2 +0,0 @@
-// @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{Pb as c,Qb as d,Rb as e,Sb as f,kc as g,lc as h,pd as i,ud as j}from"./chunk-NZVJ3DFC.js";import"./chunk-QI3MRJGU.js";import"./chunk-CDGOEK3T.js";import{jb as a,kb as b}from"./chunk-JCDO2FR4.js";import"./chunk-V4WSBIXB.js";export{d as bucketProviderPayloadSize,g as buildAutoRepoIntelligenceContext,e as checkPromiseSignal,b as cleanupIncompleteToolCalls,h as describeTransientProviderRetry,f as emitResilienceDebug,c as estimateProviderPayloadBytes,j as runKodaX,i as saveSessionSnapshot,a as validateAndFixToolHistory};

package/dist/chunks/argument-completer-OWEXGWNL.js

@@ -1,2 +0,0 @@
-// @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{wa as a,xa as b}from"./chunk-5YJIAP6C.js";import"./chunk-7EAGBLRV.js";import"./chunk-ZBK3DZ3S.js";import"./chunk-DHETLULC.js";import"./chunk-NZVJ3DFC.js";import"./chunk-QI3MRJGU.js";import"./chunk-CDGOEK3T.js";import"./chunk-JCDO2FR4.js";import"./chunk-V4WSBIXB.js";export{a as ArgumentCompleter,b as createArgumentCompleter};