fix(config): 适配 kimi-code 0.39.1——thinking keep 写字符串 off（布尔会整节作废）、存量布尔归一化；loop_control 默认只写 v2 键（legacy flag 才双写）；effort 移除 max 档；实验 flags 补 remote-control、wait_for/minidb 标默认开启

src-tauri/src/commands.rs

@@ -1293,21 +1293,24 @@ pub async fn kimi_oauth_poll(
 // Experimental feature env-var probe (Kimi Code secondary model etc.)
 // ---------------------------------------------------------------------------
 
-/// Read the Kimi Code experimental-feature environment variables that are
+/// Read the Kimi Code environment variables that are currently set (non-empty)
-/// currently set (non-empty) in this process's environment. The frontend
+/// in this process's environment. The experimental-feature vars are used by the
-/// uses the result to mark config.toml `[experimental]` toggles as locked:
+/// frontend to mark config.toml `[experimental]` toggles as locked: env vars
-/// env vars outrank the config file in Kimi Code's flag resolution.
+/// outrank the config file in Kimi Code's flag resolution. `KIMI_CODE_LEGACY_FLAG`
+/// is probed too — the AgentSettingsPanel uses it to decide whether to
+/// dual-write the v1 engine's loop_control keys.
 ///
 /// Truthy values per the CLI: `1` / `true` / `yes` / `on` (case-insensitive);
 /// the raw values are returned and the truthy check happens on the frontend.
 #[tauri::command]
 pub fn get_experimental_env_status() -> HashMap<String, String> {
-    const VARS: [&str; 5] = [
+    const VARS: [&str; 6] = [
         "KIMI_CODE_EXPERIMENTAL_FLAG",
         "KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL",
         "KIMI_CODE_EXPERIMENTAL_TOOL_SELECT",
-        "KIMI_CODE_EXPERIMENTAL_ACP_V2",
         "KIMI_CODE_EXPERIMENTAL_PERSISTENCE_MINIDB_READMODEL",
+        "KIMI_CODE_EXPERIMENTAL_REMOTE_CONTROL",
+        "KIMI_CODE_LEGACY_FLAG",
     ];
     let mut out = HashMap::new();
     for name in VARS {

src/components/AgentSettingsPanel.tsx

@@ -1,7 +1,14 @@
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
 import { useTranslation } from "../i18n";
 import type { TranslationKey } from "../i18n/zh";
 import { getAgentSettings, setAgentSettings } from "../lib/agent-settings";
-import type { AgentSettings, Hook, PermissionRule } from "../types";
+import type {
+  AgentSettings,
+  ExperimentalEnvStatus,
+  Hook,
+  PermissionRule,
+} from "../types";
 import { Card, Checkbox, NumberField, Segmented } from "./ui/controls";
 
 interface AgentSettingsPanelProps {
@@ -9,12 +16,12 @@ interface AgentSettingsPanelProps {
   onChange: (nextRawOther: unknown) => void;
 }
 
-const THINKING_LEVELS = ["low", "medium", "high", "max"] as const;
+// Upstream removed the "max" effort tier (auto-migrates to "high").
+const THINKING_LEVELS = ["low", "medium", "high"] as const;
 const THINKING_LABELS: Record<(typeof THINKING_LEVELS)[number], TranslationKey> = {
   low: "thinkingLow",
   medium: "thinkingMedium",
   high: "thinkingHigh",
-  max: "thinkingMax",
 };
 
 const PERMISSION_DECISIONS = ["allow", "deny", "ask"] as const;
@@ -40,9 +47,23 @@ const COMMON_EVENTS = [
 export function AgentSettingsPanel({ rawOther, onChange }: AgentSettingsPanelProps) {
   const { t } = useTranslation();
   const settings = getAgentSettings(rawOther);
+  /**
+   * KIMI_CODE_LEGACY_FLAG=1 keeps the v1 loop_control keys dual-written for
+   * v1-engine users; the default (v2) writes only max_attempts_per_step.
+   */
+  const [legacyV1, setLegacyV1] = useState(false);
+
+  useEffect(() => {
+    invoke<ExperimentalEnvStatus>("get_experimental_env_status")
+      .then((env) => {
+        const value = env?.KIMI_CODE_LEGACY_FLAG ?? "";
+        setLegacyV1(["1", "true", "yes", "on"].includes(value.trim().toLowerCase()));
+      })
+      .catch(() => setLegacyV1(false));
+  }, []);
 
   const update = (patch: Partial<AgentSettings>) => {
-    onChange(setAgentSettings(rawOther, patch));
+    onChange(setAgentSettings(rawOther, patch, { legacyV1 }));
   };
 
   const updateThinking = (patch: Partial<AgentSettings["thinking"]>) => {
@@ -95,7 +116,7 @@ export function AgentSettingsPanel({ rawOther, onChange }: AgentSettingsPanelPro
           label={t("thinkingKeep")}
           checked={settings.thinking?.keep === "all"}
           disabled={!thinkingEnabled}
-          onChange={(checked) => updateThinking({ keep: checked ? "all" : false })}
+          onChange={(checked) => updateThinking({ keep: checked ? "all" : "off" })}
         />
         <p className="text-xs text-content-muted">{t("thinkingContextHint")}</p>
       </Card>

src/components/SubagentSettingsPage.tsx

@@ -9,6 +9,7 @@ import {
   forcedEnvValue,
   getExperimentalFlags,
   getSubagentModelPool,
+  isExperimentalFlagSet,
   isFlagLockedByEnv,
   isMasterEnvOn,
   removeSubagentPoolEntry,
@@ -33,12 +34,12 @@ interface SubagentSettingsPageProps {
   onBack: () => void;
 }
 
-const EFFORTS = ["low", "medium", "high", "max"] as const;
+// Upstream removed the "max" effort tier (auto-migrates to "high").
+const EFFORTS = ["low", "medium", "high"] as const;
 const EFFORT_LABELS: Record<(typeof EFFORTS)[number], TranslationKey> = {
   low: "thinkingLow",
   medium: "thinkingMedium",
   high: "thinkingHigh",
-  max: "thinkingMax",
 };
 
 const FLAG_LABELS: Record<string, { name: TranslationKey; desc: TranslationKey }> = {
@@ -55,6 +56,7 @@ const FLAG_LABELS: Record<string, { name: TranslationKey; desc: TranslationKey }
     name: "flagAutoSessionTitle",
     desc: "flagAutoSessionTitleDesc",
   },
+  "remote-control": { name: "flagRemoteControl", desc: "flagRemoteControlDesc" },
 };
 
 /** Validation-error i18n key per engine rule, for the pre-write self-check. */
@@ -235,7 +237,9 @@ export function SubagentSettingsPage({
         ? `${Math.round(n / 1000)}K`
         : String(n);
   const effortLabel = (e: string): string => {
-    const key = EFFORT_LABELS[e as (typeof EFFORTS)[number]];
+    // Stored "max" tiers from old configs are shown as "high" (upstream
+    // removed the tier; it auto-migrates to "high").
+    const key = EFFORT_LABELS[e === "max" ? "high" : (e as (typeof EFFORTS)[number])];
     return key ? t(key) : e;
   };
 
@@ -297,15 +301,27 @@ export function SubagentSettingsPage({
   const renderFlagRow = (flag: ExperimentalFlagDef) => {
     const labels = FLAG_LABELS[flag.id];
     const locked = masterOn || isFlagLockedByEnv(env, flag);
+    // An explicitly written flag (true or false) wins; an absent flag falls
+    // back to the upstream default (`defaultEnabled`).
+    const explicitlySet = isExperimentalFlagSet(rawOther, flag.id);
     const on = masterOn
       ? true
       : isFlagLockedByEnv(env, flag)
         ? forcedEnvValue(env, flag)
-        : flags[flag.id] === true;
+        : explicitlySet
+          ? flags[flag.id] === true
+          : (flag.defaultEnabled ?? false);
     return (
       <div key={flag.id} className="flex items-center gap-3">
         <div className="flex-1 min-w-0">
-          <div className="text-sm text-content-primary">{t(labels.name)}</div>
+          <div className="flex items-center gap-2 text-sm text-content-primary">
+            {t(labels.name)}
+            {!locked && !explicitlySet && flag.defaultEnabled && (
+              <span className="shrink-0 text-xs text-blue-600 dark:text-blue-400 border border-blue-500/30 rounded px-1">
+                {t("flagDefaultOn")}
+              </span>
+            )}
+          </div>
           <div className="text-xs text-content-muted">
             {t(labels.desc)}
             <code className="ml-2">{flag.envVar}</code>

src/i18n/en.ts

@@ -138,7 +138,6 @@ export const enTranslations: Record<TranslationKey, string> = {
   thinkingLow: "Low",
   thinkingMedium: "Medium",
   thinkingHigh: "High",
-  thinkingMax: "Max",
   thinkingContextHint: "Thinking uses more context. Ensure the model context length and reserved size are sufficient.",
   loopControlSettings: "Loop Control",
   maxAttemptsPerStep: "Max attempts per step",
@@ -476,6 +475,9 @@ export const enTranslations: Record<TranslationKey, string> = {
   flagWaitForDesc: "The agent can wait for background tasks to finish within the current turn",
   flagAutoSessionTitle: "Auto Session Title",
   flagAutoSessionTitleDesc: "Generate session titles automatically via the managed chat_title tool",
+  flagRemoteControl: "Remote Control",
+  flagRemoteControlDesc: "Enable the experimental remote control feature",
+  flagDefaultOn: "On by default",
   lockedByEnv: "Locked by env var",
   masterEnvOnHint: "KIMI_CODE_EXPERIMENTAL_FLAG is set: all experimental features are forced on by the env var",
   secondaryModelSection: "Subagent Model (Secondary Model)",

src/i18n/zh.ts

@@ -136,7 +136,6 @@ export const zhTranslations = {
   thinkingLow: "低",
   thinkingMedium: "中",
   thinkingHigh: "高",
-  thinkingMax: "最大",
   thinkingContextHint: "启用思考会占用更多上下文，请确保模型上下文长度和预留空间足够。",
   loopControlSettings: "循环控制",
   maxAttemptsPerStep: "单步最大尝试次数",
@@ -471,6 +470,9 @@ export const zhTranslations = {
   flagWaitForDesc: "代理可在当前回合内等待后台任务完成，而无需结束回合再被唤醒",
   flagAutoSessionTitle: "自动会话标题",
   flagAutoSessionTitleDesc: "通过托管 chat_title 工具自动生成会话标题",
+  flagRemoteControl: "远程控制",
+  flagRemoteControlDesc: "启用实验性远程控制功能",
+  flagDefaultOn: "默认开启",
   lockedByEnv: "被环境变量锁定",
   masterEnvOnHint: "KIMI_CODE_EXPERIMENTAL_FLAG 已设置：全部实验功能被环境变量强制开启",
   secondaryModelSection: "子代理模型（次主力模型）",

src/lib/agent-settings.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import { getAgentSettings, setAgentSettings } from "./agent-settings";
+
+// ---------------------------------------------------------------------------
+// Helpers — drill into the written `[thinking]` / `[loop_control]` sections
+// ---------------------------------------------------------------------------
+
+function thinkingOf(raw: unknown): Record<string, unknown> {
+  const t = (raw as { thinking?: unknown })?.thinking;
+  return t && typeof t === "object" && !Array.isArray(t)
+    ? (t as Record<string, unknown>)
+    : {};
+}
+
+function loopOf(raw: unknown): Record<string, unknown> {
+  const l = (raw as { loop_control?: unknown })?.loop_control;
+  return l && typeof l === "object" && !Array.isArray(l)
+    ? (l as Record<string, unknown>)
+    : {};
+}
+
+// ---------------------------------------------------------------------------
+// Reading — legacy off values normalized to "off", "max" → "high"
+// ---------------------------------------------------------------------------
+
+describe("getAgentSettings — thinking.keep normalization", () => {
+  it("normalizes a legacy boolean `false` to \"off\"", () => {
+    expect(getAgentSettings({ thinking: { keep: false } }).thinking?.keep).toBe(
+      "off"
+    );
+  });
+
+  it("normalizes the other legacy off values (0, null, \"no\", \"none\") to \"off\"", () => {
+    for (const v of [0, null, "no", "none"]) {
+      expect(
+        getAgentSettings({ thinking: { keep: v } }).thinking?.keep
+      ).toBe("off");
+    }
+  });
+
+  it("keeps \"all\" and \"off\" as-is on read", () => {
+    expect(getAgentSettings({ thinking: { keep: "all" } }).thinking?.keep).toBe(
+      "all"
+    );
+    expect(getAgentSettings({ thinking: { keep: "off" } }).thinking?.keep).toBe(
+      "off"
+    );
+  });
+
+  it("keeps the default \"all\" when the key is absent", () => {
+    expect(getAgentSettings({}).thinking?.keep).toBe("all");
+  });
+});
+
+describe("getAgentSettings — effort \"max\" read mapping", () => {
+  it("normalizes a stored \"max\" to \"high\" on read", () => {
+    expect(getAgentSettings({ thinking: { effort: "max" } }).thinking?.effort).toBe(
+      "high"
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Writing — keep: "all" round-trips, "off" is written for legacy off values,
+// absent keep is not materialized
+// ---------------------------------------------------------------------------
+
+describe("setAgentSettings — keep serialization", () => {
+  it("round-trips keep = \"all\"", () => {
+    const raw = { thinking: { keep: "all" } };
+    const next = setAgentSettings(raw, { thinking: { keep: "all" } });
+    expect(thinkingOf(next).keep).toBe("all");
+  });
+
+  it("writes \"off\" (string) for a legacy keep = false, never a boolean", () => {
+    const next = setAgentSettings({ thinking: { keep: false } }, {});
+    expect(thinkingOf(next).keep).toBe("off");
+  });
+
+  it("does not write the keep key when it was never set (absent in raw and patch)", () => {
+    expect(thinkingOf(setAgentSettings({}, {}))).not.toHaveProperty("keep");
+    const next = setAgentSettings(
+      { thinking: { enabled: true } },
+      { thinking: { effort: "high" } }
+    );
+    expect(thinkingOf(next)).not.toHaveProperty("keep");
+    expect(thinkingOf(next).effort).toBe("high");
+  });
+
+  it("writes the key when an absent raw config's keep is explicitly toggled off", () => {
+    const next = setAgentSettings({}, { thinking: { keep: "off" } });
+    expect(thinkingOf(next).keep).toBe("off");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loop_control — v2 default writes only max_attempts_per_step; legacyV1 opts
+// dual-writes; read fallback from the v1 key is preserved
+// ---------------------------------------------------------------------------
+
+describe("loop_control — v1/v2 key handling", () => {
+  const raw = { loop_control: { max_attempts_per_step: 5, max_retries_per_step: 5 } };
+
+  it("default (v2): a save strips the legacy max_retries_per_step key", () => {
+    const next = setAgentSettings(raw, { loop_control: { reserved_context_size: 60000 } });
+    expect(loopOf(next).max_attempts_per_step).toBe(5);
+    expect(loopOf(next)).not.toHaveProperty("max_retries_per_step");
+  });
+
+  it("default (v2): a dual-write patch ends up with only the v2 key", () => {
+    const next = setAgentSettings(
+      raw,
+      { loop_control: { max_attempts_per_step: 7, max_retries_per_step: 7 } }
+    );
+    expect(loopOf(next).max_attempts_per_step).toBe(7);
+    expect(loopOf(next)).not.toHaveProperty("max_retries_per_step");
+  });
+
+  it("legacyV1: both keys are written", () => {
+    const next = setAgentSettings(
+      raw,
+      { loop_control: { max_attempts_per_step: 7, max_retries_per_step: 7 } },
+      { legacyV1: true }
+    );
+    expect(loopOf(next).max_attempts_per_step).toBe(7);
+    expect(loopOf(next).max_retries_per_step).toBe(7);
+  });
+
+  it("read fallback keeps a max_retries_per_step-only config editable", () => {
+    const s = getAgentSettings({ loop_control: { max_retries_per_step: 4 } });
+    expect(s.loop_control?.max_attempts_per_step).toBe(4);
+    expect(s.loop_control?.max_retries_per_step).toBe(4);
+  });
+});

src/lib/agent-settings.ts

@@ -49,11 +49,24 @@ export function getAgentSettings(rawOther: unknown): AgentSettings {
   ) {
     loop.max_attempts_per_step = sectionLoop.max_retries_per_step;
   }
-  return {
+  const thinking = {
-    thinking: {
     ...DEFAULT_SETTINGS.thinking,
     ...getSection<AgentSettings["thinking"]>(rawOther, "thinking"),
-    },
+  };
+  // Upstream engines only accept string off values ("off"/"none"/"no"; see
+  // KEEP_OFF_VALUES) — a `false` from an old config fails the v2 validator
+  // and the v1 strict parse. Normalize every legacy off value to "off" for
+  // display; the serialization path (setAgentSettings) writes the string.
+  if (thinking.keep !== undefined && thinking.keep !== "all") {
+    thinking.keep = "off";
+  }
+  // The "max" effort tier was removed upstream (auto-migrates to "high");
+  // old configs still carrying it are shown as "high" (not rewritten on read).
+  if (thinking.effort === "max") {
+    thinking.effort = "high";
+  }
+  return {
+    thinking,
     loop_control: loop,
     background: {
       ...DEFAULT_SETTINGS.background,
@@ -70,7 +83,8 @@ export function getAgentSettings(rawOther: unknown): AgentSettings {
 
 export function setAgentSettings(
   rawOther: unknown,
-  patch: Partial<AgentSettings>
+  patch: Partial<AgentSettings>,
+  opts?: { legacyV1?: boolean }
 ): unknown {
   const root = { ...asRecord(rawOther) };
   const current = getAgentSettings(rawOther);
@@ -84,6 +98,20 @@ export function setAgentSettings(
     hooks: patch.hooks ?? current.hooks ?? [],
   };
 
+  // `keep` is only written when the source config explicitly carries it or the
+  // patch sets it — an absent key keeps the engine default ("all") instead of
+  // being materialized, so a plain save does not add the key.
+  const rawThinking = asRecord(getSection(rawOther, "thinking"));
+  const patchHasKeep = patch.thinking !== undefined && "keep" in patch.thinking;
+  if (!("keep" in rawThinking) && !patchHasKeep) {
+    delete next.thinking?.keep;
+  }
+
+  // The v2 engine (default) only reads max_attempts_per_step; the legacy v1
+  // key is stripped on save unless KIMI_CODE_LEGACY_FLAG=1 (v1 engine compat).
+  if (!opts?.legacyV1) {
+    delete next.loop_control?.max_retries_per_step;
+  }
   if (next.thinking) root.thinking = next.thinking;
   if (next.loop_control) root.loop_control = next.loop_control;
   if (next.background) root.background = next.background;

src/lib/subagent-settings.test.ts

@@ -231,6 +231,31 @@ describe("pool mutations", () => {
     expect(section(updated).default_model).toBe("kimi-k1");
   });
 
+  it("upsertSubagentPoolEntry materializes the implicit default into a new table", () => {
+    // Implicit single-entry form (default_model set, no models table): adding a
+    // second alias must pull the default into the table, otherwise the result
+    // violates "default_model must be a pool key" (rule 3) and gets rejected.
+    const raw = rawWith({ default_model: "kimi-k1", force: false });
+    const added = upsertSubagentPoolEntry(raw, "kimi-k2", "");
+    expect(modelsOf(added)).toEqual({ "kimi-k1": "", "kimi-k2": "" });
+    expect(section(added).default_model).toBe("kimi-k1");
+    const pool = getSubagentModelPool(added);
+    expect(pool).toBeDefined();
+    expect(
+      validateSubagentPool(pool!, ["kimi-k1", "kimi-k2"]),
+    ).toEqual([]);
+  });
+
+  it("upsertSubagentPoolEntry upgrades a legacy `model`-only section to a valid pool", () => {
+    const raw = rawWith({ model: "kimi-k1" });
+    const added = upsertSubagentPoolEntry(raw, "kimi-k2", "K2");
+    expect(modelsOf(added)).toEqual({ "kimi-k1": "", "kimi-k2": "K2" });
+    expect(section(added).default_model).toBe("kimi-k1");
+    expect(section(added).model).toBe("kimi-k1");
+    const pool = getSubagentModelPool(added);
+    expect(validateSubagentPool(pool!, ["kimi-k1", "kimi-k2"])).toEqual([]);
+  });
+
   it("removeSubagentPoolEntry keeps the default when removing a non-default alias", () => {
     const raw = rawWith({
       default_model: "kimi-k1",

src/lib/subagent-settings.ts

@@ -28,27 +28,36 @@ export interface ExperimentalFlagDef {
   id: string;
   /** Single-feature env var that can force the flag (locks the UI toggle). */
   envVar: string;
+  /** Feature turned on by default upstream; an absent config key falls back
+   *  to this, while an explicit `false` in `[experimental]` still wins. */
+  defaultEnabled?: boolean;
 }
 
 /** Known experimental flags — mirrors the kimi-code v2 flag registry
  * (the per-feature flag.ts files under packages/agent-core-v2/src:
  * secondary-model, tool-select, persistence_minidb_readmodel, tower,
- * subagent_fork, wait_for, auto_session_title). `acp-v2` was removed
+ * subagent_fork, wait_for, auto_session_title, remote-control). `acp-v2` was
- * upstream and is dropped here. */
+ * removed upstream and is dropped here. */
 export const EXPERIMENTAL_FLAGS: ExperimentalFlagDef[] = [
   { id: "secondary-model", envVar: "KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL" },
   { id: "tool-select", envVar: "KIMI_CODE_EXPERIMENTAL_TOOL_SELECT" },
   {
     id: "persistence_minidb_readmodel",
     envVar: "KIMI_CODE_EXPERIMENTAL_PERSISTENCE_MINIDB_READMODEL",
+    defaultEnabled: true,
   },
   { id: "tower", envVar: "KIMI_CODE_EXPERIMENTAL_TOWER" },
   { id: "subagent_fork", envVar: "KIMI_CODE_EXPERIMENTAL_SUBAGENT_FORK" },
-  { id: "wait_for", envVar: "KIMI_CODE_EXPERIMENTAL_WAIT_FOR" },
+  {
+    id: "wait_for",
+    envVar: "KIMI_CODE_EXPERIMENTAL_WAIT_FOR",
+    defaultEnabled: true,
+  },
   {
     id: "auto_session_title",
     envVar: "KIMI_CODE_EXPERIMENTAL_AUTO_SESSION_TITLE",
   },
+  { id: "remote-control", envVar: "KIMI_CODE_EXPERIMENTAL_REMOTE_CONTROL" },
 ];
 
 export const EXPERIMENTAL_MASTER_ENV = "KIMI_CODE_EXPERIMENTAL_FLAG";
@@ -87,6 +96,15 @@ export function getExperimentalFlags(rawOther: unknown): Record<string, boolean>
   return out;
 }
 
+/** Whether a flag is explicitly written in `[experimental]` (true *or* false).
+ *  An absent flag falls back to the upstream default (`defaultEnabled`). */
+export function isExperimentalFlagSet(rawOther: unknown, id: string): boolean {
+  return Object.prototype.hasOwnProperty.call(
+    asRecord(asRecord(rawOther)["experimental"]),
+    id
+  );
+}
+
 /** Set one flag in `[experimental]`. Removing all flags drops the section. */
 export function setExperimentalFlag(
   rawOther: unknown,
@@ -256,8 +274,11 @@ export function setSubagentModelPool(
   return root;
 }
 
-/** Add or update one alias in the pool `models` table. The rest of the
+/** Add or update one alias in the pool `models` table. When the section is
- *  section (default, force, unknown fields) is preserved untouched. */
+ *  the implicit single-entry form (a `default_model`/`model` but no table),
+ *  the effective default is materialized into the table first — otherwise the
+ *  new table would fail the engine rule "default_model must be a pool key".
+ *  The rest of the section (force, unknown fields) is preserved untouched. */
 export function upsertSubagentPoolEntry(
   rawOther: unknown,
   alias: string,
@@ -269,8 +290,21 @@ export function upsertSubagentPoolEntry(
   for (const [k, v] of Object.entries(section)) next[k] = v;
   const models: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(asRecord(next.models))) models[k] = v;
+  const effectiveDefault =
+    typeof next.default_model === "string" && next.default_model !== ""
+      ? next.default_model
+      : typeof next.model === "string" && next.model !== ""
+        ? next.model
+        : undefined;
+  if (effectiveDefault !== undefined && !(effectiveDefault in models)) {
+    models[effectiveDefault] = "";
+  }
   models[alias] = description;
   next.models = models;
+  if (effectiveDefault !== undefined) {
+    next.default_model = effectiveDefault;
+    next.model = effectiveDefault;
+  }
   root.secondary_model = next;
   return root;
 }

src/types/index.ts

@@ -100,7 +100,18 @@ export interface DiscoveredModel {
 
 export interface ThinkingConfig {
   enabled?: boolean;
+  /**
+   * Effort tier. `max` is read-compatible only — upstream removed the tier
+   * (old configs auto-migrate to `high`); the UI normalizes it and the
+   * serialization path never writes it.
+   */
   effort?: "low" | "medium" | "high" | "max";
+  /**
+   * Keep thinking content. The legacy off values (`false`, `0`, "no", "none",
+   * `null`) are read-compatible — old configs may carry them; the UI
+   * normalizes them to `"off"` and the serialization path never emits a
+   * boolean (upstream engines only accept string off values).
+   */
   keep?: "all" | false | 0 | "no" | "off" | "none" | null;
 }
 
@@ -109,7 +120,8 @@ export interface LoopControlConfig {
   max_attempts_per_step?: number;
   /** v2 engine key (kimi-code 0.33+): `max_steps_per_run` was renamed. */
   max_steps_per_turn?: number;
-  /** Legacy v1 key — written in sync so KIMI_CODE_LEGACY_FLAG=1 still works. */
+  /** Legacy v1 key — read fallback only; written/kept only when
+   *  KIMI_CODE_LEGACY_FLAG=1 (v1 engine compat). v2 saves strip it. */
   max_retries_per_step?: number;
   reserved_context_size?: number;
 }