jinzd-ai-cli 0.4.276 → 0.4.278

package/dist/electron-server.js

@@ -13,7 +13,7 @@ import {
 } from "./chunk-SKET65WZ.js";
 import {
   indexProject
-} from "./chunk-QCG6UU2S.js";
+} from "./chunk-PPIISCFN.js";
 import {
   addMemoryEntry,
   backupMemoryStore,
@@ -40,14 +40,14 @@ import {
   touchMemoryReferences,
   updateMemoryApproval,
   updateMemoryEntry
-} from "./chunk-4NH4Q7QK.js";
+} from "./chunk-LXXQTWT2.js";
 import {
   redactJson,
   scanString
 } from "./chunk-FSC6KEWU.js";
 import {
   runTestsTool
-} from "./chunk-ATD2Y3PB.js";
+} from "./chunk-LOXEYWC3.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   APP_NAME,
@@ -80,7 +80,7 @@ import {
   SUBAGENT_MAX_ROUNDS_LIMIT,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-UNL7NR55.js";
+} from "./chunk-SJCOE4C7.js";
 import {
   hasSemanticIndex,
   semanticSearch
@@ -1155,7 +1155,8 @@ var BaseProvider = class {
     return this.reliableContentOnlyTee;
   }
   /**
-   * 该 provider 是否支持 `reasoning_effort` 档位（low/high/max）。目前只有 DeepSeek V4。
+   * 该 provider 是否支持 `reasoning_effort` 档位（low/high/max）。目前是 DeepSeek V4
+   * 与智谱 GLM-5 系列（v0.4.276 接入 GLM-5.3 时补上——它关不掉思考，档位是唯一的成本闸门）。
    *
    * 2026-08-14 审计 P2-03：提示符标签此前无条件渲染成 `[THINK:high]`，于是 Claude
    * （用 thinkingBudget 计 token 预算）和 GLM（根本没有 effort 概念）也显示一个
@@ -2136,6 +2137,16 @@ Node.js does not automatically use system proxies. Try one of the following:
 // src/providers/openai-compatible.ts
 import OpenAI from "openai";
 
+// src/providers/openai-extensions.ts
+function toSdkParams(params) {
+  return params;
+}
+function readReasoningContent(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const value = message.reasoning_content;
+  return typeof value === "string" ? value : void 0;
+}
+
 // src/tools/hallucination.ts
 var HALLUCINATION_PATTERNS = [
   /文件路径[：:]\s*`?[^\s`]+\.\w{1,5}/,
@@ -3377,7 +3388,7 @@ var OpenAICompatibleProvider = class extends BaseProvider {
         continue;
       }
       if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-        const assistantMsg = {
+        msgs.push({
           role: "assistant",
           content: typeof m.content === "string" && m.content ? m.content : null,
           tool_calls: m.toolCalls.map((tc) => ({
@@ -3386,15 +3397,22 @@ var OpenAICompatibleProvider = class extends BaseProvider {
             function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
           })),
           reasoning_content: m.reasoningContent ?? ""
-        };
-        msgs.push(assistantMsg);
+        });
         continue;
       }
-      const base = { role: m.role, content: m.content };
       if (m.role === "assistant") {
-        base.reasoning_content = m.reasoningContent ?? "";
+        msgs.push({
+          role: "assistant",
+          content: typeof m.content === "string" ? m.content : "",
+          reasoning_content: m.reasoningContent ?? ""
+        });
+        continue;
+      }
+      if (m.role === "system") {
+        msgs.push({ role: "system", content: typeof m.content === "string" ? m.content : "" });
+        continue;
       }
-      msgs.push(base);
+      msgs.push({ role: "user", content: m.content });
     }
     const systemContent = [request.systemPrompt, request.systemPromptVolatile].filter(Boolean).join("\n\n---\n\n");
     if (systemContent) {
@@ -3423,12 +3441,13 @@ var OpenAICompatibleProvider = class extends BaseProvider {
    */
   async chat(request) {
     try {
-      const response = await this.client.chat.completions.create({
+      const params = {
         model: request.model,
         messages: this.buildMessages(request),
         ...this.buildChatRequestParams(request),
         stream: false
-      }, {
+      };
+      const response = await this.client.chat.completions.create(toSdkParams(params), {
         timeout: request.timeout ?? this.defaultTimeout,
         signal: request.signal
       });
@@ -3436,7 +3455,7 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       if (!firstChoice) {
         return { content: "", model: response.model, usage: void 0 };
       }
-      const reasoningContent = firstChoice.message.reasoning_content;
+      const reasoningContent = readReasoningContent(firstChoice.message);
       return {
         content: firstChoice.message.content ?? "",
         model: response.model,
@@ -3449,14 +3468,15 @@ var OpenAICompatibleProvider = class extends BaseProvider {
   }
   async *chatStream(request) {
     try {
-      const stream = await this.client.chat.completions.create({
+      const params = {
         model: request.model,
         messages: this.buildMessages(request),
         ...this.buildChatRequestParams(request),
         stream: true,
         // 请求末尾 usage chunk，供 token 统计使用
         stream_options: { include_usage: true }
-      }, {
+      };
+      const stream = await this.client.chat.completions.create(toSdkParams(params), {
         timeout: request.timeout ?? this.defaultTimeout,
         signal: request.signal
       });
@@ -3526,14 +3546,15 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       const baseMessages = this.buildMessages(request);
       const extraMessages = request._extraMessages ?? [];
       const allMessages = [...baseMessages, ...extraMessages];
-      const response = await this.client.chat.completions.create({
+      const params = {
         model: request.model,
         messages: allMessages,
         tools: openaiTools,
         tool_choice: "auto",
         ...this.buildChatRequestParams(request),
         stream: false
-      }, {
+      };
+      const response = await this.client.chat.completions.create(toSdkParams(params), {
         timeout: request.timeout ?? this.defaultTimeout,
         // 非流式路径同样必须收 signal，否则 Ctrl+C 期间整个请求不可中断（见 chat() 上方注释）
         signal: request.signal
@@ -3546,7 +3567,7 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       const finishReason = firstChoice.finish_reason;
       const usage = toUsage(response.usage);
       const hasToolCalls = !!(message.tool_calls && message.tool_calls.length > 0);
-      const reasoningContent = message.reasoning_content;
+      const reasoningContent = readReasoningContent(message);
       if (message.tool_calls && message.tool_calls.length > 0) {
         const toolCalls = message.tool_calls.map((tc) => {
           const parsed = parseToolCallArguments(
@@ -3625,7 +3646,7 @@ var OpenAICompatibleProvider = class extends BaseProvider {
     const extraMessages = request._extraMessages ?? [];
     const allMessages = [...baseMessages, ...extraMessages];
     try {
-      const stream = await this.client.chat.completions.create({
+      const params = {
         model: request.model,
         messages: allMessages,
         tools: openaiTools,
@@ -3633,7 +3654,8 @@ var OpenAICompatibleProvider = class extends BaseProvider {
         ...this.buildChatRequestParams(request),
         stream: true,
         stream_options: { include_usage: true }
-      }, {
+      };
+      const stream = await this.client.chat.completions.create(toSdkParams(params), {
         timeout: request.timeout ?? this.defaultTimeout,
         signal: request.signal
       });
@@ -3751,9 +3773,11 @@ var OpenAICompatibleProvider = class extends BaseProvider {
           name: tc.name,
           arguments: JSON.stringify(tc.arguments)
         }
-      }))
+      })),
+      // DeepSeek V4 thinking 模式严格校验：assistant 消息必须包含 reasoning_content
+      // 字段（即使为空字符串也必须存在，否则 API 返回 400）
+      reasoning_content: reasoningContent ?? ""
     };
-    assistantMsg.reasoning_content = reasoningContent ?? "";
     const resultMsgs = results.map((r) => ({
       role: "tool",
       tool_call_id: r.callId,
@@ -3966,7 +3990,7 @@ var ZhipuProvider = class extends OpenAICompatibleProvider {
   buildChatRequestParams(request) {
     const params = super.buildChatRequestParams(request);
     if (request.thinkingEffort && REASONING_EFFORT_MODELS.test(request.model)) {
-      params["reasoning_effort"] = request.thinkingEffort;
+      params.reasoning_effort = request.thinkingEffort;
     }
     return params;
   }
@@ -8525,7 +8549,7 @@ Do NOT split a long document into many write_file(append=true) calls. That patte
     const mode = appendMode ? "appended" : "written";
     void (async () => {
       try {
-        const { updateFile } = await import("./indexer-M2LJGTY2.js");
+        const { updateFile } = await import("./indexer-RBEKMFT4.js");
         await updateFile(process.cwd(), filePath);
       } catch {
       }
@@ -10733,6 +10757,13 @@ function formatResults2(query, data, _requested) {
   return header + "\n" + results.join("\n\n");
 }
 
+// src/core/tool-capable-provider.ts
+function isToolCapableProvider(provider) {
+  if (!provider) return false;
+  const candidate = provider;
+  return typeof candidate.chatWithTools === "function" && typeof candidate.buildToolResultMessages === "function";
+}
+
 // src/agents/agent-config.ts
 import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync15 } from "fs";
 import { join as join13 } from "path";
@@ -11544,7 +11575,8 @@ async function runSubAgent(task, maxRounds, agentIndex, ctx, agent) {
   if (!ctx.provider) {
     throw new ToolError("spawn_agent", "provider not initialized (context not injected)");
   }
-  const providerFromConfig = agent.provider && ctx.providers?.has(agent.provider) ? ctx.providers.get(agent.provider) : void 0;
+  const configured = agent.provider && ctx.providers?.has(agent.provider) ? ctx.providers.get(agent.provider) : void 0;
+  const providerFromConfig = isToolCapableProvider(configured) ? configured : void 0;
   const provider = providerFromConfig ?? ctx.provider;
   const model = agent.model ?? (providerFromConfig?.info?.defaultModel ?? ctx.model);
   const run = startAgentRun({
@@ -15511,48 +15543,259 @@ function applyThinkCommand(sub, state2) {
   return stay(`Unknown /think option "${sub}" \u2014 expected on | off | low | high | max | status`);
 }
 
+// src/core/provider-command.ts
+function preservedSuffix(messageCount) {
+  return messageCount > 0 ? ` (conversation preserved: ${messageCount} messages)` : "";
+}
+function resolveProviderSwitch(input) {
+  const id = input.targetId;
+  if (!input.configured) {
+    return {
+      status: "not-configured",
+      message: `Provider '${id}' is not configured. Run: aicli config`
+    };
+  }
+  if (input.availableModels.length === 0) {
+    return {
+      status: "no-models",
+      message: `Provider '${id}' has no available models. ` + (id === "ollama" ? "Make sure Ollama is running (`ollama serve`) and has models (`ollama pull <model>`)." : "Check provider configuration.")
+    };
+  }
+  if (id === input.currentProvider) {
+    return { status: "unchanged", message: `Already using provider: ${id}` };
+  }
+  const model = input.configuredDefaultModel || input.providerDefaultModel;
+  return {
+    status: "switched",
+    providerId: id,
+    model,
+    message: `Switched to provider: ${id} (${model})` + preservedSuffix(input.messageCount)
+  };
+}
+function parseModelCommand(args, currentProvider) {
+  const raw = args[0];
+  if (!raw) return { kind: "select" };
+  const sub = raw.toLowerCase();
+  if (sub === "refresh") return { kind: "refresh", providerId: args[1] ?? currentProvider };
+  if (sub === "cache") {
+    if ((args[1] ?? "").toLowerCase() === "clear") return { kind: "cache-clear", providerId: args[2] };
+    return { kind: "cache-show" };
+  }
+  return { kind: "set", modelId: raw };
+}
+function resolveModelSwitch(input) {
+  if (input.targetModel === input.currentModel) {
+    return { status: "unchanged", message: `Already using model: ${input.targetModel}` };
+  }
+  const known = input.knownModels.includes(input.targetModel);
+  return {
+    status: "switched",
+    model: input.targetModel,
+    message: `Switched to model: ${input.targetModel}` + preservedSuffix(input.messageCount),
+    warning: known ? void 0 : `'${input.targetModel}' is not in the known model list for ${input.provider}. If the provider rejects it, check the spelling or run /model refresh ${input.provider}.`
+  };
+}
+var PLAN_MODE_TOOL_HINT = [
+  "read_file \xB7 list_dir \xB7 grep_files \xB7 glob_files",
+  "web_fetch \xB7 google_search \xB7 ask_user \xB7 write_todos"
+];
+function applyPlanCommand(sub, active) {
+  const key = (sub ?? "enter").toLowerCase() === "toggle" ? active ? "exit" : "enter" : (sub ?? "enter").toLowerCase();
+  if (key === "enter") {
+    if (active) {
+      return {
+        planMode: true,
+        changed: false,
+        status: "already-active",
+        summary: "Already in Plan Mode. Use /plan execute to start executing, or /plan exit to leave.",
+        details: []
+      };
+    }
+    return {
+      planMode: true,
+      changed: true,
+      status: "entered",
+      summary: "\u{1F4CB} Plan Mode activated",
+      details: [
+        "AI can now ONLY use read-only tools:",
+        ...PLAN_MODE_TOOL_HINT,
+        "Describe your task and the AI will analyze the codebase and create a detailed implementation plan.",
+        "When ready: /plan execute  |  To cancel: /plan exit"
+      ]
+    };
+  }
+  if (key === "execute") {
+    if (!active) {
+      return { planMode: false, changed: false, status: "not-active", summary: "Not in Plan Mode. Enter first with /plan", details: [] };
+    }
+    return {
+      planMode: false,
+      changed: true,
+      status: "executing",
+      summary: "Plan Mode ended \u2014 switching to execute mode. AI now has full tool access.",
+      details: []
+    };
+  }
+  if (key === "exit" || key === "cancel") {
+    if (!active) {
+      return { planMode: false, changed: false, status: "not-active", summary: "Not in Plan Mode.", details: [] };
+    }
+    return { planMode: false, changed: true, status: "cancelled", summary: "Plan Mode cancelled. Returning to normal mode.", details: [] };
+  }
+  if (key === "status" || key === "show") {
+    return {
+      planMode: active,
+      changed: false,
+      status: "status",
+      summary: `Plan Mode: ${active ? "ACTIVE \u{1F4CB}" : "inactive"}`,
+      details: active ? ["Tools restricted to read-only set.", "Use /plan execute to start executing, or /plan exit to cancel."] : []
+    };
+  }
+  return {
+    planMode: active,
+    changed: false,
+    status: "unknown",
+    summary: `Unknown /plan option "${sub}" \u2014 expected execute | exit | status`,
+    details: []
+  };
+}
+function parseRouteCommand(args) {
+  const sub = (args[0] ?? "show").toLowerCase();
+  if (sub === "on" || sub === "enable") return { kind: "enable" };
+  if (sub === "off" || sub === "disable") return { kind: "disable" };
+  if (sub === "test") {
+    const message = args.slice(1).join(" ").trim();
+    return message ? { kind: "test", message } : { kind: "usage", message: "Usage: /route test <message>" };
+  }
+  if (sub === "show" || sub === "status") return { kind: "show" };
+  return { kind: "unknown", message: `Unknown subcommand: ${sub}. Usage: /route [on|off|show|test <message>]` };
+}
+function routingEmptyRulesNote(routing) {
+  if (routing && routing.rules.length > 0) return null;
+  return 'No rules configured yet. Add rules under `routing.rules` in ~/.aicli/config.json.\nExample: { match: { tag: "fast" }, model: "claude-haiku-4-5" }';
+}
+function describeRoutingRule(rule, index) {
+  const parts = [];
+  if (rule.match.tag) parts.push(`tag=#${rule.match.tag}`);
+  if (rule.match.contains && rule.match.contains.length > 0) {
+    const shown = rule.match.contains.slice(0, 3).join(", ");
+    parts.push(`contains=[${shown}${rule.match.contains.length > 3 ? ", \u2026" : ""}]`);
+  }
+  if (typeof rule.match.maxLength === "number") parts.push(`maxLen=${rule.match.maxLength}`);
+  if (typeof rule.match.minLength === "number") parts.push(`minLen=${rule.match.minLength}`);
+  const empty = parts.length === 0;
+  return {
+    index,
+    name: rule.name,
+    condition: empty ? "(empty \u2014 never matches)" : parts.join(" & "),
+    model: rule.model,
+    empty
+  };
+}
+function describeRouting(input) {
+  const rules = input.routing?.rules ?? [];
+  return {
+    enabled: input.routing?.enabled === true,
+    provider: input.provider,
+    currentModel: input.currentModel,
+    fallback: input.routing?.fallback,
+    rules: rules.map((r, i) => describeRoutingRule(r, i)),
+    noRulesNote: rules.length === 0 ? "(no rules configured \u2014 edit ~/.aicli/config.json `routing.rules`)" : null,
+    hint: "Commands: /route on | off | test <msg> | show"
+  };
+}
+function routeDecisionRows(message, currentModel, decision) {
+  const rows = [
+    { label: "Input", value: message },
+    { label: "Current", value: currentModel },
+    { label: "Decision", value: `${decision.model}  ${decision.overridden ? "\u2192 ROUTED" : "(unchanged)"}` },
+    { label: "Reason", value: decision.reason }
+  ];
+  if (typeof decision.ruleIdx === "number") rows.push({ label: "Rule", value: `#${decision.ruleIdx}` });
+  return rows;
+}
+
 // src/web/commands/provider-commands.ts
+function syncSessionProvider(ctx) {
+  const session = ctx.sessions.current;
+  if (!session) return;
+  session.updateProvider(ctx.currentProvider, ctx.currentModel);
+  ctx.saveIfNeeded();
+}
 async function handleProvider(args, ctx) {
   const id = args[0];
   if (!id) {
     ctx.send({ type: "error", message: "Usage: /provider <id>" });
     return;
   }
-  const p = ctx.providers.get(id);
-  if (!p) {
-    ctx.send({ type: "error", message: `Provider "${id}" not available` });
+  const configured = ctx.providers.has(id);
+  let availableModels = [];
+  let providerDefaultModel = "";
+  if (configured) {
+    const target = ctx.providers.get(id);
+    providerDefaultModel = target.info.defaultModel;
+    availableModels = target.info.models.map((m) => m.id);
+    if (availableModels.length === 0) {
+      try {
+        availableModels = (await target.listModels()).map((m) => m.id);
+      } catch {
+        availableModels = [];
+      }
+    }
+  }
+  const outcome = resolveProviderSwitch({
+    targetId: id,
+    currentProvider: ctx.currentProvider,
+    configured,
+    availableModels,
+    configuredDefaultModel: ctx.config.get("defaultModels")[id],
+    providerDefaultModel,
+    messageCount: ctx.sessions.current?.messages.length ?? 0
+  });
+  if (outcome.status === "not-configured" || outcome.status === "no-models") {
+    ctx.send({ type: "error", message: outcome.message });
+    return;
+  }
+  if (outcome.status === "unchanged") {
+    ctx.send({ type: "info", message: outcome.message });
     return;
   }
-  ctx.currentProvider = id;
-  ctx.currentModel = p.info.defaultModel;
+  ctx.currentProvider = outcome.providerId;
+  ctx.currentModel = outcome.model;
   ctx.updateContextWindow();
-  ctx.send({ type: "info", message: `Switched to provider: ${id} (${ctx.currentModel})` });
+  syncSessionProvider(ctx);
+  ctx.send({ type: "info", message: outcome.message });
   ctx.sendStatus();
 }
 async function handleModel(args, ctx) {
-  const sub = args[0];
-  if (!sub) {
+  const intent = parseModelCommand(args, ctx.currentProvider);
+  if (intent.kind === "select") {
     ctx.send({ type: "error", message: "Usage: /model <id>|refresh [provider]|cache [clear [provider]]" });
     return;
   }
-  if (sub === "refresh") {
-    const providerId = args[1] ?? ctx.currentProvider;
+  if (intent.kind === "refresh") {
+    if (!ctx.providers.has(intent.providerId)) {
+      ctx.send({ type: "error", message: `Provider is not configured: ${intent.providerId}` });
+      return;
+    }
     try {
-      const models2 = await ctx.providers.refreshModels(providerId);
-      ctx.send({ type: "info", message: `Refreshed ${models2.length} model(s) for ${providerId}.` });
+      const models2 = await ctx.providers.refreshModels(intent.providerId);
+      ctx.send({ type: "info", message: `Refreshed ${models2.length} model(s) for ${intent.providerId}.` });
       ctx.sendStatus();
     } catch (err) {
       ctx.send({ type: "error", message: `Model refresh failed: ${err instanceof Error ? err.message : String(err)}` });
     }
     return;
   }
-  if (sub === "cache") {
-    if ((args[1] ?? "").toLowerCase() === "clear") {
-      const providerId = args[2];
-      ctx.providers.clearModelCache(providerId);
-      ctx.send({ type: "info", message: providerId ? `Cleared model cache for ${providerId}.` : "Cleared model cache." });
-      return;
-    }
+  if (intent.kind === "cache-clear") {
+    ctx.providers.clearModelCache(intent.providerId);
+    ctx.send({
+      type: "info",
+      message: intent.providerId ? `Cleared model cache for ${intent.providerId}.` : "Cleared model cache."
+    });
+    return;
+  }
+  if (intent.kind === "cache-show") {
     const rows = ctx.providers.getModelCacheStatus();
     ctx.send({
       type: "info",
@@ -15560,16 +15803,25 @@ async function handleModel(args, ctx) {
     });
     return;
   }
-  const modelId = sub;
   const models = await ctx.providers.listModels(ctx.currentProvider);
-  const found = models.find((m) => m.id === modelId);
-  if (!found) {
-    ctx.send({ type: "error", message: `Model "${modelId}" not found` });
+  const outcome = resolveModelSwitch({
+    targetModel: intent.modelId,
+    currentModel: ctx.currentModel,
+    provider: ctx.currentProvider,
+    knownModels: models.map((m) => m.id),
+    messageCount: ctx.sessions.current?.messages.length ?? 0
+  });
+  if (outcome.status === "unchanged") {
+    ctx.send({ type: "info", message: outcome.message });
     return;
   }
-  ctx.currentModel = modelId;
+  ctx.currentModel = outcome.model;
   ctx.updateContextWindow();
-  ctx.send({ type: "info", message: `Switched to model: ${modelId}` });
+  syncSessionProvider(ctx);
+  ctx.send({
+    type: "info",
+    message: outcome.warning ? `${outcome.message} \u2014 ${outcome.warning}` : outcome.message
+  });
   ctx.sendStatus();
 }
 async function handleThink(args, ctx) {
@@ -15579,7 +15831,7 @@ async function handleThink(args, ctx) {
     runtimeEffort: ctx.runtimeThinkingEffort,
     configuredThinking: modelParams?.thinking,
     configuredEffort: modelParams?.thinkingEffort,
-    supportsEffort: ctx.providers.get(ctx.currentProvider)?.supportsReasoningEffort ?? false,
+    supportsEffort: ctx.providers.has(ctx.currentProvider) ? ctx.providers.get(ctx.currentProvider).supportsReasoningEffort : false,
     provider: ctx.currentProvider
   });
   if (outcome.changed) {
@@ -15593,24 +15845,59 @@ async function handleThink(args, ctx) {
   if (outcome.changed) ctx.sendStatus();
 }
 async function handlePlan(args, ctx) {
-  const sub = args[0];
-  if (sub === "exit" || sub === "cancel") {
-    ctx.planMode = false;
-    ctx.send({ type: "info", message: "Plan mode OFF." });
-  } else if (sub === "execute") {
-    ctx.planMode = false;
-    ctx.send({ type: "info", message: "Plan mode OFF. Executing with all tools enabled." });
-  } else if (sub === "status" || sub === "show") {
-    ctx.send({ type: "info", message: `Plan mode: ${ctx.planMode ? "ON (read-only tools only)" : "OFF"}` });
+  const outcome = applyPlanCommand(args[0], ctx.planMode);
+  if (outcome.changed) ctx.planMode = outcome.planMode;
+  ctx.send({
+    type: outcome.status === "unknown" ? "error" : "info",
+    message: [outcome.summary, ...outcome.details].join(" \u2014 ")
+  });
+  if (outcome.changed) ctx.sendStatus();
+}
+async function handleRoute(args, ctx) {
+  const intent = parseRouteCommand(args);
+  const routing = ctx.config.get("routing");
+  if (intent.kind === "enable" || intent.kind === "disable") {
+    const on = intent.kind === "enable";
+    ctx.config.setByPath("routing.enabled", on ? "true" : "false");
+    const note = on ? routingEmptyRulesNote(routing) : null;
+    ctx.send({
+      type: "info",
+      message: `Smart model routing ${on ? "enabled" : "disabled"}.` + (note ? `
+${note}` : "")
+    });
+    ctx.sendStatus();
+    return;
+  }
+  if (intent.kind === "usage" || intent.kind === "unknown") {
+    ctx.send({ type: "error", message: intent.message });
     return;
-  } else if (sub !== void 0) {
-    ctx.send({ type: "error", message: `Unknown /plan option "${sub}" \u2014 expected execute | exit | status` });
+  }
+  if (intent.kind === "test") {
+    const decision = ctx.computeRoutingDecision(intent.message);
+    ctx.send({
+      type: "info",
+      message: routeDecisionRows(intent.message, ctx.currentModel, decision).map((row) => `${row.label}: ${row.value}`).join("\n")
+    });
     return;
+  }
+  const view = describeRouting({ routing, provider: ctx.currentProvider, currentModel: ctx.currentModel });
+  const lines = [
+    "Smart Model Routing",
+    `Status:   ${view.enabled ? "enabled" : "disabled"}`,
+    `Provider: ${view.provider}`,
+    `Current:  ${view.currentModel}`
+  ];
+  if (view.fallback) lines.push(`Fallback: ${view.fallback}`);
+  if (view.noRulesNote) {
+    lines.push(view.noRulesNote);
   } else {
-    ctx.planMode = !ctx.planMode;
-    ctx.send({ type: "info", message: `Plan mode: ${ctx.planMode ? "ON (read-only tools only)" : "OFF"}` });
+    lines.push("Rules (evaluated top-to-bottom):");
+    for (const rule of view.rules) {
+      lines.push(`  #${rule.index} ${rule.name ? `${rule.name} ` : ""}${rule.condition} \u2192 ${rule.model}`);
+    }
   }
-  ctx.sendStatus();
+  lines.push(view.hint);
+  ctx.send({ type: "info", message: lines.join("\n") });
 }
 
 // src/core/session-cost.ts
@@ -16143,7 +16430,7 @@ Cache:  write=${cacheCreate} read=${cacheRead}` : "";
 Cost:   ${formatCost(cost)}` : "";
   let memoryLine = "";
   try {
-    const { countPendingMemories: countPendingMemories2 } = await import("./persistent-memory-CI544RLT.js");
+    const { countPendingMemories: countPendingMemories2 } = await import("./persistent-memory-JCENBMCJ.js");
     const pending = countPendingMemories2(ctx.config.getConfigDir());
     if (pending > 0) memoryLine = `
 Memory: \u26A0 ${pending} pending approval \u2014 see the Memory panel or /memory`;
@@ -16956,7 +17243,7 @@ async function handleTest(args, ctx) {
       const isCommand = argStr.includes(" ") || /^(mvn|gradle|npm|pytest|cargo|go)\b/.test(argStr);
       testArgs = isCommand ? { command: argStr } : { filter: argStr };
     }
-    const runTests = ctx.runTests ?? (await import("./run-tests-72VNZXNT.js")).executeTests;
+    const runTests = ctx.runTests ?? (await import("./run-tests-2Q5MJHXB.js")).executeTests;
     const report = await runTests(testArgs);
     ctx.send({ type: "info", message: report });
   } catch (err) {
@@ -17134,7 +17421,7 @@ async function handleIndex(args, ctx) {
   const sub = (args[0] ?? "status").toLowerCase();
   const root = process.cwd();
   const { loadIndex: loadIndex2, clearIndex } = await import("./store-VO37H6LS.js");
-  const { indexProject: indexProject2 } = await import("./indexer-M2LJGTY2.js");
+  const { indexProject: indexProject2 } = await import("./indexer-RBEKMFT4.js");
   const { loadVectorStore, clearVectorStore } = await import("./vector-store-JBAE6PS4.js");
   if (sub === "status") {
     const idx = loadIndex2(root);
@@ -17292,7 +17579,7 @@ async function handleMemory(args, ctx) {
     ctx.handleMemoryManage(sub, args[1], sub === "expire" ? args[2] : void 0);
   } else if (sub === "export") {
     if (args[1] === "md") {
-      const { exportMemoryEntries: exportMemoryEntries2 } = await import("./persistent-memory-CI544RLT.js");
+      const { exportMemoryEntries: exportMemoryEntries2 } = await import("./persistent-memory-JCENBMCJ.js");
       ctx.send({
         type: "export_data",
         format: "md",
@@ -17734,7 +18021,8 @@ async function handleHelp(_args, ctx) {
       "  /clear               \u2014 Clear conversation & start new session",
       "  /compact [hint]      \u2014 Compress conversation history",
       "  /think [on|off]      \u2014 Toggle extended thinking mode",
-      "  /plan [enter|exit]   \u2014 Toggle read-only planning mode",
+      "  /plan [execute|exit|status] \u2014 Read-only planning mode (bare /plan enters it)",
+      "  /route [on|off|show|test <msg>] \u2014 Smart model routing",
       "  /session new|list|load|delete <id> \u2014 Session management",
       "  /system [prompt|clear] \u2014 Set/view/reset system prompt",
       "  /context [status|reload] \u2014 Show/reload context layers",
@@ -17871,8 +18159,9 @@ var CLI_ONLY_WEB_COMMANDS = /* @__PURE__ */ new Map([
   ["snapshot", "Dev-state snapshots are written when the terminal REPL exits."],
   ["hooks", "Hook trust is granted per machine from the terminal."],
   ["hook", "Hook trust is granted per machine from the terminal."],
-  // 以下两条并非「终端才有意义」，而是 Web 侧尚未实现——如实说明，别假装是设计。
-  ["route", "Smart model routing is not applied to Web sessions yet (config.routing is REPL-only)."],
+  // 以下一条并非「终端才有意义」，而是 Web 侧尚未实现——如实说明，别假装是设计。
+  // （`route` 曾在这里，理由写的是「Web 尚未应用智能路由」；v0.4.269 让 routing 在 Web
+  // 上真正生效之后那句话就不再成立，命令已在 Web 实现，见 commands/provider-commands.ts。）
   ["security", "Redaction status and toggles are terminal-only for now; /status shows the current profile."]
 ]);
 var webCommandHandlers = {
@@ -17880,6 +18169,7 @@ var webCommandHandlers = {
   model: handleModel,
   think: handleThink,
   plan: handlePlan,
+  route: handleRoute,
   clear: handleClear,
   compact: handleCompact,
   status: handleStatus,
@@ -18052,9 +18342,19 @@ var SessionHandler = class {
     }
     runLifecycleHooks(hooks, "SessionStart", { source: "web" }, { configDir: this.config.getConfigDir() });
     this.sendStatus();
-    askUserContext.rl = null;
+    askUserContext.rl = void 0;
     askUserContext.prompting = false;
   }
+  /**
+   * P3-03：本方法与 `WebCommandContext` 列出的其余 36 个成员一并由 private 放开为
+   * public——它们本就经由 ctx 门面暴露给每一个 web 命令 handler，`private` 只是名义上的。
+   *
+   * `web-command-context.ts` 的文件注释明明白白写着「`ctx: WebCommandContext = this`
+   * 这个赋值保证 handler 只能碰到这些成员」，而 `handleCommand` 实际写的是
+   * `this as unknown as WebCommandContext`——那道保证被这一次 cast 整个绕过了，
+   * 唯一拦着真赋值的就是这些名义上的 private。去掉 cast 之后，SessionHandler 与门面
+   * 接口之间的任何漂移（少一个成员、签名改了）都会当场编译失败，而不是等到运行时。
+   */
   send(msg) {
     if (this.ws.readyState === this.ws.OPEN) {
       this.ws.send(JSON.stringify(msg));
@@ -18423,10 +18723,10 @@ var SessionHandler = class {
         this.processing = false;
         return;
       }
-      const hasToolSupport = typeof provider.chatWithTools === "function";
-      const { toolDefs, mcpBudgetNote } = hasToolSupport ? this.getFilteredToolDefs() : { toolDefs: [], mcpBudgetNote: null };
-      if (hasToolSupport && toolDefs.length > 0) {
-        await this.handleChatWithTools(provider, session.messages, toolDefs, mcpBudgetNote, routingDecision.model);
+      const toolCapable = isToolCapableProvider(provider) ? provider : null;
+      const { toolDefs, mcpBudgetNote } = toolCapable ? this.getFilteredToolDefs() : { toolDefs: [], mcpBudgetNote: null };
+      if (toolCapable && toolDefs.length > 0) {
+        await this.handleChatWithTools(toolCapable, session.messages, toolDefs, mcpBudgetNote, routingDecision.model);
       } else {
         await this.handleChatSimple(provider, session.messages, routingDecision.model);
       }