@jesonliu/lark-claudecode-bridge 1.3.8 → 1.4.1

package/dist/memory-installer.js

@@ -17,7 +17,7 @@ import { access } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { parseDocument } from 'yaml';
-import { probeMemoryHealth, MEMORY_PLUGIN_NAME } from './memory.js';
+import { probeMemoryHealth, MEMORY_PLUGIN_NAME, memoryEndpoint } from './memory.js';
 /** 服务默认 pin 版本（实测环境；memory.version 可覆盖） */
 export const DEFAULT_OPENVIKING_PIN = '0.5.0';
 /** 插件源（市场清单 git-subdir 事实）：主仓库 examples 子目录 */
@@ -50,6 +50,20 @@ const START_STEPS = () => [
 let installState = { kind: 'install', running: false, steps: FRESH_STEPS() };
 export function getInstallState() { return installState; }
 let managed;
+/** 受管进程最近输出环形缓冲上限（行；P0：失败文案带真实输出而非笼统指引） */
+const MANAGED_OUTPUT_CAP = 40;
+/** stdout/stderr 行入环形缓冲（spawnManaged 的两个 data 回调共用） */
+function pushManagedOutput(line) {
+    if (!managed)
+        return;
+    managed.output.push(line.slice(0, 300));
+    if (managed.output.length > MANAGED_OUTPUT_CAP)
+        managed.output.shift();
+}
+/** 受管进程最近输出尾部（失败文案「最近输出：…」的数据源；exported 便于单测验证截断语义） */
+export function managedRecentOutput(maxLines = 12) {
+    return (managed?.output ?? []).slice(-maxLines).join('\n');
+}
 /** 停受管实例（页面 stop / LCB shutdown / 重装前）：幂等，未运行为 no-op */
 export function stopManagedServer() {
     if (!managed)
@@ -237,7 +251,10 @@ export const MANAGED_OV_CONF = join(MEMORY_MANAGED_DIR, 'ov.conf');
 function vlmProvider(p) {
     return p === 'glm' ? 'glm' : 'openai';
 }
-/** 渲染 ov.conf（纯函数 exported 便于单测）。rootKey 已有则复用（重装不换 key，否则插件侧缓存/用户侧配置全部失效） */
+/** 渲染 ov.conf（纯函数 exported 便于单测）。rootKey 已有则复用（重装不换 key，否则插件侧缓存/用户侧配置全部失效）。
+ *  P2 双端点拆分：embedding.dense 与 vlm 各自独立——向量块显式配置（embeddingApiBase/embeddingApiKey）
+ *  优先，未设置回退主块（apiBase/apiKey），既有单份配置零迁移即可用；跨厂商组合（vlm=glm +
+ *  embedding=openai 系）填向量块两字段即可。 */
 export function renderOvConf(model, opts) {
     const rootApiKey = opts.rootApiKey ?? randomBytes(24).toString('hex');
     const conf = {
@@ -246,8 +263,8 @@ export function renderOvConf(model, opts) {
             dense: {
                 provider: 'openai',
                 model: model.embeddingModel ?? '',
-                api_key: model.apiKey ?? '',
-                api_base: model.apiBase ?? '',
+                api_key: model.embeddingApiKey ?? model.apiKey ?? '',
+                api_base: model.embeddingApiBase ?? model.apiBase ?? '',
             },
         },
         vlm: {
@@ -288,6 +305,97 @@ function readConfPort(confPath) {
         return 1933;
     }
 }
+// ============ 客户端接入配置（ovcli.conf，§6.7 第 4 步落地） ============
+// 插件 isPluginEnabled() 的第 3 优先级判据 + 连接信息兜底层（env > ovcli.conf > ov.conf，
+// 插件 scripts/shared/credentials.mjs 实测口径）。LCB 只写「无 key 骨架」：key 永远走 env
+// 下发（§6.6），绝不落盘到 ~/.openviking/ 域。全新机器一键安装后即启用插件，用户零手工。
+/** 客户端配置文件位置（与 EXTERNAL_OV_CONF 同款 home 解析口径） */
+export const OVCLI_CONF = join(String(process.env.USERPROFILE ?? process.env.HOME ?? ''), '.openviking', 'ovcli.conf');
+/** LCB 骨架形状签名：恰好 {url, account, user} 三个 string 键。这是「文件归 LCB 所有」的判定
+ *  依据——插件 setup 向导 / `ov login` 恒写 api_key（含 api_key 的文件永不与本形状同形），
+ *  且形状判定与端点/账号现值解耦：重装 findFreePort 换端口后旧骨架仍被识别为 LCB 所有
+ *  （这是 ensure 能刷新、cleanup 能删中的关键；勿改成内容比对，否则端口漂移后清理永不触发） */
+function isLcbClientConfShape(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const o = v;
+    const keys = Object.keys(o);
+    return keys.length === 3 && ['url', 'account', 'user'].every((k) => typeof o[k] === 'string')
+        && keys.every((k) => ['url', 'account', 'user'].includes(k));
+}
+/** 渲染 ovcli.conf（纯函数 exported 便于单测）。刻意不含 api_key / plugin 段；user 取 account
+ *  值：保证直连场景 identity 非空 → 插件判 trusted header 身份（dev 模式服务可用）；留空会被
+ *  判成 api_key 模式而 401 */
+export function renderOvcliConf(memory) {
+    return { url: memoryEndpoint(memory), account: memory.account ?? 'lcb', user: memory.account ?? 'lcb' };
+}
+/** 写/刷新客户端配置（幂等可重跑）。决策表：
+ *  ① EXTERNAL_OV_CONF 存在 → 'skipped-external'（~/.openviking 域归用户自管，整体不碰；
+ *     外部 ov.conf 本身就满足插件启用判定，LCB 会话另有 env 通道兜底）
+ *  ② 文件缺失 → mkdir recursive + writeAtomic(渲染值) → 'written'
+ *  ③ 文件存在且为 LCB 骨架：内容与渲染值全等 → 'kept'（幂等零写）；否则重写 → 'updated'
+ *     （端口漂移/账号改名/remote↔embedded 切换后的自愈路径）
+ *  ④ 其余（含 api_key 的用户手配、plugin 段、损坏 JSON）→ 'skipped-foreign'（尊重不动）
+ *  dirOverride 供单测注入临时目录（ov.conf/ovcli.conf 一并重定向，摆脱模块常量的 home 依赖） */
+export function ensureClientCliConf(memory, dirOverride) {
+    const ovConf = dirOverride ? join(dirOverride, 'ov.conf') : EXTERNAL_OV_CONF;
+    const ovcli = dirOverride ? join(dirOverride, 'ovcli.conf') : OVCLI_CONF;
+    if (existsSync(ovConf))
+        return 'skipped-external';
+    const next = renderOvcliConf(memory);
+    let cur;
+    try {
+        cur = JSON.parse(readFileSync(ovcli, 'utf8'));
+    }
+    catch {
+        cur = undefined;
+    }
+    if (cur === undefined && !existsSync(ovcli)) {
+        writeAtomic(ovcli, JSON.stringify(next, null, 2));
+        return 'written';
+    }
+    if (isLcbClientConfShape(cur)) {
+        if (JSON.stringify(cur) === JSON.stringify(next))
+            return 'kept';
+        writeAtomic(ovcli, JSON.stringify(next, null, 2));
+        return 'updated';
+    }
+    return 'skipped-foreign';
+}
+/** 关记忆的对称清理：仅当解析后命中 LCB 骨架形状才删（返回是否删除）。刻意不做内容匹配
+ *  （见 isLcbClientConfShape 注释）；损坏/手配文件一律保留 */
+export function cleanupClientCliConf(dirOverride) {
+    const ovcli = dirOverride ? join(dirOverride, 'ovcli.conf') : OVCLI_CONF;
+    let cur;
+    try {
+        cur = JSON.parse(readFileSync(ovcli, 'utf8'));
+    }
+    catch {
+        return false;
+    }
+    if (!isLcbClientConfShape(cur))
+        return false;
+    rmSync(ovcli, { force: true });
+    return true;
+}
+/** 状态页分类（exported 便于 memory-api 与单测复用；路径入参可注入摆脱 home 依赖）。
+ *  external 优先：外部 ov.conf 存在即整个 ~/.openviking 域归用户（与 ensure 的守卫口径一致） */
+export function classifyClientConf(paths) {
+    if (existsSync(paths.ovConf))
+        return { state: 'external', path: paths.ovConf };
+    let cur;
+    try {
+        cur = JSON.parse(readFileSync(paths.ovcli, 'utf8'));
+    }
+    catch {
+        cur = undefined;
+    }
+    if (isLcbClientConfShape(cur))
+        return { state: 'lcb-managed', path: paths.ovcli };
+    if (existsSync(paths.ovcli))
+        return { state: 'user-managed', path: paths.ovcli };
+    return { state: 'missing', path: paths.ovcli };
+}
 // ============ 步骤 4：受管拉起 ============
 /** 找空闲端口：从 1933 起「net 试探 + HTTP 探活」双重确认（Windows SO_REUSEADDR 允许抢绑，
  *  net listen 成功 ≠ 端口空闲——已有 OpenViking 服务在监听时 listen 可能误报空闲；探活有
@@ -310,40 +418,101 @@ export async function findFreePort(startPort = 1933, tries = 20) {
     throw new Error(`${startPort}-${startPort + tries - 1} 端口段均被占用`);
 }
 /** 拉起受管实例并探活等待就绪（安装流水线第 4 步与「启动服务」按钮共用）。
- *  探活轮询给 30s（服务冷启含依赖加载）；启动即崩/超时统一抛带指引的 Error（调用方决定展示）。 */
+ *  P0 启动可靠性（记忆系统最终方案 v1.1 §五）：
+ *  - 探活预算 30 → 120 轮（首装冷启动最坏路径：OS 缓存全冷 + Defender 实时扫描 + 重依赖加载，
+ *    常超 30s——旧预算 + 超时即杀是「第一次必败」竞态的根因）；
+ *  - 超时不杀进程：预算耗尽且进程仍活 → 返回 { ready:false, crashed:false }，调用方转后台续等
+ *    （waitSlowStart），UI 显示「启动中（已等 N 秒）」而非红叉，就绪后自动续跑后续步骤；
+ *  - 进程退出（崩溃 3 次放弃 / 被停止）→ { ready:false, crashed:true }，文案带最近真实输出。 */
+const PROBE_BUDGET_ROUNDS = 120;
+/** 慢启动后台续等窗口（预算耗尽且进程存活时；10 分钟仍未见就绪才放弃并停止进程，防僵尸占端口） */
+const SLOW_START_MAX_MS = 600_000;
 async function launchManagedAndWait(bin, confPath, port, external = false) {
     spawnManaged(bin, confPath, port);
-    for (let i = 0; i < 30; i++) {
+    for (let i = 1; i <= PROBE_BUDGET_ROUNDS; i++) {
         await new Promise((r) => setTimeout(r, 1000));
         const h = await probeMemoryHealth(`http://127.0.0.1:${port}`, 1500);
         if (h.healthy) {
-            return { detail: `服务已就绪：http://127.0.0.1:${port}${external ? '（外部配置 ~/.openviking/ov.conf，LCB 仅代为拉起、不改写）' : ''}`, port };
+            return {
+                ready: true, crashed: false, port,
+                detail: `服务已就绪：http://127.0.0.1:${port}${external ? '（外部配置 ~/.openviking/ov.conf，LCB 仅代为拉起、不改写）' : ''}${i > 15 ? `（冷启动 ${i} 秒）` : ''}`,
+            };
+        }
+        if (!managed) {
+            // 崩溃自动重启 3 次放弃 / 被主动停止：managed 已清。文案带最近输出（stdout+stderr 合流），
+            // 不再误导为「模型配置问题」——真实原因看输出（方案 §五-P0）
+            return { ready: false, crashed: true, port, detail: `服务进程已退出（等待 ${i} 秒）。最近输出：\n${managedRecentOutput() || '（无输出）'}` };
         }
+    }
+    if (managed) {
+        // 预算耗尽但进程存活：绝不杀进程（调用方转后台续等）
+        return { ready: false, crashed: false, port, detail: `探活预算（${PROBE_BUDGET_ROUNDS} 秒）内未见就绪，服务进程仍在运行，转后台继续等待` };
+    }
+    return { ready: false, crashed: true, port, detail: `服务进程在等待期间退出。最近输出：\n${managedRecentOutput() || '（无输出）'}` };
+}
+/** P0 慢启动后台续等：预算耗尽但进程存活时，后台每 2s 探活；onTick 上报累计已等秒数（UI 实时
+ *  「启动中（已等 N 秒）」）。就绪 → ok；进程放弃（崩溃 3 次/被停止）或窗口耗尽 → !ok——窗口
+ *  耗尽时停止未就绪进程（防僵尸占端口），文案如实说明并附最近输出。 */
+async function waitSlowStart(port, onTick) {
+    const begin = Date.now();
+    while (Date.now() - begin < SLOW_START_MAX_MS) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const elapsed = PROBE_BUDGET_ROUNDS + Math.round((Date.now() - begin) / 1000);
+        const h = await probeMemoryHealth(`http://127.0.0.1:${port}`, 1500);
+        if (h.healthy)
+            return { ok: true, detail: `服务已就绪（累计等待 ${elapsed} 秒）：http://127.0.0.1:${port}` };
         if (!managed)
-            break; // 启动即崩（config 错等）
+            return { ok: false, detail: `服务进程已退出（累计等待 ${elapsed} 秒）。最近输出：\n${managedRecentOutput() || '（无输出）'}` };
+        onTick(elapsed);
     }
-    const hint = `服务启动后探活失败（127.0.0.1:${port}）——请检查 ov.conf 的模型配置（api_base/key/模型名）${external ? '，或改用「一键安装」生成 LCB 受管配置' : ''}`;
+    const detail = `服务启动超时（已等 ${PROBE_BUDGET_ROUNDS + Math.round(SLOW_START_MAX_MS / 1000)} 秒仍未见就绪），已停止该进程。最近输出：\n${managedRecentOutput() || '（无输出）'}`;
     stopManagedServer();
-    throw new Error(hint);
+    return { ok: false, detail };
 }
-async function stepStart(bin, confPath) {
+/** 流水线统一收尾：err 时把 running 步骤置 failed，无论成败都关闭 running 态（后台续跑路径共用） */
+function finalizeInstallState(steps, err) {
+    const failed = steps.find((x) => x.status === 'running');
+    if (err && failed) {
+        failed.status = 'failed';
+        failed.detail = err instanceof Error ? err.message : String(err);
+    }
+    installState.running = false;
+    installState.finishedAt = new Date().toISOString();
+}
+async function stepStart(bin, confPath, opts = {}) {
     const port = readConfPort(confPath);
-    // 已有受管实例：探活通即跳过（幂等重跑）
+    // 已有受管实例：探活通即跳过（幂等重跑）；forceRestart（P1 保存即生效）则重启以应用新配置
     if (managed && !managed.stopped) {
         const h = await probeMemoryHealth(`http://127.0.0.1:${managed.port}`, 2000);
-        if (h.healthy)
-            return { skipped: true, detail: `受管实例已在运行（127.0.0.1:${managed.port}）`, port: managed.port };
+        if (h.healthy && !opts.forceRestart) {
+            return { skipped: true, ready: true, crashed: false, detail: `受管实例已在运行（127.0.0.1:${managed.port}）`, port: managed.port };
+        }
         stopManagedServer();
+        await new Promise((r) => setTimeout(r, 1000)); // 端口释放窗口（TIME_WAIT）
     }
     const r = await launchManagedAndWait(bin, confPath, port);
-    return { skipped: false, detail: r.detail, port: r.port };
+    return { ...r, skipped: false };
 }
 // ============ 单独启动（「启动服务」按钮 → LCB 接管式启动流水线） ============
+/** 启动流水线尾部（③插件接入 + 回写）：正常路径与慢启动后台续跑共用 */
+async function finishStartTail(opts, port, external, set) {
+    set('plugin', 'running');
+    const pl = await stepPlugin({
+        endpoint: `http://127.0.0.1:${port}`,
+        account: await memoryAccount(opts.configPath),
+    });
+    set('plugin', pl.skipped ? 'skipped' : 'done', pl.detail);
+    if (pl.writeback) {
+        // 插件新装/调和才回写：受管场景顺带对齐 endpoint/mode；外部场景不动用户配置（只补插件引用）
+        writeBackConfig(opts.configPath, external ? {} : { endpoint: `http://127.0.0.1:${port}`, mode: 'embedded' }, pl.writeback.pluginPath, pl.writeback.opts);
+    }
+}
 /**
  * 启动流水线（kind='start'，后台执行 + 与安装同款 stepper 轮询展示）：LCB 已接管 OpenViking，
  * 「启动」就应当是接管的启动——不只拉进程，还要把记忆链路整段拉就绪：
  * ① 检查服务与配置（bin / ov.conf 定位，缺失即 failed + 指引改走「检查修复 / 一键安装」）
- * ② 拉起并探活（受管拉起 + 最长 30s 探活；已在运行则 skipped，幂等重跑）
+ * ② 拉起并探活（受管拉起 + P0 预算 120s；预算耗尽且进程存活 → 转后台续等（UI 显示
+ *    「启动中（已等 N 秒）」），就绪自动续跑 ③；已在运行则 skipped，幂等重跑）
  * ③ 接入记忆插件（CLI 市场渠道真实安装：已登记启用 → skipped；缺失 → marketplace add/install/enable
  *  三步幂等安装，插件页可见可管理；CLI 失败回退 zip 下载自管副本）
  * 完成后无须再点「检查修复」——启动结束即完整接管态。任何一步失败即停（同安装流水线语义）。
@@ -388,29 +557,42 @@ export async function runStartPipeline(opts) {
         }
         if (needLaunch) {
             const r = await launchManagedAndWait(bin, confPath, readConfPort(confPath), external);
+            if (!r.ready) {
+                if (r.crashed) {
+                    set('launch', 'failed', r.detail);
+                    throw new Error(r.detail);
+                }
+                // P0 慢启动：进程存活 → 不杀不红叉，保持流水线 running 转后台续等，就绪自动续跑 ③
+                set('launch', 'running', `启动中（已等 ${PROBE_BUDGET_ROUNDS} 秒）…`);
+                void (async () => {
+                    const slow = await waitSlowStart(r.port, (s) => set('launch', 'running', `启动中（已等 ${s} 秒）…`));
+                    if (!slow.ok) {
+                        set('launch', 'failed', slow.detail);
+                        finalizeInstallState(steps);
+                        return;
+                    }
+                    set('launch', 'done', slow.detail);
+                    try {
+                        await finishStartTail(opts, r.port, external, set);
+                        finalizeInstallState(steps);
+                    }
+                    catch (e) {
+                        finalizeInstallState(steps, e);
+                    }
+                })();
+                return installState; // running 保持 true：前端持续轮询看实时秒数
+            }
             port = r.port;
             set('launch', 'done', r.detail);
         }
-        // ③ 插件接入（启动完整性的另一半：插件缺失时记忆照样不工作——补齐并回写显式引用）
-        set('plugin', 'running');
-        const pl = await stepPlugin();
-        set('plugin', pl.skipped ? 'skipped' : 'done', pl.detail);
-        if (pl.writeback) {
-            // 插件新装/调和才回写：受管场景顺带对齐 endpoint/mode；外部场景不动用户配置（只补插件引用）
-            writeBackConfig(opts.configPath, external ? {} : { endpoint: `http://127.0.0.1:${port ?? 1933}`, mode: 'embedded' }, pl.writeback.pluginPath, pl.writeback.opts);
-        }
-        installState.running = false;
-        installState.finishedAt = new Date().toISOString();
+        // ③ 插件接入（启动完整性的另一半：插件缺失时记忆照样不工作——补齐并回写显式引用；
+        //    client 传 endpoint/account：顺带落客户端接入配置 ovcli.conf，外部模式由 ensure 自守卫跳过）
+        await finishStartTail(opts, port ?? 1933, external, set);
+        finalizeInstallState(steps);
         return installState;
     }
     catch (e) {
-        installState.running = false;
-        installState.finishedAt = new Date().toISOString();
-        const failed = steps.find((x) => x.status === 'running');
-        if (failed) {
-            failed.status = 'failed';
-            failed.detail = e instanceof Error ? e.message : String(e);
-        }
+        finalizeInstallState(steps, e);
         return installState;
     }
 }
@@ -419,7 +601,7 @@ function spawnManaged(bin, confPath, port) {
         windowsHide: true,
         stdio: ['ignore', 'pipe', 'pipe'],
     });
-    managed = { proc, port, restarts: 0, stopped: false, confPath, startedAt: new Date().toISOString() };
+    managed = { proc, port, restarts: 0, stopped: false, confPath, startedAt: new Date().toISOString(), output: [] };
     proc.on('exit', () => {
         if (!managed || managed.proc !== proc)
             return;
@@ -447,10 +629,25 @@ function spawnManaged(bin, confPath, port) {
             managed = undefined;
         }
     });
+    // P0：stdout 原先只 pipe 不消费——缓冲写满会阻塞子进程且信息全丢；现转发控制台并入环形缓冲
+    //（stderr 同款），失败文案「最近输出：…」即来源于此
+    proc.stdout?.on('data', (d) => {
+        for (const raw of String(d).split(/\r?\n/)) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            pushManagedOutput(line);
+            console.log('[memory-server]', line.slice(0, 300));
+        }
+    });
     proc.stderr?.on('data', (d) => {
-        const line = String(d).trim();
-        if (line)
+        for (const raw of String(d).split(/\r?\n/)) {
+            const line = raw.trim();
+            if (!line)
+                continue;
+            pushManagedOutput(line);
             console.warn('[memory-server]', line.slice(0, 300));
+        }
     });
 }
 // ============ 步骤 5：插件 ============
@@ -639,8 +836,22 @@ async function cliInstallViaMarketplace(claudeDir, dirs) {
         : { detail: `安装动作已完成但未能自动发现 ${MARKETPLACE_KEY}（installed_plugins/enabledPlugins 未生效，请反馈）` };
 }
 /** 接入记忆插件（安装流水线第 5 步/启动流水线第 3 步共用；exported 便于运维脚本与单测直调）：
- *  ① CLI marketplace 双登记命中 → skipped；② CLI 真实安装（幂等）；③ zip 兜底 + CLI 同构登记 */
-export async function stepPlugin() {
+ *  ① CLI marketplace 双登记命中 → skipped；② CLI 真实安装（幂等）；③ zip 兜底 + CLI 同构登记。
+ *  client 传入时（endpoint/account）同时落客户端接入配置 ovcli.conf（§6.7 第 4 步：插件启用判定
+ *  的文件兜底层；写入失败只 warn 不阻塞插件接入——LCB 会话另有 env 通道兜底） */
+export async function stepPlugin(client) {
+    // 客户端配置先落（三个 return 分支都要携带：①分支是高频提前 return——「已装但无文件」的
+    // 存量机器最常见形态，放函数体后段会漏掉）
+    let clientConf;
+    if (client) {
+        try {
+            clientConf = ensureClientCliConf(client);
+        }
+        catch (e) {
+            console.warn('[memory-installer] ovcli.conf 写入失败（不阻塞插件接入）：', e instanceof Error ? e.message : e);
+        }
+    }
+    const detailSuffix = clientConf ? `；客户端配置 ${clientConf}` : '';
     const { loadConfig } = await import('./config.js');
     const { DEFAULT_CLAUDE_DIR, resolveClaudeDir } = await import('./claude-config.js');
     let claudeDir = DEFAULT_CLAUDE_DIR;
@@ -659,7 +870,8 @@ export async function stepPlugin() {
             if (hit)
                 return {
                     skipped: true,
-                    detail: `已安装（CLI marketplace 已启用）：${hit.path}`,
+                    detail: `已安装（CLI marketplace 已启用）：${hit.path}${detailSuffix}`,
+                    clientConf,
                     writeback: {
                         pluginPath: hit.path,
                         opts: { reconcileOnly: true, artifactRoots: [...dirs.map((x) => join(x, 'plugins', 'cache')), MANAGED_PLUGIN_ROOT] },
@@ -675,7 +887,8 @@ export async function stepPlugin() {
     if (cli.installPath) {
         return {
             skipped: false,
-            detail: `${cli.detail}（插件页可见，可启停/更新）`,
+            detail: `${cli.detail}（插件页可见，可启停/更新）${detailSuffix}`,
+            clientConf,
             writeback: {
                 pluginPath: cli.installPath,
                 opts: { reconcileOnly: true, artifactRoots: [...dirs.map((d) => join(d, 'plugins', 'cache')), MANAGED_PLUGIN_ROOT] },
@@ -721,7 +934,8 @@ export async function stepPlugin() {
         invalidatePluginCache(claudeDir);
         return {
             skipped: false,
-            detail: `已安装 v${version}（CLI 同构登记）→ ${dest}（插件页可见，可启停/更新）`,
+            detail: `已安装 v${version}（CLI 同构登记）→ ${dest}（插件页可见，可启停/更新）${detailSuffix}`,
+            clientConf,
             writeback: {
                 pluginPath: dest,
                 opts: { reconcileOnly: true, artifactRoots: [...dirs.map((d) => join(d, 'plugins', 'cache')), MANAGED_PLUGIN_ROOT] },
@@ -807,9 +1021,42 @@ export function writeBackConfig(configPath, wb, pluginPath, opts = {}) {
         return;
     writeAtomic(configPath, doc.toString({ lineWidth: 0 }));
 }
+// ============ 主流水线 ============
+/** 读 config.yaml 的 memory.account（懒加载；损坏配置降级 undefined → 渲染取缺省 'lcb'）。
+ *  两条流水线原本不读 config.yaml（只有 configPath），stepPlugin 落 ovcli.conf 时需要它 */
+async function memoryAccount(configPath) {
+    try {
+        const { loadConfig } = await import('./config.js');
+        return loadConfig(configPath).memory?.account;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 安装流水线尾部（⑤插件接入 + ⑥回写 config.yaml）：正常路径与慢启动后台续跑共用 */
+async function finishInstallTail(opts, port, firstInstallKey, set) {
+    // ⑤ 插件（client 传 endpoint/account：顺带落客户端接入配置 ovcli.conf，§6.7 第 4 步）
+    set('plugin', 'running');
+    const pl = await stepPlugin({
+        endpoint: `http://127.0.0.1:${port}`,
+        account: await memoryAccount(opts.configPath),
+    });
+    set('plugin', pl.skipped ? 'skipped' : 'done', pl.detail);
+    // ⑥ 回写 config.yaml——全链成功才落盘（半成品不污染用户配置）：endpoint / mode=embedded /
+    // 首装生成的 root_api_key 回写 memory.api_key（复用已有 key 不写）+ 插件引用回写（CLI 渠道为
+    // 调和模式、zip 兜底为补齐模式，选项由 stepPlugin 携带）
+    writeBackConfig(opts.configPath, {
+        endpoint: `http://127.0.0.1:${port}`,
+        mode: 'embedded',
+        ...(firstInstallKey ? { apiKey: firstInstallKey } : {}),
+    }, pl.writeback?.pluginPath, pl.writeback?.opts);
+}
 /**
  * 一键安装流水线（幂等锁：running 中重复调用直接返回当前状态）。
  * 任何一步失败即停（状态留 failed + detail），页面可整链重跑——已就绪步骤自动 skipped。
+ * P0 慢启动语义：拉起步骤预算耗尽但进程存活时，流水线保持 running、转后台续等（UI 实时显示
+ * 「启动中（已等 N 秒）」），就绪后自动续跑 ⑤⑥ 并收尾——调用方（HTTP 层）此刻即返回，
+ * 前端经 /api/memory/install/status 轮询看到全过程。
  */
 export async function runInstall(opts) {
     if (installState.running)
@@ -876,32 +1123,40 @@ export async function runInstall(opts) {
         }
         // ④ 拉起
         set('start', 'running');
-        const st = await stepStart(svc.bin, MANAGED_OV_CONF);
+        const st = await stepStart(svc.bin, MANAGED_OV_CONF, { forceRestart: opts.forceRestart });
+        if (!st.ready) {
+            if (st.crashed) {
+                set('start', 'failed', st.detail);
+                throw new Error(st.detail);
+            }
+            // P0 慢启动：进程存活 → 不杀不红叉，保持流水线 running 转后台续等，就绪自动续跑 ⑤⑥
+            set('start', 'running', `启动中（已等 ${PROBE_BUDGET_ROUNDS} 秒）…`);
+            void (async () => {
+                const slow = await waitSlowStart(st.port, (s) => set('start', 'running', `启动中（已等 ${s} 秒）…`));
+                if (!slow.ok) {
+                    set('start', 'failed', slow.detail);
+                    finalizeInstallState(steps);
+                    return;
+                }
+                set('start', 'done', slow.detail);
+                try {
+                    await finishInstallTail(opts, st.port, firstInstallKey, set);
+                    finalizeInstallState(steps);
+                }
+                catch (e) {
+                    finalizeInstallState(steps, e);
+                }
+            })();
+            return installState; // running 保持 true：前端持续轮询看实时秒数
+        }
         set('start', st.skipped ? 'skipped' : 'done', st.detail);
-        // ⑤ 插件
-        set('plugin', 'running');
-        const pl = await stepPlugin();
-        set('plugin', pl.skipped ? 'skipped' : 'done', pl.detail);
-        // ⑥ 回写 config.yaml——全链成功才落盘（半成品不污染用户配置）：endpoint / mode=embedded /
-        // 首装生成的 root_api_key 回写 memory.api_key（复用已有 key 不写）+ 插件引用回写（CLI 渠道为
-        // 调和模式、zip 兜底为补齐模式，选项由 stepPlugin 携带）
-        writeBackConfig(opts.configPath, {
-            endpoint: `http://127.0.0.1:${st.port}`,
-            mode: 'embedded',
-            ...(firstInstallKey ? { apiKey: firstInstallKey } : {}),
-        }, pl.writeback?.pluginPath, pl.writeback?.opts);
-        installState.running = false;
-        installState.finishedAt = new Date().toISOString();
+        // ⑤⑥ 插件接入 + 回写（尾部提取：与慢启动后台续跑共用）
+        await finishInstallTail(opts, st.port, firstInstallKey, set);
+        finalizeInstallState(steps);
         return installState;
     }
     catch (e) {
-        installState.running = false;
-        installState.finishedAt = new Date().toISOString();
-        const failed = steps.find((x) => x.status === 'running');
-        if (failed) {
-            failed.status = 'failed';
-            failed.detail = e instanceof Error ? e.message : String(e);
-        }
+        finalizeInstallState(steps, e);
         return installState;
     }
 }