@luchenglong/cli-bridge 0.2.4 → 0.2.5

package/dynamic/mimo.host.js

@@ -3,7 +3,7 @@
 // 构建（node scripts/build.mjs --only=mimo）把 core/bridge-kit.mjs 与
 // providers/mimo.mjs 分别内联进下方两个占位标记行（各占一行、行内仅此标记），
 // 生成 dynamic/mimo.host.js。注意：标记字面量绝不能出现在本注释里 —— 构建做全局
-// 替换，注释中出现同样会被替换成正文代码而炸掉语法。
+// 替换，注释中出现同样也会被替换成正文代码而炸掉语法。
 // 沙箱纪律（旧仓 dynamic/host.js 头注 verbatim 精神）：
 //  - 禁 import/require、无 TypeScript；无 AbortController/process 裸引用/Buffer/原生
 //    定时器 —— process 只经 typeof 守卫探测；宿主能力全部来自注入的 harness.*/ctx。
@@ -12,14 +12,9 @@
 //  - 无 ctx.emit：状态经 ctx.get('cliBridgeCollector').mergeSnapshot('mimo', snap)
 //    推给家级灯（旧 mimoCollector 服务名在 keystone 里保留别名）；动态形态不宣告
 //    mode（旧语义：普通模式灯仅在调用 mimo 时临时显示）。
-//  - mimo-desktop 在沙箱的形态（契约 §9）：无 fs 发现 desktop-api.json，且多数沙箱
-//    无 fetch —— 描述符 preflight 直接 abort 为 DESKTOP_UNREACHABLE 并提示改用
-//    backend=mimocode（旧仓返回 DESKTOP_UNSUPPORTED 的替代；语义升级，Lead 定案）。
-//    宿主若注入了 globalThis.fetch 且给出 MIMO_DESKTOP_PORT/MIMO_DESKTOP_TOKEN env，
-//    委托 execute 仍可走通（fetch 路径全部 typeof 守卫）。
 //  - mimo_settings 在沙箱不持久化（无 nodeFs → 描述符回显语义；旧 dynamic echo 形态）。
-//  - exe 解析（旧动态候选无 existsSync 校验，盲取候选 [0] 易 spawn 失败）：升级走
-//    agy 模板同款链路 —— MIMO_BIN/MIMO_CLI env > subprocess.resolveExecutable(PATH)。
+//  - 单后端（本地 mimo CLI / MiMoCode）：exe 解析走 agy 模板同款链路 ——
+//    MIMO_BIN/MIMO_CLI env > 已知安装位置 > subprocess.resolveExecutable(PATH)。
 // core/bridge-kit.mjs — CLI Bridge 单一事实来源：通用执行/状态骨架。
 //
 // 深度重构核心（合并 agy-first-bridge / codebuddy-first-bridge / mimo-first-bridge）：
@@ -570,75 +565,152 @@ function createRunner(o) {
   return { coreExecute, runSync, askFallback }
 }
 
-// providers/mimo.mjs — mimo provider descriptor（真移植，替换 Lead 冒烟占位）。
+// providers/mimo.mjs — mimo provider descriptor（单后端：本地 mimo CLI / MiMoCode）。
 //
-// 移植基线：mimo-first-bridge v1.x Xiaomi MiMo-bridge 仓 core/mimo-core.mjs +
-// core/runtime-settings.mjs + preset/mimo-first/mimo-first-bridge.mjs 的内联逻辑
-// （双后端 mimocode/mimo-desktop、buildArgv/parseMimoJson/buildResult/桌面回合编排/
-// 三工具 schema/mimo_settings），语义逐字保持；与 provider 无关的骨架（状态引擎/行流/
-// 回退弹窗/展示层/超时护栏）在 core/bridge-kit.mjs（PROVIDER-CONTRACT.md §1）。
+// 移植基线：mimo-first-bridge v1.x 仓 core/mimo-core.mjs + core/runtime-settings.mjs +
+// preset/mimo-first/mimo-first-bridge.mjs 的内联逻辑（buildArgv / parseMimoJson /
+// buildResult / 三工具 schema / mimo_settings），语义逐字保持；与 provider 无关的骨架
+// （状态引擎/行流/回退弹窗/展示层/超时护栏）在 core/bridge-kit.mjs（契约 §1）。
 //
-// 红线（PROVIDER-CONTRACT.md §8 + Lead 定案）：
-//  - 本文件会被 build 内联进 dynamic 沙箱（new Function）：绝不出现 import.meta 字面量；
-//    process/fs/child_process 只经 deps 注入或 typeof/globalThis 守卫读取；原生定时器
-//    （setTimeout/AbortController）只在 typeof 守卫下使用（沙箱缺省时自动降级）。
-//  - 只允许 import '../core/bridge-kit.mjs'。
-//  - mimo-desktop 走本地 HTTP（非 spawn）：delegates(backend) 只认 desktop，execute 自己
-//    复刻旧回合编排；mimocode 不写 execute 分支 → kit 通用 pipeline 带 jobs/重试/弹窗。
-
-// ── 后端常量与别名归一（旧 mimo-core verbatim）────────────────────────────────
-const BACKEND_MIMOCODE = 'mimocode'
-const BACKEND_DESKTOP = 'mimo-desktop'
-const BACKENDS = [BACKEND_MIMOCODE, BACKEND_DESKTOP]
-const DEFAULT_BACKEND = BACKEND_MIMOCODE
+// 2026-10 去 desktop 化（用户定案：MiMo 免费 API 服务已被官方终止 + 本机 0 凭据）：
+//  1. 取消 mimo-desktop 后端 —— 只走 `mimo run`（MiMoCode CLI，官方便携安装位置
+//     ~/.mimocode/bin/mimo.exe）；登录由用户在 CLI 侧 `mimo auth login` 自理。
+//  2. 模型由用户在设置里手动指定（settings.defaultModel，不写死默认值）；留空 =
+//     不传 --model，交给 mimo CLI 自身默认。可用模型以 `mimo models` 实测为准
+//     （xiaomi/mimo-v2.6-flash / -pro / -pro-ultraspeed 等）。
+//  3. 是否启用 mimo 由调度（_scheduling.enabled）控制；本描述符不含任何开关。
+//
+// 红线（PROVIDER-CONTRACT.md §8 + Lead 定案）：本文件会被 build 内联进 dynamic 沙箱
+// （new Function）—— 绝不出现 import.meta 字面量；process/fs/child_process 只经
+// globalThis.process.getBuiltinModule + typeof 守卫读取；只允许 import bridge-kit。
+// import { createStatusEngine, createRunner, clampInt, shortLabel, summarizeArgs } from '../core/bridge-kit.mjs'
+// ── 单后端归一（旧 mimo-core 双后端 verbatim 的收缩形态）───────────────────────
+// mimo-desktop 取消后不再有第二后端：backends() 恒 null；任何输入（含历史别名
+// mimocode / mimo-cli / desktop / 空串 / 非法值）一律归一为 null。会话路由由
+// engine.resolveTarget（cwd + sessionId）完成，backend 恒 null。
+const DEFAULT_TIMEOUT_SEC = 600
 
 // 旧 LIMIT_RE（比 kit 版多 free-API/登录/第三方等 MiMo 文案；provider.isLimited 覆盖）。
 // 命名 MIMO_ 前缀：dynamic 内联时 kit 也声明顶层 LIMIT_RE，同名会在同一脚本作用域
 // 触发「Identifier already declared」构建错误（scripts/build.mjs 文本拼接的固有约束）。
 const MIMO_LIMIT_RE = /rate.?limit|ratelimit|429|too many|quota|insufficient|credit|balance|exhausted|exceed|network|offline|ENETUNREACH|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|timeout|timed out|unavailable|503|502|500|401|403|unauthorized|invalid api|api key|connection|proxy|socket|tls|ssl|dns|free API service has ended|sign in|configure a third-party|网络|超时|限流|流量|受限|配额|金额|余额|额度|认证|连接|断开|登录|第三方/i
 
-const DEFAULT_TIMEOUT_SEC = 600
+// ── Node 内建探测（沙箱纪律：getBuiltinModule + typeof 守卫）───────────────────
+// 名字带 mimo 前缀：本文件会与 bridge-kit / core/scheduling.mjs【文本内联进同一个动态
+// 沙箱脚本作用域】，撞名即「Identifier already declared」构建错误。
+function mimoBuiltin(name) {
+  try {
+    const proc = globalThis.process
+    return (proc && typeof proc.getBuiltinModule === 'function') ? proc.getBuiltinModule(name) : null
+  } catch (e) { return null }
+}
+
+// ── 可执行文件解析（env MIMO_BIN/MIMO_CLI > 已知安装位置 > PATH 名字）───────────
+// MiMoCode CLI 官方便携安装目录：<USERPROFILE|HOME>/.mimocode/bin/mimo[.exe]。
+// 沙箱内可能没有 fs —— 全部读取走 typeof 守卫，读不到就返回空数组（退回 PATH 查找）。
+const MIMO_EXE_DIR = ['.mimocode', 'bin']
+
+/** 探测本机 mimo 可执行文件候选路径（官方便携安装位置）；无 fs 能力时返回空数组。 */
+function mimoCandidateExePaths(env) {
+  const e = env || {}
+  const out = []
+  const fs = mimoBuiltin('node:fs')
+  if (!fs || typeof fs.existsSync !== 'function') return out
+  const path = mimoBuiltin('node:path')
+  const join = (path && typeof path.join === 'function') ? ((a, b) => path.join(a, b)) : ((a, b) => a + '/' + b)
+  for (const k of ['USERPROFILE', 'HOME']) {
+    if (!e[k]) continue
+    const dir = join(join(String(e[k]), MIMO_EXE_DIR[0]), MIMO_EXE_DIR[1])
+    for (const base of ['mimo.exe', 'mimo']) {
+      const exe = join(dir, base)
+      try { if (fs.existsSync(exe) && out.indexOf(exe) < 0) out.push(exe) } catch (err) { /* 探测失败静默跳过 */ }
+    }
+  }
+  return out
+}
+
+/**
+ * 解析本次调用使用的 exe 前缀（数组或字符串）。
+ * 优先级：binPath（显式路径）> env MIMO_BIN/MIMO_CLI > 已知安装位置 > PATH 名字。
+ */
+function resolveMimoExePrefix(env, binPath) {
+  const e = env || {}
+  const bin = binPath || e.MIMO_BIN || e.MIMO_CLI || ''
+  if (bin) {
+    if (/\.(mjs|cjs|js)$/i.test(bin)) {
+      const proc = globalThis.process
+      return [(proc && proc.execPath) ? proc.execPath : 'node', bin]
+    }
+    return [String(bin)]
+  }
+  const found = mimoCandidateExePaths(e)
+  return found.length ? [found[0]] : ['mimo']
+}
+
+// ── 模型列表（`mimo models`；设置面板下拉用）───────────────────────────────────
+// 实测输出形如每行 `provider/model — window 1M, compacts at 900K`（分隔符是中文破折号
+// U+2014）。模型名自身含连字符（xiaomi/mimo-v2.6-pro-ultraspeed），所以只认「行首的
+// provider/model」，其后一律当描述文本；表头/说明/空行一律丢弃，绝不抛。
+const MIMO_MODEL_ID_RE = /^([A-Za-z0-9_.-]+\/[A-Za-z0-9_.@#+-]+)(?=$|[\s—–:|,])/
+
+/** 解析 `mimo models` 文本输出为 [{id, provider, name, note}]（去重、保序）。 */
+function parseMimoModels(text) {
+  const out = []
+  const seen = Object.create(null)
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    // 去掉列表记号（• * - 1. 等）与行首空白，避免把记号当 provider 名。
+    const ln = raw.replace(/^[^A-Za-z0-9]+/, '').trim()
+    if (!ln) continue
+    const m = ln.match(MIMO_MODEL_ID_RE)
+    if (!m) continue
+    const id = m[1]
+    if (seen[id]) continue
+    seen[id] = true
+    const slash = id.indexOf('/')
+    out.push({ id: id, provider: id.slice(0, slash), name: id.slice(slash + 1), note: ln.slice(id.length).replace(/^[\s—–:|,-]+/, '').trim() })
+  }
+  return out
+}
 
-// Desktop-local API 路径构造器（旧 DESKTOP_API verbatim）。
-const DESKTOP_API = {
-  healthPath: '/v1/health',
-  sessionsPath: '/v1/sessions',
-  turnsPath: (id) => '/v1/sessions/' + encodeURIComponent(String(id)) + '/turns',
-  eventsPath: (id, dir) => '/v1/sessions/' + encodeURIComponent(String(id)) + '/events' + (dir ? ('?dir=' + encodeURIComponent(String(dir))) : '')
+/**
+ * 同步抓取模型列表（供设置面板下拉）。失败返回空数组 —— 下拉退化为自由输入，
+ * 绝不因探测失败影响面板渲染。仅 spawnSync 可用时生效（宿主形态）。
+ */
+function fetchMimoModelsSync(env, timeoutMs) {
+  try {
+    const child = mimoBuiltin('node:child_process')
+    if (!child || typeof child.spawnSync !== 'function') return []
+    const prefix = resolveMimoExePrefix(env)
+    const r = child.spawnSync(prefix[0], prefix.slice(1).concat(['models']), { encoding: 'utf8', timeout: clampInt(timeoutMs, 8000, 1000, 30000), windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] })
+    if (!r || r.error || r.status !== 0) return []
+    return parseMimoModels(String(r.stdout || ''))
+  } catch (e) { return [] }
 }
 
-// 工具三件套 schema（旧 preset ctx.tools.register parameters verbatim，转 JSON Schema
-// 形态对齐 agy 描述符约定；required 进顶层数组，其余字段语义逐字保持）。
+// ── 三工具 schema（旧 preset verbatim；desktop 专属入参已随之后端取消而删除）────
+const MODEL_DESC = 'provider/model 格式，如 xiaomi/mimo-v2.6-flash；留空用设置里的默认模型'
 const RUN_PARAMS = {
-  type: 'object',
-  additionalProperties: true,
-  required: ['prompt'],
+  type: 'object', additionalProperties: true, required: ['prompt'],
   properties: {
     prompt: { type: 'string', description: 'The task instruction for mimo. On first dispatch for a topic, include a compact CONTEXT preamble (goal, repo root, key paths, decisions/constraints; point at paths, do not paste file contents — mimo reads the repo itself). For follow-ups on the same topic, use mimo_continue with latest=true or sessionId (mimo keeps conversation context; state only what is new).' },
     mode: { type: 'string', enum: ['auto', 'plan', 'build', 'compose', 'accept-edits'], description: 'auto follows DSH plan state (plan vs build); plan = read-only analysis (--agent plan); build = full tools (--agent build); compose = compose workflow.' },
-    backend: { type: 'string', enum: BACKENDS, description: 'Dispatch backend for THIS call only. Default comes from settings preselection (plugin config.backend / MIMO_BRIDGE_BACKEND / settings file): mimocode = local `mimo` CLI (MiMoCode); mimo-desktop = Xiaomi MiMo Desktop client local API. Prefer the preselected default; override only when necessary.' },
-    model: { type: 'string', description: 'Optional mimo model id as provider/model (e.g. mimo/mimo). For mimo-desktop, desktop model id (e.g. mimo-auto).' },
-    effort: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Optional reasoning effort, mapped to mimo --variant (low→minimal, high→high). mimocode only.' },
-    cwd: { type: 'string', description: 'Working directory for mimo (--dir / desktop directory).' },
+    model: { type: 'string', description: MODEL_DESC },
+    effort: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Optional reasoning effort, mapped to mimo --variant (low→minimal, high→high).' },
+    cwd: { type: 'string', description: 'Working directory for mimo (--dir).' },
     timeoutSec: { type: 'integer', description: 'Hard timeout seconds (10-3600, default 600). Grace +60s on top.' },
     background: { type: 'boolean', description: 'Defaults to true: dispatch returns a jobId immediately; collect with job_output, watch progress with mimo_status. Set false to block for the final answer.' },
-    // desktop 后端**不能创建会话**（API 对任意 id 都回 202 但不落库），所以必须能
-    // 显式指定一个**已存在**的 Desktop 会话 id，否则每次都生成自造 id → 静默空操作。
-    sessionId: { type: 'string', description: 'mimo-desktop only: id of an ALREADY EXISTING MiMo Desktop session (see the Desktop app). Omit for mimocode.' },
+    sessionId: { type: 'string', description: 'Optional mimo session id to resume (--session). Follow-ups on the same topic normally go through mimo_continue.' },
     title: { type: 'string', description: 'Optional session title.' }
   }
 }
 const CONTINUE_PARAMS = {
-  type: 'object',
-  additionalProperties: true,
-  required: ['prompt'],
+  type: 'object', additionalProperties: true, required: ['prompt'],
   properties: {
     prompt: { type: 'string', description: 'Follow-up instruction for the ongoing mimo session. State only what is new; mimo preserves its conversation context.' },
     sessionId: { type: 'string', description: 'mimo session id to resume (--session).' },
     latest: { type: 'boolean', description: 'Continue the most recent mimo session (--continue).' },
-    backend: { type: 'string', enum: BACKENDS, description: 'Dispatch backend for THIS call only (see mimo_run.backend). Prefer the preselected default.' },
     mode: { type: 'string', enum: ['auto', 'plan', 'build', 'compose', 'accept-edits'], description: 'Execution mode.' },
-    model: { type: 'string', description: 'Optional mimo model id as provider/model.' },
+    model: { type: 'string', description: MODEL_DESC },
     effort: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Optional reasoning effort.' },
     cwd: { type: 'string', description: 'Working directory for mimo.' },
     timeoutSec: { type: 'integer', description: 'Hard timeout seconds (10-3600, default 600).' },
@@ -646,50 +718,27 @@ const CONTINUE_PARAMS = {
   }
 }
 const STATUS_PARAMS = { type: 'object', additionalProperties: true, required: [], properties: { cwd: { type: 'string', description: 'Optional: filter the snapshot to a single project (working directory).' } } }
-const SETTINGS_PARAMS = {
-  type: 'object',
-  additionalProperties: true,
-  required: [],
-  properties: {
-    backend: { type: 'string', enum: BACKENDS, description: 'If set, save this as the default backend.' },
-    desktopModel: { type: 'string', description: 'Optional desktop model id (mimo-desktop backend only), e.g. mimo-auto.' }
-  }
-}
-const SETTINGS_DESCRIPTION = 'Read or change the preselected dispatch backend (settings). backend=mimocode (local mimo CLI / MiMoCode) or mimo-desktop (Xiaomi MiMo Desktop client). Call with only backend to set the default for subsequent mimo_run/mimo_continue; call with no args to read current settings. Persisted to the settings file; plugin config and MIMO_BRIDGE_BACKEND env still override when set.'
+const SETTINGS_PARAMS = { type: 'object', additionalProperties: true, required: [], properties: { model: { type: 'string', description: MODEL_DESC } } }
+const SETTINGS_DESCRIPTION = 'Read or change the default mimo model (settings). Call with model=<provider/model> to save it as the default for subsequent mimo_run/mimo_continue; call with no args to read current settings. Persisted to the settings file; a per-call `model` argument on mimo_run/mimo_continue overrides it for that call only. Available models are listed by `mimo models` on this machine (mimo CLI must be installed and logged in).'
 
 function renderSettings(value) {
   const s = value || {}
   const lines = [
     'mimo settings',
     '  settings file  : ' + (s.settingsPath || '(unknown)'),
-    '  file backend   : ' + (s.fileBackend || '(unset)'),
-    '  config backend : ' + (s.configBackend || '(unset)'),
-    '  env backend    : ' + (s.envBackend || '(unset)'),
-    '  effective      : ' + (s.effectiveBackend || '(unknown)'),
-    '  desktop model  : ' + (s.desktopModel || '(default)'),
-    '  desktop api    : ' + (s.desktopAvailable
-      ? 'available' + (s.desktopApiFile ? ' (' + s.desktopApiFile + ')' : '')
-      : 'unavailable' + (s.desktopError ? ' — ' + s.desktopError : '')),
-    '  backends       : ' + ((Array.isArray(s.backends) && s.backends.length ? s.backends.join(' | ') : BACKENDS.join(' | ')))
+    '  default model  : ' + (s.defaultModel || '(unset — 不传 --model)'),
+    '  effective      : ' + (s.effective || '(unknown)'),
+    '  exe            : ' + (s.exe || '(unknown)'),
+    '  saved          : ' + (s.saved ? 'yes' : 'no')
   ]
+  if (s.saveError) lines.push('  save error     : ' + s.saveError)
   if (s.note) lines.push('  note           : ' + s.note)
   return [{ type: 'text', text: lines.join('\n') }]
 }
-
 // ── 可纯函数化的 mimo-core 语义（descriptor 方法 + 独立导出双份）───────────────
-function normalizeBackend(v) {
-  if (v == null || v === '') return null
-  const s = String(v).trim().toLowerCase()
-  if (s === 'mimocode' || s === 'mimo-code' || s === 'cli' || s === 'mimo-cli') return BACKEND_MIMOCODE
-  if (s === 'mimo-desktop' || s === 'desktop' || s === 'mimo_desktop' || s === 'xiaomi-mimo' || s === 'xiaomi-mimo-desktop') return BACKEND_DESKTOP
-  return null
-}
-
 function parseMimoJson(stdoutText) {
   const trimmed = String(stdoutText || '').trim()
   if (!trimmed) return null
-  const MAX_ARG_LEN = 120
-  const MAX_TRAIL = 12
   const events = []
   const lines = trimmed.split(/\r?\n/)
   for (const raw of lines) {
@@ -722,12 +771,12 @@ function parseMimoJson(stdoutText) {
     if (ev.session && typeof ev.session === 'object' && ev.session.id) sessionId = ev.session.id
     if (ev.type === 'session' && ev.properties && ev.properties.id) sessionId = ev.properties.id
     const t = ev.type
+    const p = ev.properties || ev
     if (t === 'error') {
-      const err = ev.error || ev.properties || {}
+      const err = ev.error || p
       errorMessage = (err.data && err.data.message) || err.message || err.name || 'error'
       errorName = err.name || 'Error'
     } else if (t === 'text' || t === 'message' || t === 'assistant' || t === 'output') {
-      const p = ev.properties || ev
       const chunk = p.text || p.content || p.message || p.output || (typeof ev.text === 'string' ? ev.text : '')
       if (typeof chunk === 'string' && chunk) {
         textParts.push(chunk)
@@ -735,26 +784,17 @@ function parseMimoJson(stdoutText) {
       }
     } else if (t === 'step-start' || t === 'step-finish' || t === 'step_update') {
       numTurns += 1
-      const p = ev.properties || ev
       if (p.tokens && typeof p.tokens === 'object') {
         const tt = p.tokens.total ?? p.tokens.input ?? p.tokens.output
         if (typeof tt === 'number') totalTokens = (totalTokens || 0) + tt
       }
-      if (t === 'step_update' && (p.tool_name || p.tool || p.name)) {
-        steps.push({
-          at: Date.now(),
-          kind: 'tool',
-          label: shortLabel((p.tool_name || p.tool || p.name) + ' ' + JSON.stringify(summarizeArgs(p.arguments || p.args || p.input) || {}))
-        })
+      if (t === 'step_update') {
+        const name = p.tool_name || p.tool || p.name
+        if (name) steps.push({ at: Date.now(), kind: 'tool', label: shortLabel(name + ' ' + JSON.stringify(summarizeArgs(p.arguments || p.args || p.input) || {})) })
       }
     } else if (t === 'tool' || t === 'tool-call' || t === 'tool_use') {
-      const p = ev.properties || ev
       const name = p.tool || p.name || p.tool_name || 'tool'
-      steps.push({
-        at: Date.now(),
-        kind: 'tool',
-        label: shortLabel(name + ' ' + JSON.stringify(summarizeArgs(p.arguments || p.args || p.input) || {}))
-      })
+      steps.push({ at: Date.now(), kind: 'tool', label: shortLabel(name + ' ' + JSON.stringify(summarizeArgs(p.arguments || p.args || p.input) || {})) })
     }
   }
   if (textParts.length) text = textParts.join('\n')
@@ -799,217 +839,56 @@ function buildResult(parsed, outcome, mode, stderrText, stdoutText, backend) {
   }
 }
 
-function desktopResult(ok, opts) {
-  const o = opts || {}
-  return {
-    ok: !!ok,
-    fallback: false,
-    status: o.status || (ok ? (o.accepted ? 'ACCEPTED' : 'SUCCESS') : 'ERROR'),
-    response: o.response || '',
-    sessionId: o.sessionId || null,
-    durationSeconds: null,
-    numTurns: null,
-    totalTokens: null,
-    exitCode: o.exitCode != null ? o.exitCode : (ok ? 0 : 1),
-    mode: o.mode || 'auto',
-    backend: BACKEND_DESKTOP,
-    stderr: o.stderr || '',
-    errorMessage: o.errorMessage || '',
-    accepted: o.accepted === true,
-    steps: []
-  }
-}
-
-function buildDesktopTurnBody(args) {
-  const a = args || {}
-  const message = String(a.prompt != null ? a.prompt : (a.message != null ? a.message : ''))
-  const model = String(a.model || a.desktopModel || 'mimo-auto')
-  const body = { message, model }
-  const directory = a.directory || a.cwd
-  if (directory) body.directory = String(directory)
-  return body
-}
-
-function newDesktopSessionId() {
-  // ses_ + 18-ish random chars, same shape as Desktop API ids
-  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
-  let s = ''
-  for (let i = 0; i < 18; i++) s += chars[Math.floor(Math.random() * chars.length)]
-  return 'ses_' + s
-}
-
-function extractDesktopText(j) {
-  if (!j || typeof j !== 'object') return { text: '', sessionId: null, error: null }
-  const sessionId = j.sessionID || j.sessionId || (j.session && j.session.id) || null
-  if (j.type === 'error' || j.error) {
-    const err = j.error || j
-    const msg = (err.data && err.data.message) || err.message || err.name || 'error'
-    return { text: '', sessionId, error: String(msg) }
-  }
-  let text = ''
-  if (typeof j.text === 'string') text = j.text
-  else if (typeof j.message === 'string') text = j.message
-  else if (typeof j.content === 'string') text = j.content
-  else if (typeof j.response === 'string') text = j.response
-  else if (Array.isArray(j.parts)) {
-    for (const p of j.parts) {
-      if (p && typeof p.text === 'string') text += (text ? '\n' : '') + p.text
-    }
-  } else if (j.data && typeof j.data.text === 'string') text = j.data.text
-  return { text, sessionId, error: null }
-}
-
-function parseDesktopEvents(stdoutOrJson) {
-  const raw = String(stdoutOrJson || '').trim()
-  if (!raw) return { text: '', sessionId: null, error: null }
-  try {
-    const j = JSON.parse(raw)
-    return extractDesktopText(j)
-  } catch (e) { }
-  const texts = []
-  for (const line of raw.split(/\r?\n/)) {
-    const ln = line.trim()
-    if (!ln.startsWith('{')) continue
-    try {
-      const r = extractDesktopText(JSON.parse(ln))
-      if (r.text) texts.push(r.text)
-      if (r.error) return { text: texts.join('\n'), sessionId: r.sessionId, error: r.error }
-    } catch (e) { }
-  }
-  return { text: texts.join('\n'), sessionId: null, error: null }
-}
-
 function defineProvider (deps = {}) {
   const env = deps.env || {}
   const nodeFs = deps.nodeFs || null
   const nodePath = deps.nodePath || null
-
-  // ── Desktop-local API discovery（旧 runtime-settings.loadRuntime 桌面段语义）───
-  // fs 缺失（dynamic 沙箱）→ 只认 MIMO_DESKTOP_PORT/TOKEN env；都没有 → 不可用。
-  function discoverDesktop() {
-    const d = { available: false, baseUrl: null, token: null, apiFile: null, error: null }
-    if (env.MIMO_DESKTOP_PORT && env.MIMO_DESKTOP_TOKEN) {
-      return { available: true, baseUrl: 'http://127.0.0.1:' + env.MIMO_DESKTOP_PORT, token: String(env.MIMO_DESKTOP_TOKEN), apiFile: null, error: null }
-    }
-    const candidates = []
-    if (env.MIMO_DESKTOP_API_FILE) candidates.push(env.MIMO_DESKTOP_API_FILE)
-    const joinP = (...segs) => (nodePath ? nodePath.join(...segs) : segs.join('/'))
-    if (env.APPDATA) candidates.push(joinP(env.APPDATA, 'Xiaomi MiMo', 'desktop-api.json'))
-    if (env.HOME) {
-      candidates.push(joinP(env.HOME, '.config', 'Xiaomi MiMo', 'desktop-api.json'))
-      candidates.push(joinP(env.HOME, 'Library', 'Application Support', 'Xiaomi MiMo', 'desktop-api.json'))
-    }
-    if (!nodeFs) {
-      d.error = 'desktop-api.json not readable (no fs in this host; set MIMO_DESKTOP_PORT/MIMO_DESKTOP_TOKEN)'
-      return d
-    }
-    for (const p of candidates) {
-      try {
-        if (!p || !nodeFs.existsSync || !nodeFs.existsSync(p)) continue
-        const j = JSON.parse(nodeFs.readFileSync(p, 'utf8'))
-        if (j && j.port && j.token) {
-          return { available: true, baseUrl: 'http://127.0.0.1:' + j.port, token: String(j.token), apiFile: p, error: null }
+  let host = null // attach 后保存 hostOpts（preset/dynamic 形态提供 getSettings）
+  let settingsRef = { defaultModel: '' }
+
+  /** 取当前生效的偏好设置。三条来源按优先级合并，每次 buildArgv 都重新读 ——
+   *  面板改默认模型后无需重启即生效：
+   *   1) `host.getSettings('mimo')` —— preset/dynamic 形态（attach 时由宿主注入）；
+   *   2) `deps.readSettings()` —— MCP 形态（真 Node 进程，每次现读设置文件）；
+   *   3) `settingsRef` —— attach 时固化的一次性快照 / 缺省值。
+   *  三条都拿不到 → 缺省 `{defaultModel:''}`（= 不传 --model，交给 mimo CLI 自决）。
+   *
+   *  历史坑：MCP 形态不 attach（自建 engine），只认 host.getSettings 会让面板设置的
+   *  defaultModel 在 MCP 面对 mimo_run 完全失效 —— 只有 args.model 才落地。
+   *  三个形态行为不一致是缺陷，故此处统一把 readSettings 纳入。 */
+  function currentSettings() {
+    const out = Object.assign({}, settingsRef)
+    try {
+      if (typeof deps.readSettings === 'function') {
+        const r = deps.readSettings()
+        if (r && typeof r === 'object') {
+          // 宿主可返回 { partition, path, home } 或直接返回分区对象（宽松兼容）。
+          const part = ('partition' in r || 'path' in r || 'home' in r) ? r.partition : r
+          if (part && typeof part === 'object') Object.assign(out, part)
         }
-      } catch (e) {
-        d.error = String(e && e.message || e)
       }
-    }
-    if (!d.error) d.error = 'desktop-api.json not found (start Xiaomi MiMo Desktop)'
-    return d
-  }
-
-  function fetchFn() {
-    return (typeof globalThis !== 'undefined' && typeof globalThis.fetch === 'function') ? globalThis.fetch.bind(globalThis) : null
-  }
-
-  // desktopFetch（旧 runtime-settings verbatim；AbortController/setTimeout 守卫，
-  // 沙箱缺省时退化为无超时 fetch —— 仍可用）。
-  async function desktopFetch(method, path, body, timeoutMs) {
-    const fetch = fetchFn()
-    if (!fetch) { const e = new Error('fetch not available in this host'); e.code = 'DESKTOP_UNAVAILABLE'; throw e }
-    const d = desktop
-    if (!d || !d.available || !d.baseUrl) {
-      const e = new Error('MiMo Desktop API unavailable: ' + (d && d.error || 'not configured'))
-      e.code = 'DESKTOP_UNAVAILABLE'
-      throw e
-    }
-    const url = d.baseUrl + path
-    const ms = timeoutMs == null ? 8000 : timeoutMs
-    let ctrl = null
-    let timer = null
-    const init = {
-      method: method || 'GET',
-      headers: { Authorization: 'Bearer ' + d.token, 'Content-Type': 'application/json' }
-    }
-    if (body != null) init.body = typeof body === 'string' ? body : JSON.stringify(body)
-    if (typeof AbortController === 'function' && typeof setTimeout === 'function' && typeof clearTimeout === 'function') {
-      ctrl = new AbortController()
-      init.signal = ctrl.signal
-      timer = setTimeout(() => { try { ctrl.abort() } catch (e) {} }, ms)
-    }
-    try {
-      const res = await fetch(url, init)
-      const text = await res.text()
-      let json = null
-      try { json = text ? JSON.parse(text) : null } catch (e) { }
-      return { status: res.status, ok: res.ok, text, json }
-    } finally {
-      if (timer != null) clearTimeout(timer)
-    }
-  }
-
-  async function desktopHealth() {
+    } catch (e) { }
     try {
-      const r = await desktopFetch('GET', DESKTOP_API.healthPath)
-      return { ok: r.ok, status: r.status, body: r.json || r.text }
-    } catch (e) {
-      return { ok: false, status: 0, error: String(e && e.message || e) }
-    }
-  }
-
-  async function desktopListSessions(limit) {
-    const r = await desktopFetch('GET', DESKTOP_API.sessionsPath + '?limit=' + (limit || 10))
-    return r.json
-  }
-
-  async function desktopSendTurn(sessionId, args) {
-    const id = sessionId || newDesktopSessionId()
-    const body = buildDesktopTurnBody(args)
-    const r = await desktopFetch('POST', DESKTOP_API.turnsPath(id), body, 15000)
-    // 【实测事故】Desktop API 对**任意** session id 都无条件返回 202 {"ok":true} ——
-    // 它不校验目标会话是否存在。实测：向自造 id POST 得到 202，但
-    //   GET /v1/sessions 计数不变（19→19），会话从未创建，任务从未执行。
-    // 因此 202 不能作为成功判据，必须回读会话列表确认目标 id 确实存在，
-    // 否则桥接层会把"静默丢弃"报告成 ACCEPTED，用户在 Desktop UI 里什么都看不到。
-    const accepted = r.status === 202 || (r.json && r.json.ok === true)
-    let verified = null
-    if (accepted) {
-      try {
-        const list = await desktopListSessions(200)
-        if (Array.isArray(list)) verified = list.some((s) => s && String(s.id) === String(id))
-        else verified = null
-      } catch (e) { verified = null }
-    }
-    return {
-      id, status: r.status, ok: r.ok, body: r.json || r.text,
-      accepted, verified,
-      // 仅当回读确认存在（或回读不可用）才算真正投递成功
-      delivered: accepted && verified !== false
-    }
+      if (host && typeof host.getSettings === 'function') {
+        const s = host.getSettings('mimo')
+        if (s && typeof s === 'object') Object.assign(out, s)
+      }
+    } catch (e) { }
+    return out
   }
 
-  async function desktopReadEvents(sessionId, dir, timeoutMs) {
-    try {
-      const r = await desktopFetch('GET', DESKTOP_API.eventsPath(sessionId, dir), null, timeoutMs || 2500)
-      return parseDesktopEvents(r.text || (r.json ? JSON.stringify(r.json) : ''))
-    } catch (e) {
-      return { text: '', sessionId, error: String(e && e.message || e) }
-    }
+  // 模型优先级：调用参数 > 宿主注入设置 > runner opts 透传 > 空（不传 --model）。
+  // 用户要求「不设默认 → 由 mimo CLI 自决」，故空值绝不落地 --model。
+  function effectiveModel(args, opts) {
+    const o = opts || {}
+    const fromArg = (args && args.model && String(args.model).trim()) || ''
+    if (fromArg) return fromArg
+    const fromSettings = (currentSettings().defaultModel || '').trim()
+    if (fromSettings) return fromSettings
+    const fromOpts = (o.settings && o.settings.defaultModel) || o.defaultModel
+    return fromOpts ? String(fromOpts).trim() : ''
   }
 
-  // 每次调用前刷一次发现结果（Desktop 可能中途启动/退出；env-only 形态零开销）。
-  let desktop = discoverDesktop()
-
   // ── 统一设置分区读取（keystone 落盘；descriptor 只读）。宿主注入 deps.readSettings
   //    动态读取（preset/MCP 每次取最新文件值），或静态 deps.settings（测试/dynamic）。
   function liveSettings() {
@@ -1027,44 +906,22 @@ function defineProvider (deps = {}) {
     }
     return { partition: (deps.settings && typeof deps.settings === 'object') ? deps.settings : null, path: deps.settingsPath || null, home: deps.dshHome || null }
   }
-  function partitionSettings() {
-    return liveSettings().partition || null
-  }
-  function fileBackend() {
-    const s = partitionSettings()
-    if (s && s.preferredBackend) return s.preferredBackend
-    return null
-  }
-  function desktopModelChain(cfg) {
-    const s = partitionSettings()
-    return (cfg && cfg.desktopModel) || (s && s.desktopModel) || env.MIMO_DESKTOP_MODEL || 'mimo-auto'
-  }
 
   const descriptor = {
-    id: 'mimo', label: 'MIMO', presetId: 'cordis-mimo', defaultBackend: DEFAULT_BACKEND, defaultMode: 'auto',
+    id: 'mimo', label: 'MIMO', presetId: 'cordis-mimo', defaultBackend: null, defaultMode: 'auto',
     exeName: 'mimo', binEnvVars: ['MIMO_BIN', 'MIMO_CLI'], unavailableStatus: 'MIMO_UNAVAILABLE',
 
-    backends() { return BACKENDS },
-    normalizeBackend,
-
-    // 预选优先级（旧 resolveBackend 语义）：工具参数 > 插件 config > env > 设置文件 > 默认。
-    // keystone runner 已把 config/env/file 折进 getPreferredBackend()，这里只补 arg 级。
-    resolveBackend(args, target, preferred) {
-      const b = normalizeBackend(args && args.backend)
-      if (b) return b
-      return normalizeBackend(preferred) || descriptor.defaultBackend
-    },
-
-    // 委托规则（Lead 定案）：只有 desktop 走 provider.execute；mimocode 落 kit 通用管线。
-    delegates(backend) { return backend === BACKEND_DESKTOP },
+    // 单后端：backends() 恒 null；历史别名（mimocode/mimo-cli/desktop）与非法值一律
+    // 归一为 null（契约 §1：非法输入返回 null）。
+    backends() { return null },
+    normalizeBackend() { return null },
+    resolveBackend(args, target, preferred) { return null },
 
+    // 旧 preset buildArgv(exe, args, planActive) verbatim 语义（execPrefix 可为
+    // [nodeExe, binPath] 数组，runner 已归一）。
     buildArgv(exePrefix, args, opts) {
       const o = opts || {}
       const timeoutSec = clampInt(args.timeoutSec, DEFAULT_TIMEOUT_SEC, 10, 3600)
-      // mimo-desktop：非 spawn 路径，空壳交给 execute（kit 委托前会调本函数）。
-      if (o.backend === BACKEND_DESKTOP) {
-        return { argv: [], mode: args.mode || 'auto', timeoutSec }
-      }
       const argv = Array.isArray(exePrefix) ? exePrefix.slice() : [String(exePrefix)]
       argv.push('run')
       if (args.prompt != null && String(args.prompt).length) argv.push(String(args.prompt))
@@ -1075,8 +932,9 @@ function defineProvider (deps = {}) {
       // mimo --agent: build | plan | compose
       const agent = args.agent || mode
       if (agent === 'plan' || agent === 'build' || agent === 'compose') argv.push('--agent', agent)
-      // mimocode 用 --model provider/model（桌面模型链只在 desktop execute 内使用）。
-      if (args.model) argv.push('--model', String(args.model))
+      // 模型：调用参数 > 设置 defaultModel > 不传（mimo CLI 自身默认）。
+      const model = effectiveModel(args, o)
+      if (model) argv.push('--model', String(model))
       // effort (low/medium/high) maps to mimo --variant; pass-through if already a variant name
       let variant = args.variant || args.effort
       if (variant === 'low') variant = 'minimal'
@@ -1093,9 +951,9 @@ function defineProvider (deps = {}) {
     parseJson: parseMimoJson,
     buildResult,
 
-    // 旧 foldStepUpdate 语义 verbatim（识别 tool/text/error 事件），但 trail 条目同时
-    // 带 kit 展示层字段（stepIndex/tool/state/args）与旧字段（kind/label），
-    // 这样 renderStatus 与 MCP 快照映射（buildMcpBridgePayload）都能直接渲染。
+    // 旧 foldStepUpdate 语义 verbatim（识别 tool/text/error 事件），trail 条目同时带
+    // kit 展示层字段（stepIndex/tool/state/args）与旧字段（kind/label），这样
+    // renderStatus 与 MCP 快照映射（buildMcpBridgePayload）都能直接渲染。
     foldStreamEvent(ev, p, summarizeArgsFn, maxArgLen, maxTrail) {
       if (!ev || typeof ev !== 'object') return
       const t = ev.type
@@ -1144,218 +1002,121 @@ function defineProvider (deps = {}) {
     failureHint(res) {
       if (!res || res.ok) return ''
       const st = String(res.status || '')
-      if (st === 'MIMO_UNAVAILABLE') return '[诊断] 未找到 mimo 可执行文件：请安装 MiMoCode CLI（mimo），或设置 MIMO_BIN 指向其绝对路径；也可改用 backend=mimo-desktop 走 MiMo Desktop 客户端。'
-      if (st === 'DESKTOP_UNREACHABLE') return '[诊断] MiMo Desktop 本地 API 不可达/本宿主不支持 HTTP：请启动 Xiaomi MiMo Desktop 后重试，或改用 backend=mimocode（本地 mimo CLI）。'
-      if (st === 'DESKTOP_SESSION_NOT_CREATED') return '[诊断] MiMo Desktop API 无法创建会话：请在 Desktop 应用中新建或选用现有会话，把它的 id 传给 sessionId 参数。'
-      if (/free API service has ended|sign in|configure a third-party|登录|第三方/i.test(String(res.stderr || '') + String(res.errorMessage || ''))) {
-        return '[诊断] MiMo 免费 API 服务疑似已停止或未登录：请在 mimo CLI 完成登录/配置第三方模型（configure a third-party），或改用 backend=mimo-desktop 走 Desktop 登录态。'
+      if (st === 'MIMO_UNAVAILABLE') return '[诊断] 未找到 mimo 可执行文件：请安装 MiMoCode CLI（mimo，官方便携安装位置 ~/.mimocode/bin/mimo.exe），或设置 MIMO_BIN 指向其绝对路径。'
+      const hay = String(res.stderr || '') + ' ' + String(res.errorMessage || '') + ' ' + String(res.response || '')
+      if (/free API service has ended|sign in|configure a third-party|登录|第三方|免费/i.test(hay)) {
+        return '[诊断] MiMo 免费 API 已终止，请在 mimo CLI 用 `mimo auth login` 登录或配置第三方 API，并在 CLI Bridge 设置里指定模型。'
+      }
+      if (/model not found|unknown model|no models available|invalid model|unknown provider/i.test(hay)) {
+        return '[诊断] mimo 模型不可用或模型名无效：先在本机运行 `mimo models` 列出可用模型，再把 provider/model 填进 CLI Bridge 的「默认模型」设置（或本次调用的 model 参数）。'
       }
       return ''
     },
 
-    // ACCEPTED 计入成功态（指示灯不红；契约 §1）。
+    // ACCEPTED 计入成功态（指示灯不红；契约 §1）；desktop 取消后不再产生 ACCEPTED，
+    // 但成功态集合逐字保持不变（兼容旧会话/测试语义）。
     isSuccessStatus(st) {
       if (!st) return false
       return st === 'SUCCESS' || st === 'ACCEPTED'
     },
 
-    // 桌面可达性前置检查（契约 §9）：dynamic 无 fetch / 无发现 → abort 提示 mimocode。
-    // 有 fs 时做一次健康探测缓存（异步进行中先放行 —— preflight 是同步钩子）。
-    preflight({ backend }) {
-      if (backend !== BACKEND_DESKTOP) return null
-      desktop = discoverDesktop()
-      if (!fetchFn()) {
-        return {
-          abort: desktopResult(false, {
-            status: 'DESKTOP_UNREACHABLE',
-            mode: 'auto',
-            errorMessage: '当前宿主无 HTTP fetch 能力（dynamic 沙箱），mimo-desktop 不可用。请改用 backend=mimocode，或在 DSH 正式宿主（preset/MCP 形态）中使用桌面后端。'
-          })
-        }
-      }
-      if (!desktop.available) {
-        return {
-          abort: desktopResult(false, {
-            status: 'DESKTOP_UNREACHABLE',
-            mode: 'auto',
-            stderr: String(desktop.error || 'not configured'),
-            errorMessage: 'MiMo Desktop client unavailable. Start Xiaomi MiMo Desktop, or use backend=mimocode.'
-          })
-        }
-      }
-      return null
-    },
-
-    // mimo-desktop 委托执行（旧 runDesktop verbatim 编排；engine.begin/end 由 kit 做）。
-    async execute({ args, cwd, built }) {
-      desktop = discoverDesktop()
-      const a = args || {}
-      const sessionId = a.sessionId || newDesktopSessionId()
-      const mode = built && built.mode ? built.mode : (a.mode || 'auto')
-      try {
-        const health = await desktopHealth()
-        if (!health.ok) {
-          return desktopResult(false, {
-            status: 'DESKTOP_UNAVAILABLE',
-            sessionId,
-            mode,
-            stderr: String(health.error || health.body || 'desktop api not ready'),
-            errorMessage: 'MiMo Desktop client unavailable. Start Xiaomi MiMo Desktop and retry, or set backend=mimocode.'
-          })
-        }
-        const s = partitionSettings()
-        const turn = await desktopSendTurn(sessionId, {
-          prompt: a.prompt,
-          model: a.model || desktopModelChain(s),
-          directory: cwd
-        })
-        const okTurn = turn.delivered === true
-        let text = ''
-        if (okTurn) {
-          try {
-            const ev = await desktopReadEvents(sessionId, cwd, 2500)
-            text = ev.text || ''
-          } catch (e) { }
-        }
-        return desktopResult(okTurn, {
-          status: okTurn ? (text ? 'SUCCESS' : 'ACCEPTED') : 'DESKTOP_SESSION_NOT_CREATED',
-          response: text || (okTurn
-            ? '(Desktop turn accepted; watch Desktop UI or call mimo_continue for the reply)'
-            : ''),
-          sessionId,
-          accepted: okTurn,
-          mode,
-          stderr: okTurn ? '' : 'Desktop API returned ' + turn.status + ' but session ' + turn.id + ' does not exist',
-          errorMessage: okTurn ? '' : ('MiMo Desktop 未创建会话（API 返回 ' + turn.status +
-            ' 但会话列表中不存在 ' + turn.id + '）。任务未执行。' +
-            'MiMo Desktop API 无法创建会话，请在 Xiaomi MiMo Desktop 应用中新建（或选用现有）' +
-            '会话，再把它的 id 传给 mimo_run 的 sessionId 参数。')
-        })
-      } catch (e) {
-        return desktopResult(false, {
-          status: 'DESKTOP_ERROR',
-          sessionId,
-          mode,
-          stderr: String(e && e.message || e),
-          errorMessage: String(e && e.message || e)
-        })
-      }
-    },
-
     tools: {
-      run: { name: 'mimo_run', description: 'Dispatch a coding/build/debug/investigation task to the local mimo agent CLI (Xiaomi MiMo Desktop / MiMoCode) and return its final answer. DSH fully controls mimo (--dangerously-skip-permissions; mimo never prompts). On rate-limit/network failure DSH pops a fallback dialog; fallback=true means finish with native tools. Runs in the background by default (returns a jobId immediately; collect with job_output); set background=false to block for the final answer. While it runs, call mimo_status to watch what mimo is doing live.', inputSchema: RUN_PARAMS },
+      run: { name: 'mimo_run', description: 'Dispatch a coding/build/debug/investigation task to the local mimo agent CLI (Xiaomi MiMoCode) and return its final answer. DSH fully controls mimo (--dangerously-skip-permissions; mimo never prompts). On rate-limit/network failure DSH pops a fallback dialog; fallback=true means finish with native tools. Runs in the background by default (returns a jobId immediately; collect with job_output); set background=false to block for the final answer. While it runs, call mimo_status to watch what mimo is doing live.', inputSchema: RUN_PARAMS },
       continue: { name: 'mimo_continue', description: 'Continue an existing mimo session with a follow-up prompt. Pass sessionId or set latest=true. Same DSH-controlled, no-prompt execution and same fallback dialog as mimo_run.', inputSchema: CONTINUE_PARAMS },
       status: { name: 'mimo_status', description: 'Read a live snapshot of what the local mimo agent is currently doing. Returns one section per project (working directory): running count, current step, recent step trail, last completed run status + session id, per-project runs/token usage. Call this to check on an in-flight mimo_run/mimo_continue without waiting for it to finish.', inputSchema: STATUS_PARAMS }
     },
 
-    // mimo_settings：入参键保持旧 prompt 连续性（backend/desktopModel），落统一分区
-    // preferredBackend/desktopModel（迁移映射 keystone 已做）。写盘仅在宿主注入
-    // nodeFs + nodePath + settingsWrite 时可用；否则回显（dynamic 沙箱旧 echo 语义）。
+    // mimo_settings：入参键保持旧 prompt 连续性（backend/desktopModel → model），落统一
+    // 分区 defaultModel（迁移映射 keystone 已做）。写盘仅在宿主注入 nodeFs + nodePath 时
+    // 可用；否则回显（dynamic 沙箱旧 echo 语义）。
     extraTools: [{
       name: 'mimo_settings',
       description: SETTINGS_DESCRIPTION,
       inputSchema: SETTINGS_PARAMS,
       render: renderSettings,
-      async logic(args, exec) {
+      async logic(args) {
         const a = args || {}
         const live = liveSettings()
-        const cur = Object.assign({ preferredBackend: DEFAULT_BACKEND, desktopModel: 'mimo-auto' }, live.partition || {})
+        const cur = Object.assign({ defaultModel: '' }, live.partition || {})
         let settingsPath = live.path || null
-        let saved = false
-        let saveError = null
-        const fsMod = nodeFs
-        const pathMod = nodePath
+        let saved = false, saveError = null
         const home = live.home || deps.dshHome || null
-        if ((a.backend || a.desktopModel) && fsMod && pathMod && (settingsPath || home)) {
-          try {
-            settingsPath = await writePartition(fsMod, pathMod, settingsPath, home, env, cur, a)
-            saved = true
-          } catch (e) { saveError = String(e && e.message || e) }
+        const patch = (typeof a.model === 'string' && a.model.trim()) ? { defaultModel: a.model.trim() } : null
+        if (patch && nodeFs && nodePath && (settingsPath || home)) {
+          try { settingsPath = await writePartition(nodeFs, nodePath, settingsPath, home, env, cur, patch); saved = true } catch (e) { saveError = String(e && e.message || e) }
         }
         const merged = Object.assign({}, cur)
-        if (a.backend) merged.preferredBackend = a.backend
-        if (a.desktopModel) merged.desktopModel = a.desktopModel
-        const rt = discoverDesktop()
+        if (patch) merged.defaultModel = patch.defaultModel
         return {
           ok: !saveError,
           settingsPath: settingsPath || '(unified; not writable in this host)',
-          fileBackend: merged.preferredBackend || null,
-          configBackend: (deps.config && deps.config.backend) || null,
-          envBackend: env.MIMO_BRIDGE_BACKEND || env.MIMO_BACKEND || null,
-          effectiveBackend: descriptor.resolveBackend({ backend: a.backend }, null, normalizeBackend(env.MIMO_BRIDGE_BACKEND || env.MIMO_BACKEND) || merged.preferredBackend),
-          desktopModel: merged.desktopModel || 'mimo-auto',
-          desktopAvailable: !!rt.available,
-          desktopError: rt.error || null,
-          desktopApiFile: rt.apiFile || null,
-          saved,
-          saveError,
-          backends: BACKENDS,
-          note: 'Preselect via settings file / plugin config.backend / MIMO_BRIDGE_BACKEND. Per-call `backend` overrides only that call.'
+          defaultModel: merged.defaultModel || '',
+          effective: merged.defaultModel ? ('settings:' + merged.defaultModel) : '(unset — 不传 --model，mimo CLI 自决)',
+          exe: resolveMimoExePrefix(env).join(' '),
+          saved, saveError,
+          note: '默认模型在设置面板或本工具里指定（provider/model）；mimo_run/mimo_continue 的 model 参数可单次覆盖。可用模型：在本机运行 `mimo models` 查看。'
         }
       }
     }],
 
     // 设置分区（契约 §3）：keystone 读写/GUI；本处纯逻辑。diagnose/meta 必须同步。
     settings: {
-      keys: ['preferredBackend', 'desktopModel'],
-      defaults: () => ({ preferredBackend: DEFAULT_BACKEND, desktopModel: 'mimo-auto' }),
+      keys: ['defaultModel'],
+      defaults: () => ({ defaultModel: '' }),
       normalize(raw) {
         const src = raw && typeof raw === 'object' ? raw : {}
-        const out = { preferredBackend: DEFAULT_BACKEND, desktopModel: 'mimo-auto' }
-        const b = normalizeBackend(src.preferredBackend)
-        if (b) out.preferredBackend = b
-        if (typeof src.desktopModel === 'string' && src.desktopModel.trim()) out.desktopModel = src.desktopModel.trim()
-        return out
+        return { defaultModel: (typeof src.defaultModel === 'string' && src.defaultModel.trim()) ? src.defaultModel.trim() : '' }
       },
-      meta() {
+      meta(envArg) {
+        const e = envArg && typeof envArg === 'object' ? envArg : env
+        // 下拉选项：实时 `mimo models`（失败则退化为空 → 面板仍可自由输入）。
+        let options = []
+        try {
+          options = fetchMimoModelsSync(e, 8000).map((m) => ({ value: m.id, label: m.id }))
+        } catch (err) { options = [] }
         return {
           titleSuffix: 'MiMo',
-          fields: [
-            { key: 'preferredBackend', label: '预选后端', type: 'select', options: [{ value: 'mimocode', label: 'MiMoCode CLI（本地 mimo 命令，DSH 完全控制）' }, { value: 'mimo-desktop', label: 'MiMo Desktop 客户端（本地 API，共享其登录/模型/会话 UI）' }], note: 'mimo_run/mimo_continue 默认走这里选的后端；单次调用可用 backend 参数覆盖。' },
-            { key: 'desktopModel', label: '桌面模型', type: 'text', allowCustom: true, placeholder: 'mimo-auto', note: '仅 mimo-desktop 后端使用（Desktop 里的模型 id，如 mimo-auto）。' }
-          ]
+          fields: [{
+            key: 'defaultModel', label: '默认模型', type: 'select', allowCustom: true,
+            options: options,
+            placeholder: '留空 = 不传 --model（由 mimo CLI 自身默认决定）',
+            note: options.length
+              ? '共 ' + options.length + ' 个可用模型（来自 `mimo models`）。mimo_run/mimo_continue 的 model 参数可单次覆盖。'
+              : '未能读取模型列表（mimo CLI 未安装/未登录/超时）—— 仍可手动输入 provider/model，如 xiaomi/mimo-v2.6-flash。'
+          }]
         }
       },
-      // 同步一行诊断：探测缓存 + 惰性 health 后台刷新（结果进缓存，下次面板可见）。
-      diagnose(settings) {
-        const rt = discoverDesktop()
-        const f = fetchFn()
-        if (!f) return ''
-        if (!rt.available) return '桌面 API 未发现（' + (rt.error || '未配置') + '）；mimocode 后端不受影响'
-        const s = settings && settings.preferredBackend || partitionSettings() && partitionSettings().preferredBackend || DEFAULT_BACKEND
-        try {
-          f(rt.baseUrl + DESKTOP_API.healthPath, { headers: { Authorization: 'Bearer ' + rt.token } })
-            .then((r) => { desktopHealthCache = { ok: r.ok, at: Date.now() } })
-            .catch(() => { desktopHealthCache = { ok: false, at: Date.now() } })
-        } catch (e) { desktopHealthCache = { ok: false, at: Date.now() } }
-        if (desktopHealthCache.at && Date.now() - desktopHealthCache.at < 60000) {
-          return desktopHealthCache.ok
-            ? ('桌面 API 在线（' + rt.baseUrl + '）；当前预选 ' + s)
-            : ('桌面 API 不可达（检查 MiMo Desktop 是否在运行）；当前预选 ' + s + '，可改用 mimocode')
-        }
-        desktopHealthCache = { ok: null, at: Date.now() }
-        return '桌面 API 已发现（' + rt.baseUrl + (rt.apiFile ? '' : '，env 配置') + '）；健康检测中…；当前预选 ' + s
+      // 同步一行诊断：当前模型 + exe 来源（env > 已知安装位置 > PATH）。
+      diagnose(settings, envArg) {
+        const s = settings && typeof settings === 'object' ? settings : {}
+        const e = envArg && typeof envArg === 'object' ? envArg : env
+        const model = s.defaultModel ? 'model=' + s.defaultModel : 'model=(未设置 → 不传 --model)'
+        if (e.MIMO_BIN || e.MIMO_CLI) return model + ' · bin=env:' + (e.MIMO_BIN || e.MIMO_CLI)
+        const found = mimoCandidateExePaths(e)
+        return model + ' · ' + (found.length ? 'bin=' + found[0] : 'bin=PATH:mimo')
       }
     },
 
-    mcp: { version: '0.2.2' }
+    // MCP 形态扩展：**不含 version**。历史：四处 `mcp: { version: '0.2.2' }` 与
+    // mcp/version.mjs 的 packageVersion() 双源，漏改一处就出现「统一 server 报 0.2.3、
+    // provider 面仍报 0.2.2」的自相矛盾输出；且 mcp/version.mjs 依赖 import.meta + node:fs，
+    // 其函数体无法随本文件内联进 dynamic 沙箱（build 文本拼接会丢实现/炸语法）。
+    // 定案：版本号单一来源 = mcp/version.mjs 的 packageVersion()，由 MCP 面（mcp/providers/
+    // mimo.mjs 的 meta.version）读取；描述符不复制 version 字面量，宿主如需注入可经 deps.mcp。
+    mcp: (deps.mcp && typeof deps.mcp === 'object') ? Object.assign({}, deps.mcp) : {}
   }
 
-  let desktopHealthCache = { ok: null, at: 0 }
-
   // 统一分区写入（tmp→rename 原子写；与 keystone lib/settings.mjs 同文件同分区规则，
   // 本工具自实现落盘 —— 不 import home-plugin；宿主给出 settingsPath 或 dshHome）。
   async function writePartition(fsMod, pathMod, knownPath, home, environment, cur, patch) {
-    const SETTINGS_FILE_NAME = 'cli-bridge-settings.json'
-    const file = knownPath || environment.CLI_BRIDGE_SETTINGS_FILE || (home ? pathMod.join(home, SETTINGS_FILE_NAME) : null)
+    const file = knownPath || environment.CLI_BRIDGE_SETTINGS_FILE || (home ? pathMod.join(home, 'cli-bridge-settings.json') : null)
     if (!file) throw new Error('dsh-home not resolved (set DSH_HOME or CLI_BRIDGE_SETTINGS_FILE)')
     let all = {}
     try { all = JSON.parse(fsMod.readFileSync(file, 'utf8')) } catch (e) { all = {} }
     if (!all || typeof all !== 'object') all = {}
     const next = Object.assign({}, all)
     const part = Object.assign({}, cur, next.mimo || {})
-    if (patch.backend) part.preferredBackend = normalizeBackend(patch.backend) || patch.backend
-    if (patch.desktopModel) part.desktopModel = patch.desktopModel
+    if (patch && patch.defaultModel) part.defaultModel = patch.defaultModel
     next.mimo = descriptor.settings.normalize(part)
     next.updatedAt = Date.now()
     try { fsMod.mkdirSync(pathMod.dirname(file), { recursive: true }) } catch (e) { }
@@ -1366,31 +1127,20 @@ function defineProvider (deps = {}) {
   }
 
   // 三形态共用的工具逻辑。签名保持不变（keystone 与队友按此接线）。
+  // 旧 mimo preset 语义：background 默认 true（仅显式 false 才前台阻塞）。
   descriptor.runToolLogic = async function (args, exec) {
     const a = args || {}
-    // 旧 mimo preset 语义：background 默认 true（仅显式 false 才前台阻塞）。
     const normalized = a.background === undefined ? Object.assign({}, a, { background: true }) : a
     return this.runner.coreExecute(normalized, exec)
   }
   descriptor.continueToolLogic = async function (args, exec) {
     const a = args || {}
-    const mapped = {
-      prompt: a.prompt,
-      mode: a.mode,
-      model: a.model,
-      effort: a.effort,
-      cwd: a.cwd,
-      timeoutSec: a.timeoutSec,
-      background: a.background,
-      backend: a.backend,
-      // 【关键】desktop 后端的 sessionId 必须转发（白名单转发漏了它会导致
-      // mimo_run 传 sessionId 被静默丢弃 → 永远造新 id → desktop 后端不可用）。
-      sessionId: a.sessionId
-    }
+    const mapped = { prompt: a.prompt, mode: a.mode, model: a.model, effort: a.effort, cwd: a.cwd, timeoutSec: a.timeoutSec, background: a.background, sessionId: a.sessionId }
     if (a.sessionId) mapped.sessionId = a.sessionId
     else if (a.latest) mapped.continueLatest = true
     return this.runToolLogic(mapped, exec)
   }
+  // 旧 statusTool.execute verbatim：cwd 过滤到单项目（Object.assign 形式与 opencode 一致）。
   descriptor.statusToolLogic = async function (args) {
     const a = args || {}
     const snap = this.engine.statusSnapshot()
@@ -1399,41 +1149,39 @@ function defineProvider (deps = {}) {
       snap.projects = (snap.projects || []).filter((p) => p.cwd === key)
       const g = snap.projects[0]
       if (g) {
-        snap.state = g.state
-        snap.running = g.running
-        snap.current = g.current
-        snap.trail = g.trail
-        snap.lastStatus = g.lastStatus
-        snap.lastAt = g.lastAt
-        snap.lastSessionId = g.lastSessionId
-        snap.fallbackActive = g.fallbackActive
-        snap.runs = g.runs
-        snap.totalTokens = g.totalTokens
-        snap.updatedAt = g.updatedAt
+        Object.assign(snap, {
+          state: g.state, running: g.running, current: g.current, trail: g.trail,
+          lastStatus: g.lastStatus, lastAt: g.lastAt, lastSessionId: g.lastSessionId,
+          lastOk: g.lastOk, lastFailed: g.lastFailed, fallbackActive: g.fallbackActive,
+          runs: g.runs, totalTokens: g.totalTokens, updatedAt: g.updatedAt
+        })
       }
     }
     return snap
   }
-
-  // 工厂装配（provider 无关骨架 + 描述符）：宿主形态通过 deps 注入 runner 依赖。
+  // 工厂装配（provider 无关骨架 + 描述符）；宿主注入 getSettings 时把面板偏好带进 buildArgv。
   descriptor.attach = function (hostOpts) {
-    this.engine = createStatusEngine({ provider: this, publish: hostOpts.publish })
-    const runner = createRunner(Object.assign({}, hostOpts, { provider: this, engine: this.engine }))
+    host = hostOpts || {}
+    try {
+      if (typeof host.getSettings === 'function') {
+        const s = host.getSettings('mimo')
+        if (s && typeof s === 'object') settingsRef = descriptor.settings.normalize(s)
+      }
+    } catch (e) { }
+    this.engine = createStatusEngine({ provider: this, publish: host.publish })
+    const runner = createRunner(Object.assign({}, host, { provider: this, engine: this.engine }))
     this.runner = runner
     return runner
   }
-
-  // 测试/宿主可见的纯函数面（不进协议字段）。
-  descriptor._internals = {
-    BACKENDS, BACKEND_MIMOCODE, BACKEND_DESKTOP, DEFAULT_BACKEND, MIMO_LIMIT_RE,
-    DESKTOP_API, parseMimoJson, buildResult, desktopResult, buildDesktopTurnBody,
-    newDesktopSessionId, parseDesktopEvents, normalizeBackend, discoverDesktop,
-    desktopFetch, desktopHealth, desktopSendTurn, desktopReadEvents
+  // 测试/宿主可见的纯函数面（不进协议字段）。currentSettings/liveSettings/writePartition 是
+  // 闭包函数，不依赖 attach（未 attach 时 host 为 null → 走 deps 注入或默认空值），测试可
+  // 直接调用；writePartition 需要调用方自行传入可用的 fs/path 模块。
+  descriptor._internals = { MIMO_LIMIT_RE, parseMimoJson, buildResult,
+    mimoCandidateExePaths, resolveMimoExePrefix, parseMimoModels, fetchMimoModelsSync,
+    currentSettings, liveSettings, writePartition
   }
-
   return descriptor
 }
-
 // core/scheduling.mjs — CLI 调度（启用集合 + 调用优先级）单源纯逻辑。
 //
 // 语义（用户可见的两件事）：
@@ -1611,14 +1359,16 @@ return {
       } catch (e) { /* 灯数据尽力而为 */ }
     }
 
-    // exe：MIMO_BIN/MIMO_CLI env > PATH 查找 mimo（subprocess.resolveExecutable）。
-    // mimo-desktop 后端不 spawn：返回占位字符串让 kit 直达 delegates→execute/preflight。
+    // exe：MIMO_BIN/MIMO_CLI env > 已知安装位置 > PATH 查找 mimo
+    // （subprocess.resolveExecutable）。与 descriptor 的 resolveMimoExePrefix 同一套
+    // 优先级；.js/.mjs 目标经 process.execPath 包装（供测试 fixture 使用）。
     async function resolveExe(backend, signal) {
-      if (backend === 'mimo-desktop') return 'mimo'
-      const bin = env.MIMO_BIN || env.MIMO_CLI || ''
-      if (bin) {
-        if (/\.(mjs|cjs|js)$/i.test(bin) && typeof process !== 'undefined' && process.execPath) return [process.execPath, bin]
-        return bin
+      const prefix = resolveMimoExePrefix(env)
+      if (prefix.length && prefix[0]) {
+        const head = String(prefix[0])
+        if (prefix.length > 1) return prefix
+        if (/\.(mjs|cjs|js)$/i.test(head) && typeof process !== 'undefined' && process.execPath) return [process.execPath, head]
+        return head
       }
       return await subprocess.resolveExecutable('mimo', undefined, signal)
     }
@@ -1633,9 +1383,22 @@ return {
       return '.'
     }
 
-    // 预选链（沙箱无 fs 读设置文件）：env MIMO_BRIDGE_BACKEND / MIMO_BACKEND。
-    function getPreferredBackend() {
-      return env.MIMO_BRIDGE_BACKEND || env.MIMO_BACKEND || null
+    // 设置分区（descriptor 的 host.getSettings('mimo') 契约：直接返回分区对象
+    // { defaultModel } 或空对象）。每次调用重读统一设置文件 —— 面板改默认模型后
+    // 无需重启即生效；读不到（沙箱无 fs / 文件缺失）回落 {} = 不传 --model。
+    function getSettings() {
+      try {
+        const proc = (typeof process !== 'undefined') ? process : null
+        const nodeFs = (proc && typeof proc.getBuiltinModule === 'function') ? proc.getBuiltinModule('node:fs') : null
+        if (!nodeFs || typeof nodeFs.readFileSync !== 'function') return {}
+        const nodePath = (proc && typeof proc.getBuiltinModule === 'function') ? proc.getBuiltinModule('node:path') : null
+        const join = nodePath ? nodePath.join.bind(nodePath) : ((...p) => p.join('/'))
+        const file = env.CLI_BRIDGE_SETTINGS_FILE || (env.DSH_HOME ? join(env.DSH_HOME, 'cli-bridge-settings.json') : null)
+        if (!file) return {}
+        const all = JSON.parse(nodeFs.readFileSync(file, 'utf8'))
+        if (all && typeof all === 'object' && all.mimo && typeof all.mimo === 'object') return all.mimo
+      } catch (e) { /* 读不到：回落空分区（默认模型为空 → 不传 --model） */ }
+      return {}
     }
 
     function planActiveFor(exec) {
@@ -1648,7 +1411,7 @@ return {
       return false
     }
 
-    provider.attach({ ctx, subprocess, resolveExe, getCwdFallback, getPreferredBackend, planActiveFor, publish })
+    provider.attach({ ctx, subprocess, resolveExe, getCwdFallback, getSettings, planActiveFor, publish })
 
     const OUTPUT_SCHEMA = { type: 'object', additionalProperties: true }
 
@@ -1689,13 +1452,22 @@ return {
     // 浏览器指示灯轮询的 RPC 面（旧 dynamic/handle('mimo_status') 语义）。
     harness.handle('mimo_status', function () { return provider.statusToolLogic({}) })
 
-    // 旧 policy 文案 verbatim（提示词连续性红线）。
+    // 提示词连续性（契约 §8）：决策表 / 上下文协议 / 回退协议三段保留旧语义；后端段与
+    // 模型段随「去 desktop 化 + 模型手动指定」重写（免费 API 已终止 + mimo auth login）。
+    // 与 preset/mimo-first/cli-bridge.mjs 的 policy 段保持同文。
     const policyText = [
-      'mimo-first execution policy (Xiaomi MiMo: MiMoCode CLI or MiMo Desktop client).',
+      'mimo-first execution policy (Xiaomi MiMo: MiMoCode CLI).',
+      '',
+      'Local `mimo` CLI (MiMoCode) handles coding tasks under full DSH control (--dangerously-skip-permissions, never prompts).',
       '',
-      'Local backends (selectable in settings: backend = mimocode | mimo-desktop):',
-      '- mimocode (default): local `mimo` CLI (MiMoCode). Full DSH control (--dangerously-skip-permissions, never prompts).',
-      '- mimo-desktop: Xiaomi MiMo Desktop client local API (running Desktop app; uses its login/model/session UI).',
+      'Model:',
+      '- The model is chosen in the CLI Bridge settings panel (provider/model form, e.g. xiaomi/mimo-v2.6-flash) — this bridge does not pick one.',
+      '- Leave the setting empty to pass no --model, letting the mimo CLI use its own default. A per-call `model` argument overrides the setting for that call only.',
+      '- List available models with `mimo models` on this machine.',
+      '',
+      'Credentials:',
+      "- Xiaomi MiMo's free API service has ENDED. The user must run `mimo auth login` (or configure a third-party API) on this machine before dispatch works.",
+      '- If a run fails with sign-in / free-API-ended errors, tell the user to log in. Do not retry in a loop.',
       '',
       'By default, dispatch runs in the background and returns a jobId immediately; collect via job_output and watch live progress via mimo_status.',
       '',
@@ -1705,12 +1477,6 @@ return {
       '- Follow-ups on the same topic -> mimo_continue (with latest=true or sessionId; context is preserved).',
       '- Final build/test verification of mimo output -> Native tools.',
       '- Plan / read-only analysis -> mimo_run with mode=plan.',
-      '- Desktop-native work (Desktop session UI, shared Desktop login/model) -> prefer backend=mimo-desktop (or preselect it in settings).',
-      '',
-      'Backend preselection (settings):',
-      '- Default backend is configured OUT-OF-BAND (plugin config.backend / env MIMO_BRIDGE_BACKEND / settings file).',
-      '- Per-call `backend` argument overrides the default only when necessary.',
-      '- Do NOT invent a backend every call — use the preselected default.',
       '',
       'Context protocol (one topic = one mimo session):',
       '- First dispatch on a topic: compact CONTEXT preamble (point to paths, do not paste file contents).',