@kodax-ai/kodax 0.7.56 → 0.7.57

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

@@ -1,7 +1,7 @@
 /**
  * KodaX AI Types
  *
- * AI 层类型定义 - 所有 Provider 共享的类型接口
+  * AI 层类型定义 - 所有 Provider 共享的类型接口
  */
 interface KodaXTextBlock {
     type: 'text';
@@ -120,6 +120,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' | '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 +191,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 +205,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 +241,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 +365,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 +386,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 +437,7 @@ interface KodaXProviderConfig {
     userAgentMode?: KodaXProviderUserAgentMode;
     supportsThinking: boolean;
     reasoningCapability?: KodaXReasoningCapability;
+    reasoningProfile?: KodaXReasoningProfile;
     capabilityProfile?: KodaXProviderCapabilityProfile;
     /** 模型的上下文窗口大小 (tokens) */
     contextWindow?: number;
@@ -471,6 +539,17 @@ interface KodaXProviderStreamOptions {
         maxAttempts: number;
     }) => void;
     /** 会话标识，用于多轮对话上下文恢复 */
+    /**
+     * Passive capability learning — fired when a provider HARD-rejects a
+     * reasoning-effort value (400/422 naming the param). The REPL records it in
+     * `capability-cache.json` so the rung is removed from the 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 +561,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-D8WcfrOD.d.ts

@@ -0,0 +1,143 @@
+/**
+ * @kodax-ai/agent/messaging — Message queue types
+ *
+ * FEATURE_115 (v0.7.36): agentId-scoped 2-tier priority queue infrastructure.
+ *
+ * Per ADR-021: messaging is a generic agent-platform primitive (not coding-
+ * specific). Downstream consumers:
+ *   - @kodax-ai/coding runner-driven mid-turn drain
+ *   - @kodax-ai/repl InkREPL ESC soft-pause + text injection (FEATURE_111 absorbed)
+ *   - subagent task-notification routing (FEATURE_155 idle-yield wakeup)
+ *
+ * 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 = {
+    readonly kind: 'image';
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly source?: string;
+    readonly description?: string;
+} | {
+    readonly kind: 'file';
+    readonly path: string;
+    readonly mediaType?: string;
+    readonly mimeType?: string;
+    readonly name?: string;
+    readonly source?: string;
+    readonly description?: string;
+} | {
+    readonly kind: 'video';
+    readonly path: string;
+    readonly mediaType: string;
+    readonly name?: string;
+    readonly source?: string;
+    readonly description?: string;
+};
+interface QueuedMessage {
+    /** Stable id for tracing / dedup. Format: `msg-<sequence>`. */
+    readonly id: string;
+    readonly priority: MessagePriority;
+    /**
+     * Routing key:
+     *   undefined = main thread / coordinator agent
+     *   'agent-id-XYZ' = subagent / specific consumer
+     *
+     * Drain consumers MUST filter by agentId match — undefined matches only
+     * undefined-agentId messages, not "any agent".
+     */
+    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;
+}
+interface DequeueFilter {
+    /**
+     * Only return messages with this agentId.
+     * undefined matches messages with no agentId (main-thread messages only).
+     */
+    readonly agentId?: string;
+    /**
+     * Highest priority level included in the drain.
+     *   'user'       → only user priority drained, background stays queued
+     *   'background' → both user + background drained (Sleep-gated case)
+     */
+    readonly maxPriority: MessagePriority;
+    /**
+     * Optional cap on number of messages drained in this call.
+     * Defaults to unlimited (drains all matching).
+     */
+    readonly limit?: number;
+    /**
+     * FEATURE_159 (v0.7.40) — optional mode filter. Lets REPL split the
+     * single queue into mode-typed views (e.g. `mode:'prompt'` for user
+     * input vs `mode:'task-notification'` for child completion banners)
+     * without separate queues. When omitted, all modes match.
+     */
+    readonly mode?: MessageMode;
+    /**
+     * FEATURE_159 (v0.7.40) — optional precise-id filter. Single-message
+     * targeted removal — drives Esc-pop-this-uuid in REPL. When set, all
+     * other filters still apply (agentId / priority / mode mismatches still
+     * skip the message), so callers can't accidentally remove a message
+     * outside their scope.
+     */
+    readonly id?: string;
+    /**
+     * FEATURE_159 (v0.7.40) — optional escape-hatch predicate, AND-ed with
+     * the structured filters. Lets SDK consumers express conditions the
+     * typed fields don't cover (e.g. timestamp ranges, content-match) without
+     * forcing every new use case to extend `DequeueFilter`. KodaX-internal
+     * code should prefer the typed fields for readability; this is the
+     * "data-driven main path + predicate escape" pattern.
+     *
+     * Evaluated AFTER the typed filters succeed — so a `predicate` that
+     * inspects `message.content` never runs on messages outside the
+     * caller's `agentId` / `mode` / `id` scope.
+     */
+    readonly predicate?: (message: QueuedMessage) => boolean;
+}
+/**
+ * FEATURE_159 (v0.7.40) — structured queue event emitted to subscribers.
+ *
+ * Replaces the prior `() => void` bare-notify signal. Carries the kind +
+ * affected messages so SDK observability consumers (logging, tracing,
+ * metrics) can react per-event without re-diffing snapshots.
+ *
+ * Event granularity rules:
+ *   - `enqueued` fires ONCE per `enqueue()` call (always 1 message).
+ *   - `dequeued` fires ONCE per `dequeue()` call that removed ≥1 message,
+ *     carrying ALL drained messages in priority+FIFO order. No-op drains
+ *     (filter matched nothing) fire no event — quiet by design so the
+ *     `waitForWakeEvent` 100ms poll doesn't spam idle subscribers.
+ *   - `cleared` fires ONCE per `clear()` call that removed ≥1 message,
+ *     carrying the pre-clear messages. Empty-queue clear fires nothing.
+ *
+ * The `useSyncExternalStore` React hook ignores the event payload (it
+ * only needs the change signal); SDK / tracer consumers read the event.
+ */
+type QueueEvent = {
+    readonly kind: 'enqueued';
+    readonly message: QueuedMessage;
+} | {
+    readonly kind: 'dequeued';
+    readonly messages: readonly QueuedMessage[];
+} | {
+    readonly kind: 'cleared';
+    readonly messages: readonly QueuedMessage[];
+};
+/** FEATURE_159 — `MessageQueue.subscribe` listener signature. */
+type QueueEventListener = (event: QueueEvent) => void;
+interface EnqueueInput {
+    readonly priority: MessagePriority;
+    readonly mode: MessageMode;
+    readonly content: string;
+    readonly agentId?: string;
+    readonly inputArtifacts?: readonly QueuedInputArtifact[];
+}
+
+export type { DequeueFilter as D, EnqueueInput as E, MessageMode as M, QueueEventListener as Q, MessagePriority as a, QueuedInputArtifact as b, QueuedMessage as c };

package/dist/types-chunks/{utils.d-bC97IuQZ.d.ts → utils.d-CpgVIjYZ.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 { R as KodaXOptions, u as KodaXContextTokenSnapshot, m as KodaXAgentMode, W as KodaXRepoIntelligenceMode, a7 as KodaXSkillInvocationContext } from './bash-prefix-extractor.d-BgvMbfq6.js';
+import { c as SessionStorage$1, b as PermissionMode } from './storage.d-CPvn9qI0.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-BZncyzEj.js';
+import { j as KodaXMessage, E as KodaXReasoningMode, o as KodaXProviderCapabilityProfile, d as KodaXCustomProviderConfig } from './types.d-6VOXvF88.js';
+import { A as AgentsFile, f as AutoModeStats, l as KodaXMcpServersConfig } from './guardrail.d-C1DhxnvC.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>;
@@ -339,7 +339,7 @@ declare function executeCommand(parsed: {
 
 /**
  * KodaX CLI Utilities
- * CLI 层工具函数
+ * CLI 灞傚伐鍏峰嚱鏁?
  */
 
 /**
@@ -411,6 +411,8 @@ declare function isProviderConfigured(name: string): boolean;
 declare function loadConfig(): {
     provider?: string;
     model?: string;
+    effort?: string;
+    planModeEffort?: string;
     thinking?: boolean;
     reasoningMode?: KodaXReasoningMode;
     /**
@@ -424,14 +426,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;
     /**
@@ -464,19 +463,18 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodax-ai/kodax",
-  "version": "0.7.56",
+  "version": "0.7.57",
   "description": "极致轻量化 Coding Agent - TypeScript 实现，支持 12 个 LLM 提供商，可发布为免 Node 单文件二进制",
   "type": "module",
   "private": false,
@@ -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/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};