zcode-pro 0.18.0 → 0.20.0

package/src/host/helper.mjs

@@ -4,19 +4,19 @@
 
 import { createServer } from 'node:http';
 import { execFile, spawn, spawnSync } from 'node:child_process';
-import { chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { appendFileSync, chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { mkdtemp } from 'node:fs/promises'; // 注意：fs 的 mkdtemp 是回调版，await 它会把 undefined 当回调
 import { basename, delimiter, dirname, isAbsolute, join, resolve, sep } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readSettings, writeSettingsAtomic, remapSettingsPaths, isProjectOpenInTabs } from './settings.mjs';
-import { taskIndexPath, probeTaskIndexWritable, remapTaskIndexPaths, taskIndexDriverAvailable, listOverriddenTitles, listTaskWorkspaceMap } from './taskIndex.mjs';
+import { taskIndexPath, probeTaskIndexWritable, remapTaskIndexPaths, taskIndexDriverAvailable, listOverriddenTitles, listTaskWorkspaceMap, setTaskTitleIfNotOverridden, setCustomSessionTitle, isTaskTitleOverridden, reconcileCustomTitles, getTaskProviderModel } from './taskIndex.mjs';
 import { pickFolderSystem } from './pickFolder.mjs';
 import { reorderWorkspaceTasks, reorderGroupMembers } from './taskOrder.mjs';
 import { webdavRequest, webdavPutWithMkcol, webdavHttpText, parseWebdavListing, findCurl } from './webdav.mjs';
 import { resolveZcodeExecutable } from './paths.mjs';
 
-const VERSION = '0.18.0';
+const VERSION = '0.20.0';
 
 // 全局提示词固定在用户主目录：官方加载器按 HOME/USERPROFILE 拼 .zcode/AGENTS.md，
 // 不读 ZCODE_DATA_BASE_DIR（数据根迁走时全局指令仍在原位）。
@@ -95,6 +95,23 @@ export function defaultConfig() {
     // headroom 启用开关的记忆（供应商 id → { proxy, direct }）：关闭时把走 headroom 的
     // 供应商地址切回直连并记录下来，再次开启时按记录把地址切回代理
     headroomRoutes: {},
+    // 任务名提示词（自动起名）：新会话开始作答后按可配置的供应商与提示词生成
+    // 标题，并按“手动重命名”写入任务索引。默认关闭。provider：
+    // 'session' = 跟随当前会话（调用时从任务索引解析该会话的供应商，默认）、
+    // '' = 不跟随（自填 baseUrl/apiKey/format）、其余 = 供应商 id（保存时同步
+    // 解析一份 baseUrl/apiKey/format 副本，供应商日后被删仍可直连）；
+    // model 默认 glm-5.3-flash（起名用快模型即可），跟随会话时可留空
+    //（用会话当前模型）；prompt 留空 = 内置默认提示词
+    titleGen: {
+      enabled: false,
+      customWritten: {},
+      provider: 'session',
+      model: 'glm-5.3-flash',
+      prompt: '',
+      baseUrl: '',
+      apiKey: '',
+      format: '',
+    },
     // HTTP 代理（http(s)://host:port）：helper 发起的网络访问走它——插件市场更新/安装
     // （zcode CLI → git）、headroom/rtk 的安装与升级（pip/GitHub）。空 = 不用代理。
     proxy: '',
@@ -102,14 +119,16 @@ export function defaultConfig() {
     // 软件（headroom 与 rtk）的安装、检查更新与升级；sync = WebDAV 同步。同步默认
     // 关闭——坚果云等国内网盘通常直连即可，代理停了同步会跟着失败
     proxyScopes: { plugins: true, deps: true, sync: false },
-    // 开发模式（设置弹窗“调试”标签页）：开启后出现「重载」按钮，可在不重启
+    // 开发模式（设置弹窗“调试”标签页）：开启后出现“重载”按钮，可在不重启
     // ZCode 的情况下加载新代码（构建 → 换新启动器进程 → 各窗口自动刷新重注入）
     devMode: false,
     // 设置同步（设置弹窗“同步”标签页，交互参考 Tampermonkey 的手动同步）：
     // 仅 WebDAV、仅在点击按钮时传输（type 字段预留多后端扩展，当前恒为 webdav）。
     // url 为 WebDAV 服务器地址；dir 为其下的上传目录（默认 zcode-pro，避免直接
     // 写进网盘根目录）；include 选择同步内容；凭据只存本机、不同步出去；
-    // lastPushAt/lastPullAt 只记录本机操作时间。
+    // lastPushAt/lastPullAt 只记录本机操作时间；historyLimit 为云端历史版本保留
+    // 个数（同一次上传的各组文件算一个，上传成功后自动删除更早的；0 = 不留历史，
+    // 只有固定名最新版）。
     sync: {
       type: 'webdav',
       url: '',
@@ -117,6 +136,7 @@ export function defaultConfig() {
       login: '',
       password: '',
       include: { zcodepro: true, model: true },
+      historyLimit: 10,
       lastPushAt: null,
       lastPullAt: null,
     },
@@ -141,6 +161,7 @@ export function loadConfig(configFile) {
       styles: { ...defaultConfig().styles, ...(saved.styles && typeof saved.styles === 'object' ? saved.styles : {}) },
       aliases: { ...((saved.aliases && typeof saved.aliases === 'object') ? saved.aliases : {}) },
       headroomRoutes: { ...((saved.headroomRoutes && typeof saved.headroomRoutes === 'object' && !Array.isArray(saved.headroomRoutes)) ? saved.headroomRoutes : {}) },
+      titleGen: mergeTitleGenConfig(saved.titleGen),
       proxyScopes: mergeProxyScopes(saved.proxyScopes),
       devMode: saved.devMode === true,
       // devActive 每次读取时重算（保存时会随配置一起写入文件，但读取方不用保存的值）：
@@ -229,6 +250,20 @@ function proxyUrlFor(scope) {
   return activeProxyScopes[scope] ? activeProxyUrl : '';
 }
 
+// 智能起名诊断日志：追加到 <dataRoot>/zcodepro.log（与启动诊断同文件），超 512KB
+// 轮转 .old。起名过程注入侧静默（失败不打扰用户），出问题时靠这里回查
+let titleGenLogRotated = false;
+function titleGenLog(dataRoot, line) {
+  try {
+    const file = join(dataRoot, 'zcodepro.log');
+    if (!titleGenLogRotated && existsSync(file) && statSync(file).size > 512 * 1024) {
+      renameSync(file, file + '.old');
+      titleGenLogRotated = true;
+    }
+    appendFileSync(file, `[${new Date().toISOString()}] title-gen ${line}\n`);
+  } catch { /* 日志失败不影响功能 */ }
+}
+
 export function startHelper({ port, token, dataRoot, state, agentsFile = defaultAgentsFile() }) {
   const configFile = join(dataRoot, 'zcodepro.json');
   const settingsFile = join(dataRoot, 'v2', 'setting.json');
@@ -299,6 +334,9 @@ export function startHelper({ port, token, dataRoot, state, agentsFile = default
         if (body && typeof body === 'object' && body.styles && typeof body.styles === 'object') {
           current.styles = applyStylesPartial(current.styles, body.styles);
         }
+        if (body && typeof body === 'object' && body.titleGen && typeof body.titleGen === 'object') {
+          current.titleGen = mergeTitleGenConfig({ ...current.titleGen, ...body.titleGen });
+        }
         saveConfig(configFile, current);
         json(res, 200, { ok: true, config: current });
         return;
@@ -398,6 +436,13 @@ export function startHelper({ port, token, dataRoot, state, agentsFile = default
       // 注入侧据此把被自动标题覆盖的侧栏行钉回重命名值；响应带开关，
       // 注入侧按需拉取这一个端点即可（无轮询）
       if (req.method === 'GET' && url.pathname === '/pinned-titles') {
+        // 先自动校正：桌面端打开会话时会把运行时缓存的旧标题写回任务索引（实测），
+        // 对我们写过且 CLI custom 仍是所写标题的会话，把索引改回来再下发
+        const config0 = loadConfig(configFile);
+        if (config0.titleGen.customWritten && Object.keys(config0.titleGen.customWritten).length) {
+          const repaired = await reconcileCustomTitles(dataRoot, config0.titleGen.customWritten);
+          if (repaired.length) titleGenLog(dataRoot, `reconciled sess=${repaired.map((s) => s.slice(5, 13)).join(',')}`);
+        }
         const r = await listOverriddenTitles(dataRoot);
         if (r.error) {
           json(res, 500, { ok: false, code: r.code, error: r.error });
@@ -407,6 +452,130 @@ export function startHelper({ port, token, dataRoot, state, agentsFile = default
         json(res, 200, { ok: true, enabled: config.features.titleLock !== false, titles: r.titles });
         return;
       }
+      // —— 智能起名：配置读写 + 供应商列表 + 生成并写库 ——
+      if (req.method === 'GET' && url.pathname === '/title-gen') {
+        json(res, 200, { ok: true, titleGen: loadConfig(configFile).titleGen, defaultPrompt: titleGenDefaultPrompt() });
+        return;
+      }
+      if (req.method === 'POST' && url.pathname === '/title-gen') {
+        const body = await readBody(req);
+        if (body && typeof body === 'object' && body.titleGen && typeof body.titleGen === 'object') {
+          const current = loadConfig(configFile);
+          const next = { ...current.titleGen, ...body.titleGen };
+          // 选了列表内供应商：同步解析并保存其地址/密钥/协议副本——供应商日后
+          // 被删，这份副本仍可直连（界面标注“已删除”并展开字段）；
+          // 跟随会话不存副本（每次调用时按该会话实时解析）
+          const providerId = (next.provider || '').trim();
+          if (providerId && providerId !== 'session') {
+            const found = listTitleGenProviders().find((p) => p.id === providerId);
+            if (found) {
+              next.baseUrl = found.baseUrl;
+              next.apiKey = found.apiKey;
+              next.format = found.format;
+            }
+            // 找不到（手输 id 或已删）：保留原有副本字段不动
+          } else if (providerId === 'session') {
+            // 跟随会话不存副本（每次调用时按该会话实时解析）
+            next.baseUrl = '';
+            next.apiKey = '';
+            next.format = '';
+          }
+          current.titleGen = mergeTitleGenConfig(next);
+          saveConfig(configFile, current);
+          json(res, 200, { ok: true, titleGen: current.titleGen });
+          return;
+        }
+        json(res, 400, { ok: false, code: 'invalid-request', error: 'body 需包含 titleGen 对象' });
+        return;
+      }
+      // 供应商下拉数据：与视觉代理同源同规则，但只列 helper 能在会话外直接
+      // 调用的条目（有地址、密钥且协议可判定），并带可选模型列表；不回密钥
+      if (req.method === 'GET' && url.pathname === '/title-gen/providers') {
+        json(res, 200, {
+          ok: true,
+          providers: listTitleGenProviders().map(({ apiKey, ...rest }) => rest),
+        });
+        return;
+      }
+      // 生成（并可选写库）：text = 会话首条消息；sessId 指定且非 test 时按
+      // “手动重命名”写入任务索引（已重命名的会话不会被动）；test = 设置面板
+      // 的测试按钮，只生成不写库
+      if (req.method === 'POST' && url.pathname === '/title-gen/run') {
+        const body = await readBody(req);
+        const text = typeof body?.text === 'string' ? body.text : '';
+        if (!text.trim()) {
+          json(res, 400, { ok: false, code: 'invalid-request', error: 'text 不能为空' });
+          return;
+        }
+        const cfg = loadConfig(configFile).titleGen;
+        if (cfg.enabled !== true && body.test !== true) {
+          json(res, 400, { ok: false, code: 'title-gen-disabled', error: '智能起名未开启' });
+          return;
+        }
+        const sessId = typeof body?.sessId === 'string' && /^sess_[A-Za-z0-9._-]+$/.test(body.sessId) ? body.sessId : '';
+        let title;
+        try {
+          title = await generateTitleWith(cfg, text, dataRoot, sessId);
+        } catch (err) {
+          titleGenLog(dataRoot, `generate-failed sess=${sessId.slice(0, 13)} err=${err?.message || err}`);
+          throw err; // 交给外层统一 500
+        }
+        let written = false;
+        let store = ''; // CLI 会话库写入结果：'' 成功 | skipped 原因 | 'error'
+        if (sessId && body.test !== true) {
+          // 已被手动重命名（或前次起名已写过）就整体跳过——手动重命名永远优先，
+          // 也避免起名晚到的 CLI 写入盖掉用户的 custom 标题
+          if (await isTaskTitleOverridden(dataRoot, sessId)) {
+            json(res, 200, { ok: true, title, written: false, store: 'skipped: overridden' });
+            return;
+          }
+          // 双写，顺序不能反：先写 CLI 会话库（title_source=custom，权威层——
+          // 官方自动起名看到 custom 会放弃，桌面同步器会把 custom 标题带着
+          // overridden=1 送回任务索引），再写任务索引（展示层，立即上屏）。
+          // 只写任务索引时，官方运行时排队的自动标题会在几秒后把它覆盖（实测）。
+          // CLI 库不可写（旧版无 title_source 列 / 无该会话行）不阻断：退回
+          // 单写任务索引的旧行为；任务索引随后失败也不回滚 CLI——同步器会补
+          for (let attempt = 0; ; attempt++) {
+            try {
+              const r = await setCustomSessionTitle(dataRoot, sessId, title);
+              store = r.written ? '' : (r.skipped || 'skipped');
+              break;
+            } catch (err) {
+              if (err.code === 'index-busy' && attempt < 2) {
+                await new Promise((r) => setTimeout(r, 1200));
+                continue;
+              }
+              store = 'error: ' + (err?.message || err);
+              titleGenLog(dataRoot, `cli-store-error sess=${sessId.slice(0, 13)} err=${err?.message || err}`);
+              break;
+            }
+          }
+          // 写库撞上宿主写入时稍候重试（起名不急这几秒）
+          for (let attempt = 0; ; attempt++) {
+            try {
+              const r = await setTaskTitleIfNotOverridden(dataRoot, sessId, title);
+              written = r.written;
+              break;
+            } catch (err) {
+              if (err.code === 'index-busy' && attempt < 2) {
+                await new Promise((r) => setTimeout(r, 1200));
+                continue;
+              }
+              titleGenLog(dataRoot, `index-error sess=${sessId.slice(0, 13)} err=${err?.message || err}`);
+              json(res, 500, { ok: false, code: err.code || 'index-error', error: err.message });
+              return;
+            }
+          }
+        }
+        // CLI 库写成功了才登记回查记录（reconcileCustomTitles 只认这些记录校正）
+        if (sessId && store === '') {
+          const c = loadConfig(configFile);
+          c.titleGen.customWritten = { ...(c.titleGen.customWritten || {}), [sessId]: { title, at: Date.now() } };
+          saveConfig(configFile, c);
+        }
+        json(res, 200, { ok: true, title, written, store });
+        return;
+      }
       // —— zcode-vision 插件（图片视觉代理）：设置弹窗“视觉代理”标签页读写 ————
       if (req.method === 'GET' && url.pathname === '/vision') {
         const file = defaultVisionFile();
@@ -807,7 +976,7 @@ export function startHelper({ port, token, dataRoot, state, agentsFile = default
           json(res, r.status || 500, { ok: false, code: r.code || 'sync-run', error: r.error });
           return;
         }
-        json(res, 200, { ok: true, direction, applied: r.applied, sync: loadConfig(configFile).sync });
+        json(res, 200, { ok: true, direction, applied: r.applied, ...(typeof r.pruned === 'number' ? { pruned: r.pruned } : {}), sync: loadConfig(configFile).sync });
         return;
       }
       // —— 同步连通性测试（“测试”按钮）：用表单当前值逐步验证（可先测再存），不写入配置文件 ——
@@ -973,7 +1142,7 @@ export function startHelper({ port, token, dataRoot, state, agentsFile = default
               if (r.ok) updated += 1;
             } else if (!p.installed && only) {
               // 安装只走单插件入口（name 指定＝各面板的安装卡）：
-              // 全量「检查并更新」/启动自动更新只升级已装插件——卸载必须被尊重，
+              // 全量“检查并更新”/启动自动更新只升级已装插件——卸载必须被尊重，
               // 未装插件一律由用户在各 tab 显式点安装
               const r = await runZcodeCli(['plugins', 'install', `${p.name}@${ZCODE_PLUGINS_MARKETPLACE}`], 120000);
               steps.push({ step: `install ${p.name}`, ok: r.ok, output: r.output });
@@ -1032,6 +1201,38 @@ function clampInt(v, min, max, dflt) {
 
 // —— 设置同步（“同步”标签页）的实现 ——
 
+// loadConfig 时把磁盘上的 titleGen 段按默认值归一（智能起名）：只收已知字段，
+// 字符串限长；enabled 默认关闭（改动官方起名行为，需用户显式开启）
+function mergeTitleGenConfig(saved) {
+  const d = defaultConfig().titleGen;
+  const s = (saved && typeof saved === 'object' && !Array.isArray(saved)) ? saved : {};
+  // 旧版配置的 'cli'（登录账号单独成模式）统一迁移为 'session'：
+  // 登录账号的套餐已在供应商列表里，跟随会话即覆盖原语义
+  const provider = typeof s.provider === 'string' ? s.provider.trim().slice(0, 200) : d.provider;
+  // customWritten：起名功能写过的 { sessId → { title, at } }，自动校正只认这些
+  // 记录（见 reconcileCustomTitles）。只收合法会话 id 与短字符串，超 7 天/500 条的丢弃
+  const written = {};
+  const cutoff = Date.now() - 7 * 24 * 3600 * 1000;
+  let kept = 0;
+  for (const [k, v] of Object.entries((s.customWritten && typeof s.customWritten === 'object' && !Array.isArray(s.customWritten)) ? s.customWritten : {})) {
+    if (kept >= 500 || !/^sess_[A-Za-z0-9._-]+$/.test(k)) continue;
+    if (!v || typeof v !== 'object' || typeof v.title !== 'string' || v.title.length > 200) continue;
+    if (!Number.isFinite(v.at) || v.at < cutoff) continue;
+    written[k] = { title: v.title, at: v.at };
+    kept++;
+  }
+  return {
+    enabled: s.enabled === true,
+    provider: provider === 'cli' ? 'session' : provider,
+    model: typeof s.model === 'string' ? s.model.trim().slice(0, 200) : d.model,
+    prompt: typeof s.prompt === 'string' ? s.prompt.slice(0, 20000) : d.prompt,
+    baseUrl: typeof s.baseUrl === 'string' ? s.baseUrl.trim().slice(0, 500) : d.baseUrl,
+    apiKey: typeof s.apiKey === 'string' ? s.apiKey.trim().slice(0, 500) : d.apiKey,
+    format: s.format === 'openai' ? 'openai' : s.format === 'anthropic' ? 'anthropic' : '',
+    customWritten: written,
+  };
+}
+
 // loadConfig 时把磁盘上的 proxyScopes 按默认值归一（只收布尔，缺的补默认：
 // 插件市场/依赖软件开、同步关）
 function mergeProxyScopes(saved) {
@@ -1057,13 +1258,16 @@ function mergeSyncConfig(saved) {
     login: typeof saved.login === 'string' ? saved.login.slice(0, 300) : '',
     password: typeof saved.password === 'string' ? saved.password.slice(0, 300) : '',
     include: { zcodepro: inc.zcodepro !== false, model: inc.model !== false },
+    historyLimit: Number.isInteger(saved.historyLimit) && saved.historyLimit >= 0 && saved.historyLimit <= 100
+      ? saved.historyLimit : d.historyLimit,
     lastPushAt: Number.isFinite(saved.lastPushAt) ? saved.lastPushAt : null,
     lastPullAt: Number.isFinite(saved.lastPullAt) ? saved.lastPullAt : null,
   };
 }
 
 // POST /sync 表单校验：url/login/password/dir 全量替换（dir 缺省时不动已有值）。
-// URL 必填，指向 WebDAV 服务器（可含路径前缀）；dir 为其下的上传目录，可多级
+// URL 必填，指向 WebDAV 服务器（可含路径前缀）；dir 为其下的上传目录，可多级；
+// historyLimit 可选（缺省时不动已有值），0–100 的整数
 function validateSyncForm(raw) {
   const url = typeof raw.url === 'string' ? raw.url.trim() : '';
   const login = typeof raw.login === 'string' ? raw.login.trim() : '';
@@ -1084,6 +1288,12 @@ function validateSyncForm(raw) {
     }
     out.dir = dir;
   }
+  if (raw.historyLimit !== undefined && raw.historyLimit !== null) {
+    if (!Number.isInteger(raw.historyLimit) || raw.historyLimit < 0 || raw.historyLimit > 100) {
+      return { error: '历史版本保留个数需为 0–100 的整数' };
+    }
+    out.historyLimit = raw.historyLimit;
+  }
   return { sync: out };
 }
 
@@ -1177,8 +1387,10 @@ async function runSettingsSync({ direction, dataRoot, configFile, config, proxyU
 // 上传：每组独立一个云端文件（zcodepro.json / model.json，始终最新一版），勾选几组
 // 写几个；写前预读云端内容，别名与本机的合并后再写（合并规则见 mergeAliases），
 // 其余内容整份覆盖。同一份内容再写一个带时间戳的历史版本文件，供下载时任选版本
-// 恢复（旧版 zcode-pro 仍读固定名）
+// 恢复（旧版 zcode-pro 仍读固定名）；历史版本最多保留 historyLimit 个（同一时间戳
+// 的各组文件算一个），上传成功后自动删除更早的
 async function runSyncPush({ dataRoot, configFile, config, sync, proxyUrl }) {
+  const keep = Number.isInteger(sync.historyLimit) ? sync.historyLimit : defaultConfig().sync.historyLimit;
   const docs = {};
   if (sync.include.zcodepro) {
     // sync（本机的同步配置与凭据）与 version（本机 helper 版本）不外发
@@ -1223,10 +1435,13 @@ async function runSyncPush({ dataRoot, configFile, config, sync, proxyUrl }) {
       if (put.httpCode < 200 || put.httpCode >= 300) {
         return { code: 'sync-request', status: 502, error: webdavHttpText(put.httpCode) };
       }
-      const putVersion = await putUrl(syncVersionName(kind, stamp));
-      if (!putVersion.ok) return { code: 'sync-request', status: 502, error: putVersion.error };
-      if (putVersion.httpCode < 200 || putVersion.httpCode >= 300) {
-        return { code: 'sync-request', status: 502, error: webdavHttpText(putVersion.httpCode) };
+      // 历史版本只在保留个数 > 0 时写（0 = 只留固定名最新版，由上传后清理收尾）
+      if (keep > 0) {
+        const putVersion = await putUrl(syncVersionName(kind, stamp));
+        if (!putVersion.ok) return { code: 'sync-request', status: 502, error: putVersion.error };
+        if (putVersion.httpCode < 200 || putVersion.httpCode >= 300) {
+          return { code: 'sync-request', status: 502, error: webdavHttpText(putVersion.httpCode) };
+        }
       }
       pushed.push(kind);
     }
@@ -1235,7 +1450,9 @@ async function runSyncPush({ dataRoot, configFile, config, sync, proxyUrl }) {
   }
   sync.lastPushAt = Date.now();
   saveConfig(configFile, config);
-  return { applied: pushed };
+  // 上传成功后清理超出保留个数的旧历史版本（best-effort，失败不影响上传结果）
+  const pruned = await pruneSyncHistory(sync, proxyUrl, keep);
+  return { applied: pushed, pruned };
 }
 
 // 下载：把云端所选组应用到本机（各组独立文件，勾选几组读几组，可只覆盖模型设置）。
@@ -1378,6 +1595,39 @@ async function listSyncVersions(sync, proxyUrl) {
   return { files };
 }
 
+// 从云端文件名列表选出待删除的历史版本（导出以便测试脚本直接驱动）：带时间戳的
+// 文件按时间戳段分组——同一次上传的各组文件共用一个时间戳，算“一个”；时间戳
+// 段定宽零填充，字典序即时间序。保留最近 keep 个，返回更早的各组文件名；
+// 固定名（zcodepro.json / model.json）和不相干的文件名不会出现在结果里
+export function syncHistoryStaleNames(names, keep) {
+  const groups = new Map();
+  for (const name of names) {
+    const ts = (String(name).match(/^(?:zcodepro|model)(-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.json$/) || [])[1];
+    if (!ts) continue;
+    if (!groups.has(ts)) groups.set(ts, []);
+    groups.get(ts).push(name);
+  }
+  // 时间戳段按新 → 旧排，slice(keep) 剩下的即超出保留个数的更早各组
+  return [...groups.keys()].sort((a, b) => b.localeCompare(a)).slice(Math.max(0, keep)).flatMap((ts) => groups.get(ts));
+}
+
+// 上传后清理云端目录里超出保留个数的历史版本：列出文件，删掉 syncHistoryStaleNames
+// 归出的旧文件。best-effort——列目录或单个删除失败只跳过（下次上传再清），不抛错；
+// 返回本次删掉的文件数
+async function pruneSyncHistory(sync, proxyUrl, keep) {
+  const list = await listSyncVersions(sync, proxyUrl);
+  if (list.error) return 0;
+  const stale = syncHistoryStaleNames(list.files.map((f) => f.name), keep);
+  let removed = 0;
+  for (const name of stale) {
+    const r = await webdavRequest({ method: 'DELETE', url: syncFileUrlByName(sync, name), login: sync.login, password: sync.password, proxyUrl, timeoutMs: 30000 });
+    if (!r.ok) continue; // 网络失败：跳过该文件
+    if (r.httpCode !== 404 && (r.httpCode < 200 || r.httpCode >= 300)) continue; // 404 = 已不在，视为已清
+    removed++;
+  }
+  return removed;
+}
+
 // 别名表清洗（同步下载用）：只收 路径字符串 → 短字符串 的条目，数量限幅
 function sanitizeAliases(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
@@ -1485,7 +1735,7 @@ export async function scanIdleBusy(paths, dataRoot) {
   return SCAN_OFF;
 }
 
-// Linux：/proc 直读（comm 定位 CLI、cwd 定位项目、task/<pid>/children 拿子进程）
+// Linux：直接读取 /proc（comm 定位 CLI、cwd 定位项目、task/<pid>/children 拿子进程）
 function scanIdleBusyLinux(paths) {
   let pids;
   try { pids = readdirSync('/proc').filter((d) => /^\d+$/.test(d)); }
@@ -1672,33 +1922,302 @@ function sanitizeFontStack(v) {
   return s;
 }
 
-// 跟随供应商下拉取数：合并 ~/.zcode/v2/config.json 的 provider（优先）与
-// ~/.zcode/v2/provider_config.json 的 providerRules（同 id 时规则表的名字保留为别名）；只回 id/名称/别名，不含密钥。
+// 视觉代理“跟随供应商”下拉取数：与智能起名共用同一套供应商列表和过滤规则
+//（见 listTitleGenProviders），只回 id/名称/别名，不含密钥。
 // 导出以便测试脚本直接驱动。
 export function listVisionProviders() {
-  const list = [];
+  return listTitleGenProviders().map((p) => ({ id: p.id, name: p.name, aliases: p.aliases || [] }));
+}
+
+// —— 智能起名：供应商取数、模型调用与标题清洗 ——
+
+// 内置默认提示词（用户可在设置弹窗覆盖），按界面语言取中文或英文版。
+// 英文版的词数上限比中文版紧：英文单词更长，3~15 个词在会话列表里放不下
+const TITLE_GEN_DEFAULT_PROMPTS = {
+  zh: [
+    '为下面的会话生成一个简短的标题。',
+    '要求：',
+    '- 使用用户消息的主要语言（中文消息用中文标题）',
+    '- 概括用户要做的主要事情或主题，不要给出答案或结果',
+    '- 一般3~15个词，在会话列表里能一眼认出',
+    '- 保留重要的专有名词（文件名、产品名、技术名词等，如有）',
+    '- 不要用`用户请求`、`新任务`、`提问`这类泛泛的标题',
+    '- 不要直接复述或截取用户消息原文当标题',
+    '- 只输出标题本身：不要解释、不要引号、不要末尾标点、不要markdown',
+  ].join('\n'),
+  en: [
+    'Generate a short title for the session below.',
+    'Requirements:',
+    "- Use the primary language of the user's message (an English message gets an English title)",
+    '- Summarize the user\'s main task or topic; do not give the answer or result',
+    '- Usually 3-8 words, easy to recognize in a session list',
+    '- Keep important proper nouns (file names, product names, technical terms, if any)',
+    '- Avoid generic titles such as `User Request`, `New Task`, or `Question`',
+    '- Do not copy or truncate the user\'s message as the title',
+    '- Output only the title itself: no explanation, no quotes, no trailing punctuation, no markdown',
+  ].join('\n'),
+};
+
+// 界面语言：桌面设置（v2/setting.json 的 localePreference）为 en-US / zh-CN 时
+// 直接采用；system 或未设置时按系统环境语言判断（中文环境 → 中文，其余 → 英文）
+function titleGenLocale() {
+  const s = readJsonFile(join(homedir(), '.zcode', 'v2', 'setting.json'));
+  const pref = String((s && s.localePreference) || '').toLowerCase();
+  if (pref.startsWith('en')) return 'en';
+  if (pref.startsWith('zh')) return 'zh';
+  const lang = String(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || '').toLowerCase();
+  return lang.startsWith('zh') ? 'zh' : 'en';
+}
+
+function titleGenDefaultPrompt() {
+  return TITLE_GEN_DEFAULT_PROMPTS[titleGenLocale()] || TITLE_GEN_DEFAULT_PROMPTS.en;
+}
+
+const TITLE_GEN_MAX_TEXT = 1200;  // 用户消息送入模型的长度上限（与官方起名一致）
+const TITLE_GEN_MAX_TITLE = 64;   // 生成标题的长度上限（按字符计）
+const TITLE_GEN_TIMEOUT_MS = 60000; // 单次模型调用超时（与官方起名一致；推理模型思考占时较长）
+
+// 内置套餐显示名：与 ZCode 界面的叫法一致——条目原始名区分度差
+//（coding-plan 与 start-plan 都叫 "Coding Plan"），界面里按套餐类型显示。
+// coding-plan 的个人/团队是动态的：从桌面设置（v2/setting.json 的
+// providerFamilyConnectionSelections）读当前登录的连接方式（kind 含
+// individual → 个人、team → 团队），读不到时退回“个人/团队”
+function codingPlanKindByFamily() {
+  const s = readJsonFile(join(homedir(), '.zcode', 'v2', 'setting.json'));
+  const sel = (s && s.providerFamilyConnectionSelections && typeof s.providerFamilyConnectionSelections === 'object')
+    ? s.providerFamilyConnectionSelections : {};
+  const out = {};
+  for (const [family, v] of Object.entries(sel)) {
+    const kind = String(v?.kind || '');
+    if (/individual/i.test(kind)) out[family] = '个人';
+    else if (/team/i.test(kind)) out[family] = '团队';
+  }
+  return out;
+}
+
+function titleGenProviderDisplayName(id, name, planKinds = {}) {
+  const m = /^builtin:(zai|bigmodel)-coding-plan$/.exec(id);
+  if (m) {
+    const fam = m[1] === 'zai' ? 'Z.ai' : 'BigModel';
+    return `${fam}（${planKinds[m[1]] || '个人/团队'}）`;
+  }
+  if (/^builtin:(zai|bigmodel)-start-plan$/.test(id)) return 'Start Plan';
+  return (name && String(name).trim()) || id;
+}
+
+// 供应商条目（智能起名与视觉代理共用），列表范围与 ZCode 界面的供应商列表
+// 保持一致：
+// - 内置套餐（builtin:*）：有地址、密钥才列出（无密钥的 helper 无法在会话外
+//   调用，如未配 key 的 API Key 型条目）；
+// - 自定义供应商：以 provider_config.json 的 providerOrder 为准（ZCode 界面的
+//   自定义列表就来自它），provider 表里不在其中的残留条目（已弃用的中转等）
+//   不列出；
+// - 协议：api.type / kind 缺失时按地址推断（含 anthropic → anthropic，含
+//   openai 或以 /v\d 结尾 → openai），两个都推不出才放弃该条目。
+// 两张来源表同 id 合并（模型并集、原始名收进别名）。models 为该供应商的
+// 可选模型（下拉用，可为空）。导出以便测试
+export function listTitleGenProviders() {
+  const out = [];
   const byId = new Map();
-  const v2 = readJsonFile(join(homedir(), '.zcode', 'v2', 'config.json'));
-  for (const [id, p] of Object.entries((v2 && typeof v2.provider === 'object' && v2.provider) || {})) {
-    const entry = { id, name: (p && typeof p.name === 'string' && p.name.trim()) || id, aliases: [] };
-    list.push(entry);
+  const planKinds = codingPlanKindByFamily();
+  const add = (id, { name, aliases = [], kind, baseUrl, apiKey, models = [] }) => {
+    baseUrl = typeof baseUrl === 'string' ? baseUrl.trim() : '';
+    apiKey = typeof apiKey === 'string' ? apiKey.trim() : '';
+    if (!id || !baseUrl || !apiKey) return;
+    let format = /anthropic/i.test(String(kind)) ? 'anthropic' : /openai/i.test(String(kind)) ? 'openai' : '';
+    if (!format) format = /anthropic/i.test(baseUrl) ? 'anthropic'
+      : (/openai/i.test(baseUrl) || /\/v\d+$/.test(baseUrl)) ? 'openai' : '';
+    if (!format) return;
+    models = models.filter(Boolean);
+    const known = byId.get(id);
+    if (known) {
+      known.models = [...new Set([...known.models, ...models])];
+      for (const a of aliases) if (a && !known.aliases.includes(a)) known.aliases.push(a);
+      return;
+    }
+    const shown = titleGenProviderDisplayName(id, name, planKinds);
+    const entry = {
+      id, name: shown, aliases: [...new Set(aliases.filter((a) => a && a !== shown))],
+      format, baseUrl, apiKey, models: [...new Set(models)],
+    };
     byId.set(id, entry);
-  }
+    out.push(entry);
+  };
+
+  const v2 = readJsonFile(join(homedir(), '.zcode', 'v2', 'config.json'));
+  const providers = (v2 && typeof v2.provider === 'object' && v2.provider) || {};
   const rulesDoc = readJsonFile(join(homedir(), '.zcode', 'v2', 'provider_config.json'));
   const rules = (rulesDoc && rulesDoc.config?.providerConfigRules?.providerRules) || [];
-  for (const r of rules) {
-    if (!r || typeof r.providerId !== 'string' || !r.providerId) continue;
-    const existing = byId.get(r.providerId);
-    if (existing) {
-      const alias = (typeof r.providerName === 'string' && r.providerName.trim()) || r.providerId;
-      if (alias !== existing.name && !existing.aliases.includes(alias)) existing.aliases.push(alias);
-      continue;
-    }
-    const entry = { id: r.providerId, name: (typeof r.providerName === 'string' && r.providerName.trim()) || r.providerId, aliases: [] };
-    list.push(entry);
-    byId.set(r.providerId, entry);
+  const ruleById = new Map(rules.filter((r) => r && typeof r.providerId === 'string').map((r) => [r.providerId, r]));
+  // 同一 id 在两张表的字段并起来（provider 表优先：地址/密钥以桌面实际在用的为准）
+  const addMerged = (id) => {
+    const p = providers[id];
+    if (p !== undefined && (p === null || typeof p !== 'object')) return;
+    const r = ruleById.get(id) || {};
+    const c = r.config || {};
+    add(id, {
+      name: (p && p.name) || r.providerName,
+      aliases: [r.providerName, p && p.name],
+      kind: (p && p.kind) || c.api?.type,
+      baseUrl: (p && p.options?.baseURL) || c.api?.baseUrl,
+      apiKey: (p && p.options?.apiKey) || c.access?.apiKey,
+      models: [...Object.keys((p && p.models) || {}), ...(c.modelOrder || []), ...(c.personalModelIds || [])],
+    });
+  };
+
+  // 内置套餐在前（BigModel（个人/团队）→ Start Plan 的顺序）
+  for (const id of Object.keys(providers)) {
+    if (id.startsWith('builtin:')) addMerged(id);
   }
-  return list;
+  // 自定义供应商按界面顺序（providerOrder）
+  const order = (rulesDoc && Array.isArray(rulesDoc.config?.providerOrder) ? rulesDoc.config.providerOrder : [])
+    .filter((id) => typeof id === 'string');
+  for (const id of order) addMerged(id);
+  return out;
+}
+
+// Anthropic Messages 文本调用（无系统提示词，单条用户消息）。max_tokens 给足
+// 2048：glm 系列等推理模型先输出 thinking 块再出正文，给小了会全部耗在
+// 思考上（stop_reason=max_tokens 且没有任何 text 块），起名调用不在意这点额度
+async function callAnthropicText(baseUrl, apiKey, model, content) {
+  const url = baseUrl.replace(/\/+$/, '') + '/v1/messages';
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TITLE_GEN_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      method: 'POST', signal: ctrl.signal,
+      headers: { 'content-type': 'application/json', 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+      body: JSON.stringify({ model, max_tokens: 2048, messages: [{ role: 'user', content }] }),
+    });
+    const body = await resp.text();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status} [model=${model}]: ${body.slice(0, 300)}`);
+    const doc = JSON.parse(body);
+    const text = Array.isArray(doc.content)
+      ? doc.content.filter((b) => b && b.type === 'text').map((b) => b.text || '').join('') : '';
+    if (!text) throw new Error(doc.stop_reason === 'max_tokens'
+      ? '模型的思考用完了输出上限，仍未给出标题' : '响应中没有文本内容');
+    return text;
+  } catch (err) {
+    if (err && err.name === 'AbortError') throw new Error(`请求超时（${Math.round(TITLE_GEN_TIMEOUT_MS / 1000)} 秒）`);
+    throw err;
+  } finally { clearTimeout(timer); }
+}
+
+// OpenAI Chat Completions 文本调用；baseURL 已含 /v1 时不重复拼
+async function callOpenAiText(baseUrl, apiKey, model, content) {
+  const base = baseUrl.replace(/\/+$/, '');
+  const url = /\/v\d+$/.test(base) ? base + '/chat/completions' : base + '/v1/chat/completions';
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TITLE_GEN_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      method: 'POST', signal: ctrl.signal,
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({ model, max_tokens: 2048, messages: [{ role: 'user', content }] }),
+    });
+    const body = await resp.text();
+    if (!resp.ok) throw new Error(`HTTP ${resp.status} [model=${model}]: ${body.slice(0, 300)}`);
+    const doc = JSON.parse(body);
+    const text = doc.choices?.[0]?.message?.content || '';
+    if (typeof text !== 'string' || !text.trim()) throw new Error('响应中没有文本内容');
+    return text;
+  } catch (err) {
+    if (err && err.name === 'AbortError') throw new Error(`请求超时（${Math.round(TITLE_GEN_TIMEOUT_MS / 1000)} 秒）`);
+    throw err;
+  } finally { clearTimeout(timer); }
+}
+
+// 生成标题。provider 三种取值：
+// - 'session'：跟随当前会话——从任务索引解析该会话正在用的供应商与模型
+//   （model 已填时用填写的），供应商需在可直连列表内；
+// - ''：不跟随，用配置里的 baseUrl/apiKey/format 直连；
+// - 供应商 id：按列表解析直连；id 已被删时退回保存时留下的地址/密钥副本。
+// 输出统一清洗为单行短标题。导出以便测试
+export async function generateTitleWith(cfg, rawText, dataRoot = '', sessId = '') {
+  const text = String(rawText || '').trim().replace(/\s+/g, ' ').slice(0, TITLE_GEN_MAX_TEXT);
+  const prompt = (cfg.prompt && cfg.prompt.trim()) || titleGenDefaultPrompt();
+  // 注入当前日期（上海时区）：起名模型是无状态的，自定义提示词里要求
+  // “MMDD 取对话创建日期”时它无从得知，只能留字面量 MMDD
+  const now = new Date(Date.now() + 8 * 3600 * 1000);
+  const pad = (n) => String(n).padStart(2, '0');
+  const dateLine = `当前日期（Asia/Shanghai）：${now.getUTCFullYear()}-${pad(now.getUTCMonth() + 1)}-${pad(now.getUTCDate())}（MMDD 即 ${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}）`;
+  const userContent = `${prompt}\n\n${dateLine}\n\n会话的用户消息：\n${text}`;
+  const providerId = (cfg.provider || '').trim();
+  const model = (cfg.model || '').trim();
+  const conn = await resolveTitleGenConnection(cfg, providerId, model, dataRoot, sessId);
+  const raw = conn.format === 'anthropic'
+    ? await callAnthropicText(conn.baseUrl, conn.apiKey, conn.model, userContent)
+    : await callOpenAiText(conn.baseUrl, conn.apiKey, conn.model, userContent);
+  const title = cleanGeneratedTitle(raw);
+  if (!title) throw new Error('模型未返回可用标题');
+  return title;
+}
+
+// 直连前的连接解析（见 generateTitleWith 的取值说明）；解析不出抛明确错误
+async function resolveTitleGenConnection(cfg, providerId, model, dataRoot, sessId) {
+  if (providerId === 'session') {
+    if (!sessId || !dataRoot) {
+      throw new Error('跟随当前会话需要会话信息（测试按钮请选择具体供应商或“不跟随”）');
+    }
+    const task = await getTaskProviderModel(dataRoot, sessId);
+    if (!task || !task.providerId) throw new Error('索引中查不到该会话的供应商信息');
+    const entry = listTitleGenProviders().find((p) => p.id === task.providerId);
+    if (!entry) throw new Error(`会话供应商 ${task.providerId} 无法在会话外直连（无密钥或协议未知）`);
+    const useModel = model || task.modelId;
+    if (!useModel) throw new Error('未能确定会话当前模型，请手动填写模型');
+    return { format: entry.format, baseUrl: entry.baseUrl, apiKey: entry.apiKey, model: useModel };
+  }
+  if (providerId) {
+    const entry = listTitleGenProviders().find((p) => p.id === providerId);
+    if (entry) {
+      if (!model) throw new Error('已选择供应商，但未填写模型');
+      return { format: entry.format, baseUrl: entry.baseUrl, apiKey: entry.apiKey, model };
+    }
+    // 供应商已被删：退回保存时的地址/密钥副本
+    if (cfg.baseUrl && cfg.apiKey && cfg.format) {
+      if (!model) throw new Error('已删除的供应商需手动填写模型');
+      return { format: cfg.format, baseUrl: cfg.baseUrl, apiKey: cfg.apiKey, model };
+    }
+    throw new Error(`供应商 ${providerId} 已不可用（未保存地址/密钥副本），请重新选择`);
+  }
+  // 不跟随（自填地址）
+  if (!cfg.baseUrl || !cfg.apiKey || !cfg.format) {
+    throw new Error('不跟随（自填地址）需要填写接口地址、API Key 与协议');
+  }
+  if (!model) throw new Error('不跟随（自填地址）需要填写模型');
+  return { format: cfg.format, baseUrl: cfg.baseUrl, apiKey: cfg.apiKey, model };
+}
+
+// 清洗模型输出：去思考块/代码围栏/首尾引号/序号/末尾标点，取首个非空行并限长。
+// 模型可能沿用官方起名的习惯回 JSON 对象，此时取其 title 字段。自定义提示词常让
+// 模型“先说明再给标题”（如“无法直接修改会话标题……建议手动设置：”后另起一行
+// 【MMDD|类型|主题】），此时首个非空行是说明而非标题——优先取独立成行的
+// 【】/[] 包裹标题行（允许行首 markdown 标题符）。导出以便测试
+export function cleanGeneratedTitle(text) {
+  let t = String(text || '').replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+  // 整段包在代码围栏里时先去掉围栏标记（先取行会把“```json”当成标题内容）
+  t = t.replace(/^```[a-zA-Z]*\s*\n?/, '').replace(/\n?```\s*$/, '').trim();
+  const lines = t.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  // 标题行判定前剥掉 markdown 外壳（## 标题符、**加粗**、*斜体*、_下划线_、~~删除线~~）
+  const unwrap = (s) => s.replace(/^#{1,4}\s*/, '').replace(/^[*_~]+/, '').replace(/[*_~]+$/, '').trim();
+  const bracketed = lines.find((s) => /^(?:【[^】]{1,60}】|\[[^\]\n]{1,60}\])$/.test(unwrap(s)));
+  let line = bracketed ? unwrap(bracketed) : (lines[0] || '');
+  line = line.replace(/^```[a-zA-Z]*\s*/, '').replace(/```\s*$/, '');
+  try {
+    const doc = JSON.parse(line);
+    if (doc && typeof doc.title === 'string') line = doc.title;
+  } catch { /* 不是 JSON，按纯文本处理 */ }
+  line = line.replace(/^["'「『“]+/, '').replace(/["'」』”]+$/, '');
+  line = line.replace(/^\d+[.、)\]]\s*/, '');
+  line = line.replace(/[.。!！?？，,;；:：]\s*$/, '');
+  line = line.replace(/\s+/g, ' ').trim();
+  const chars = [...line];
+  if (chars.length > TITLE_GEN_MAX_TITLE) {
+    line = chars.slice(0, TITLE_GEN_MAX_TITLE).join('');
+    // 截断落在英文单词中间时退到词边界，避免出现半个单词
+    if (line.includes(' ')) line = line.slice(0, line.lastIndexOf(' '));
+  }
+  return line.trim();
 }
 
 // zcode-vision 配置校验：只保留已知字段并规范化；出错时返回中文原因。
@@ -1743,7 +2262,11 @@ export function validateVisionConfig(raw) {
     names.add(name);
     proxy.name = name;
     if (!(proxy.baseUrl || '').trim() && !(proxy.useProvider || '').trim()) return [null, `代理 ${name} 缺少 baseUrl（或设置 useProvider 跟随供应商）`];
-    if (!(proxy.model || '').trim()) return [null, `代理 ${name} 缺少 model`];
+    // 跟随会话（useProvider=session）时允许 model 留空：留空 = 用会话当前模型
+    //（zcode-vision ≥1.6.1 支持）；其余情况必须填写
+    if (!(proxy.model || '').trim() && proxy.useProvider !== 'session') {
+      return [null, `代理 ${name} 缺少 model`];
+    }
     if (proxy.baseUrl) proxy.baseUrl = proxy.baseUrl.trim();
     if (proxy.model) proxy.model = proxy.model.trim();
     if (proxy.useProvider) proxy.useProvider = proxy.useProvider.trim();
@@ -2028,7 +2551,7 @@ async function ensureUserPathEntry(dir) {
 }
 
 // 在插件缓存里找市场插件的钩子脚本：只认 installed_plugins.json 登记的 installPath。
-// 不能按目录扫描：卸载只删「当前指向」的版本目录，缓存里的历史版本目录会残留
+// 不能按目录扫描：卸载只删“当前指向”的版本目录，缓存里的历史版本目录会残留
 // （升级留旧版、GitHub/本地源先后装过等），扫目录会把已卸载的插件误判为已装，
 // 面板就不显示安装卡了。本地开发流（install-plugin-local.sh）同样会更新安装记录，兼容。
 // 注意只认正式市场 duanluan-zcode-plugins：本地临时市场（如 duanluan-local）装的副本不在查找范围，
@@ -2047,7 +2570,7 @@ function findVisionHook() {
   return findMarketplaceHook('zcode-vision', join('hooks', 'vision-hook.mjs'));
 }
 
-// 读市场插件在 installed_plugins.json 里登记的版本（面板信息卡显示「插件 x.y.z」用）
+// 读市场插件在 installed_plugins.json 里登记的版本（面板信息卡显示“插件 x.y.z”用）
 function installedPluginVersion(pluginName) {
   const installedRaw = readJsonFile(join(cliPluginsDir(), 'installed_plugins.json'));
   const rec = (installedRaw?.plugins || []).find((p) => p?.name === pluginName && p?.marketplace === ZCODE_PLUGINS_MARKETPLACE);
@@ -2523,13 +3046,14 @@ function zcodeCliBundleCandidates() {
   ].filter(Boolean);
 }
 
-// 运行 zcode CLI 子命令（plugins …，走 plugins 代理范围）
-function runZcodeCli(subArgs, timeoutMs = 120000) {
+// 运行 zcode CLI 子命令（plugins … 默认走 plugins 代理范围；智能起名的
+// 无界面提问传 none——模型 API 直连，不走下载代理）
+function runZcodeCli(subArgs, timeoutMs = 120000, scope = 'plugins') {
   const bundle = zcodeCliBundleCandidates().find((c) => existsSync(c));
   if (!bundle) {
     return Promise.resolve({ ok: false, code: 'cli-not-found', error: '未找到 ZCode CLI（resources/glm/zcode.cjs）' });
   }
-  return runNodeScript([bundle, ...subArgs], timeoutMs, 'plugins');
+  return runNodeScript([bundle, ...subArgs], timeoutMs, scope);
 }
 
 // 比对市场清单与已装清单：每个插件的已装版本与最新版本。导出以便测试。
@@ -2600,12 +3124,30 @@ export function writeAgents(body, agentsFile) {
   return [200, { ok: true, content: body.content }];
 }
 
+// 路径不存在时的还原尝试。宿主把消息里的反斜杠路径渲染成文件 chip 时，markdown
+// 会把 “\.” 当转义序列吃掉反斜杠（Administrator\.zcode 变成 Administrator.zcode），
+// 其余分隔符再统一显示为 /，chip 上拿到的就是这种坏路径。把每个“段名.点开头后缀”
+// 形式的段试着拆回两级（Administrator.zcode → Administrator/.zcode），哪个变体
+// 真实存在就用哪个；都不存在返回 null，按原路径走 not-found。导出以便测试脚本直接驱动。
+export function recoverSwallowedSeparator(rawPath) {
+  const segs = String(rawPath).split(/[\\/]/);
+  for (let i = 0; i < segs.length; i++) {
+    const dot = segs[i].indexOf('.');
+    if (dot <= 0) continue; // 段里没有点，或本身就是 .zcode 这类点开头目录
+    const candidate = [...segs.slice(0, i), segs[i].slice(0, dot), segs[i].slice(dot), ...segs.slice(i + 1)].join(sep);
+    try {
+      if (existsSync(candidate)) return candidate;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
 // 在系统文件管理器中定位文件：
 // Linux 走 freedesktop FileManager1.ShowItems（Dolphin/Nautilus 均支持），无会话服务时回退打开所在目录；
 // macOS 用 open -R；Windows 用 explorer /select。导出以便测试脚本直接驱动。
 export function revealInFileManager(rawPath) {
   return new Promise((resolveReveal) => {
-    const p = typeof rawPath === 'string' ? rawPath.trim() : '';
+    let p = typeof rawPath === 'string' ? rawPath.trim() : '';
     if (!p || !isAbsolute(p)) {
       resolveReveal([400, { ok: false, code: 'invalid-path', error: '无效的路径' }]);
       return;
@@ -2660,25 +3202,46 @@ export function openFolder(rawPath) {
   });
 }
 
-// 用系统默认应用打开文件（或文件夹）：macOS 用 open；Windows 用 explorer；
-// Linux 用 xdg-open。导出以便测试脚本直接驱动。
+// 用系统默认应用打开文件（或文件夹）：macOS 用 open；Windows 走 rundll32 的
+// FileProtocolHandler（等价 ShellExecute，启动失败时退回 cmd start）；Linux 用
+// xdg-open。导出以便测试脚本直接驱动。Windows 上不能用 explorer.exe <文件路径>：
+// 那只会在资源管理器里定位该文件（打开所在目录并选中），不会启动默认关联应用。
 export function openWithDefaultApp(rawPath) {
   return new Promise((resolveOpen) => {
-    const p = typeof rawPath === 'string' ? rawPath.trim() : '';
+    let p = typeof rawPath === 'string' ? rawPath.trim() : '';
     if (!p || !isAbsolute(p)) {
       resolveOpen([400, { ok: false, code: 'invalid-path', error: '无效的路径' }]);
       return;
     }
     if (!existsSync(p)) {
-      resolveOpen([400, { ok: false, code: 'not-found', error: '文件不存在' }]);
-      return;
+      // chip 带来的路径可能被宿主渲染弄坏（见 recoverSwallowedSeparator），先试还原
+      const recovered = recoverSwallowedSeparator(p);
+      if (!recovered) {
+        resolveOpen([400, { ok: false, code: 'not-found', error: '文件不存在' }]);
+        return;
+      }
+      p = recovered;
     }
     const done = (err) => resolveOpen(err ? [500, { ok: false, error: err.message }] : [200, { ok: true }]);
     if (process.platform === 'darwin') execFile('open', [p], { timeout: 5000 }, done);
     else if (process.platform === 'win32') {
-      const child = spawn('explorer.exe', [p], { detached: true, stdio: 'ignore' });
-      child.on('error', done);
-      child.on('close', () => done(null));
+      // rundll32 的参数不经 shell 解释，路径里的空格、%、& 等字符都安全；
+      // start 的第一个引号参数是窗口标题，兜底时必须先给空标题再给路径。
+      // 进程拉起即算成功：系统里没有该类型的关联应用时 rundll32 会弹
+      // “你要如何打开这个文件”对话框并一直挂着，不能等它退出才回话
+      let settled = false;
+      const finish = (err) => {
+        if (settled) return;
+        settled = true;
+        done(err);
+      };
+      const child = spawn('rundll32.exe', ['url.dll,FileProtocolHandler', p], { detached: true, stdio: 'ignore', windowsHide: true });
+      child.on('spawn', () => finish(null));
+      child.on('error', () => {
+        const viaCmd = spawn('cmd.exe', [`/d /s /c start "" "${p}"`], { windowsVerbatimArguments: true, detached: true, stdio: 'ignore', windowsHide: true });
+        viaCmd.on('spawn', () => finish(null));
+        viaCmd.on('error', finish);
+      });
     } else execFile('xdg-open', [p], { timeout: 5000 }, done);
   });
 }