@jesonliu/lark-claudecode-bridge 1.4.0 → 1.4.2

package/dist/memory-installer.d.ts

@@ -17,6 +17,8 @@ export interface InstallState {
     steps: InstallStep[];
 }
 export declare function getInstallState(): InstallState;
+/** 受管进程最近输出尾部（失败文案「最近输出：…」的数据源；exported 便于单测验证截断语义） */
+export declare function managedRecentOutput(maxLines?: number): string;
 /** 停受管实例（页面 stop / LCB shutdown / 重装前）：幂等，未运行为 no-op */
 export declare function stopManagedServer(): void;
 /** LCB 优雅关闭钩子注册点（index.ts shutdown 调用） */
@@ -30,7 +32,10 @@ export declare function resolveServerBin(uv: string): Promise<string | null>;
 /** LCB 记忆管理域（嵌入式数据全收敛于此：卸载即整目录删） */
 export declare const MEMORY_MANAGED_DIR: string;
 export declare const MANAGED_OV_CONF: string;
-/** 渲染 ov.conf（纯函数 exported 便于单测）。rootKey 已有则复用（重装不换 key，否则插件侧缓存/用户侧配置全部失效） */
+/** 渲染 ov.conf（纯函数 exported 便于单测）。rootKey 已有则复用（重装不换 key，否则插件侧缓存/用户侧配置全部失效）。
+ *  P2 双端点拆分：embedding.dense 与 vlm 各自独立——向量块显式配置（embeddingApiBase/embeddingApiKey）
+ *  优先，未设置回退主块（apiBase/apiKey），既有单份配置零迁移即可用；跨厂商组合（vlm=glm +
+ *  embedding=openai 系）填向量块两字段即可。 */
 export declare function renderOvConf(model: MemoryModelConfig, opts: {
     workspaceDir: string;
     port: number;
@@ -76,11 +81,19 @@ export declare function classifyClientConf(paths: {
  *  net listen 成功 ≠ 端口空闲——已有 OpenViking 服务在监听时 listen 可能误报空闲；探活有
  *  响应 = 确定被占）。候选端口同时两者皆过才采用。 */
 export declare function findFreePort(startPort?: number, tries?: number): Promise<number>;
+/** launchManagedAndWait 的结果：ready=就绪；crashed=进程已放弃（崩溃超限/被停）；二者皆否 = 慢启动 */
+export interface LaunchOutcome {
+    ready: boolean;
+    crashed: boolean;
+    detail: string;
+    port: number;
+}
 /**
  * 启动流水线（kind='start'，后台执行 + 与安装同款 stepper 轮询展示）：LCB 已接管 OpenViking，
  * 「启动」就应当是接管的启动——不只拉进程，还要把记忆链路整段拉就绪：
  * ① 检查服务与配置（bin / ov.conf 定位，缺失即 failed + 指引改走「检查修复 / 一键安装」）
- * ② 拉起并探活（受管拉起 + 最长 30s 探活；已在运行则 skipped，幂等重跑）
+ * ② 拉起并探活（受管拉起 + P0 预算 120s；预算耗尽且进程存活 → 转后台续等（UI 显示
+ *    「启动中（已等 N 秒）」），就绪自动续跑 ③；已在运行则 skipped，幂等重跑）
  * ③ 接入记忆插件（CLI 市场渠道真实安装：已登记启用 → skipped；缺失 → marketplace add/install/enable
  *  三步幂等安装，插件页可见可管理；CLI 失败回退 zip 下载自管副本）
  * 完成后无须再点「检查修复」——启动结束即完整接管态。任何一步失败即停（同安装流水线语义）。
@@ -88,6 +101,38 @@ export declare function findFreePort(startPort?: number, tries?: number): Promis
 export declare function runStartPipeline(opts: {
     configPath: string;
 }): Promise<InstallState>;
+/**
+ * 自举结果（控制台分步提示 + 配置页状态区展示共用）。ready=false 一律**不阻断 LCB**：
+ * 记忆是增强能力，桥接器本体必须在任何记忆故障下照常服务（与「记忆不可用不阻断机器人」同基调）。
+ * hint 是给用户的下一步指引——自举失败时页面/控制台直接展示「去哪手动起」，不必自己猜。
+ */
+export interface MemoryAutoStartReport {
+    at: string;
+    trigger: 'lcb-start';
+    ready: boolean;
+    /** 本次是否真的拉起了进程（false=已在跑/远程模式/未安装/失败） */
+    started: boolean;
+    detail: string;
+    hint?: string;
+}
+/** 最近一次启动自举结果（配置页状态区展示源；从未自举过则 undefined） */
+export declare function getMemoryAutoStartReport(): MemoryAutoStartReport | undefined;
+/**
+ * 启动自举：LCB 启动时确保受管 OpenViking 服务在跑（embedded + 本机回环才代管）。
+ * 设计约束（三条，缺一不可）：
+ *  ① **绝不阻断启动**：任何失败/超时都只产出 report（ready=false + hint），由调用方打印提示；
+ *  ② **有界等待**：前台最多等 foregroundMs（默认 60s），超时但进程存活 → 转后台续等
+ *     （waitSlowStart），既不空等也不杀进程；崩溃 → 立刻失败并附最近输出；
+ *  ③ **幂等**：已在跑（含外部自管服务占用同一端口且健康）直接 skipped，重启 LCB 无副作用。
+ * 不碰插件接入（stepPlugin 属安装/启动流水线语义）：插件缺失由配置页「检查修复」补齐，
+ * 启动自举只负责「服务在不在」这一件事，避免启动路径被 npm/marketplace 安装拖住。
+ */
+export declare function ensureMemoryServiceRunning(opts: {
+    endpoint: string;
+    mode?: string;
+    trigger?: 'lcb-start';
+    foregroundMs?: number;
+}): Promise<MemoryAutoStartReport>;
 /** 记忆插件定位结果：path 恒为真实可加载目录（.claude-plugin/plugin.json 在）。
  *  where 标注渠道——marketplace=CLI 安装且 enabledPlugins 启用（SDK 自动发现，无须显式引用）；
  *  explicit=config.yaml apps[].plugins 显式引用（运行时实际加载源）；managed=LCB 自管副本
@@ -165,10 +210,16 @@ export interface InstallOptions {
     model?: MemoryModelConfig;
     /** 服务 pin 版本（memory.version ?? DEFAULT_OPENVIKING_PIN） */
     pin?: string;
+    /** P1 保存即生效（「立即生效」按钮）：受管实例探活通过也强制重启——模型配置保存后
+     *  ov.conf 已重渲染，但运行中的旧进程不会热加载，必须重启才能应用新模型 */
+    forceRestart?: boolean;
 }
 /**
  * 一键安装流水线（幂等锁：running 中重复调用直接返回当前状态）。
  * 任何一步失败即停（状态留 failed + detail），页面可整链重跑——已就绪步骤自动 skipped。
+ * P0 慢启动语义：拉起步骤预算耗尽但进程存活时，流水线保持 running、转后台续等（UI 实时显示
+ * 「启动中（已等 N 秒）」），就绪后自动续跑 ⑤⑥ 并收尾——调用方（HTTP 层）此刻即返回，
+ * 前端经 /api/memory/install/status 轮询看到全过程。
  */
 export declare function runInstall(opts: InstallOptions): Promise<InstallState>;
 export {};

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, memoryEndpoint } from './memory.js';
+import { probeMemoryHealth, MEMORY_PLUGIN_NAME, memoryAccount, 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: {
@@ -310,7 +327,8 @@ function isLcbClientConfShape(v) {
  *  值：保证直连场景 identity 非空 → 插件判 trusted header 身份（dev 模式服务可用）；留空会被
  *  判成 api_key 模式而 401 */
 export function renderOvcliConf(memory) {
-    return { url: memoryEndpoint(memory), account: memory.account ?? 'lcb', user: memory.account ?? 'lcb' };
+    const account = memoryAccount(memory);
+    return { url: memoryEndpoint(memory), account, user: account };
 }
 /** 写/刷新客户端配置（幂等可重跑）。决策表：
  *  ① EXTERNAL_OV_CONF 存在 → 'skipped-external'（~/.openviking 域归用户自管，整体不碰；
@@ -401,40 +419,102 @@ export async function findFreePort(startPort = 1933, tries = 20) {
     throw new Error(`${startPort}-${startPort + tries - 1} 端口段均被占用`);
 }
 /** 拉起受管实例并探活等待就绪（安装流水线第 4 步与「启动服务」按钮共用）。
- *  探活轮询给 30s（服务冷启含依赖加载）；启动即崩/超时统一抛带指引的 Error（调用方决定展示）。 */
-async function launchManagedAndWait(bin, confPath, port, external = false) {
+ *  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, opts = {}) {
+    const budget = opts.budgetRounds ?? PROBE_BUDGET_ROUNDS;
     spawnManaged(bin, confPath, port);
-    for (let i = 0; i < 30; i++) {
+    for (let i = 1; i <= budget; 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: `探活预算（${budget} 秒）内未见就绪，服务进程仍在运行，转后台继续等待` };
+    }
+    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 };
+}
+/** 流水线统一收尾：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) {
+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 readMemoryAccount(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 下载自管副本）
  * 完成后无须再点「检查修复」——启动结束即完整接管态。任何一步失败即停（同安装流水线语义）。
@@ -479,42 +559,148 @@ 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);
         }
         // ③ 插件接入（启动完整性的另一半：插件缺失时记忆照样不工作——补齐并回写显式引用；
         //    client 传 endpoint/account：顺带落客户端接入配置 ovcli.conf，外部模式由 ensure 自守卫跳过）
-        set('plugin', 'running');
-        const pl = await stepPlugin({
-            endpoint: `http://127.0.0.1:${port ?? 1933}`,
-            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 ?? 1933}`, mode: 'embedded' }, pl.writeback.pluginPath, pl.writeback.opts);
-        }
-        installState.running = false;
-        installState.finishedAt = new Date().toISOString();
+        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;
     }
 }
+let autoStartReport;
+/** 最近一次启动自举结果（配置页状态区展示源；从未自举过则 undefined） */
+export function getMemoryAutoStartReport() {
+    return autoStartReport;
+}
+/** endpoint 是否指向本机回环（远程服务 LCB 不代管拉起） */
+function isLoopbackEndpoint(endpoint) {
+    try {
+        const h = new URL(endpoint).hostname;
+        return h === '127.0.0.1' || h === 'localhost' || h === '::1' || h === '0.0.0.0';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 启动自举：LCB 启动时确保受管 OpenViking 服务在跑（embedded + 本机回环才代管）。
+ * 设计约束（三条，缺一不可）：
+ *  ① **绝不阻断启动**：任何失败/超时都只产出 report（ready=false + hint），由调用方打印提示；
+ *  ② **有界等待**：前台最多等 foregroundMs（默认 60s），超时但进程存活 → 转后台续等
+ *     （waitSlowStart），既不空等也不杀进程；崩溃 → 立刻失败并附最近输出；
+ *  ③ **幂等**：已在跑（含外部自管服务占用同一端口且健康）直接 skipped，重启 LCB 无副作用。
+ * 不碰插件接入（stepPlugin 属安装/启动流水线语义）：插件缺失由配置页「检查修复」补齐，
+ * 启动自举只负责「服务在不在」这一件事，避免启动路径被 npm/marketplace 安装拖住。
+ */
+export async function ensureMemoryServiceRunning(opts) {
+    const trigger = opts.trigger ?? 'lcb-start';
+    const foregroundMs = opts.foregroundMs ?? 60_000;
+    const finish = (r) => {
+        autoStartReport = { at: new Date().toISOString(), trigger, ...r };
+        return autoStartReport;
+    };
+    // 远程模式：只探活不代管（拉起别人的服务是越权）
+    if ((opts.mode ?? 'embedded') !== 'embedded' || !isLoopbackEndpoint(opts.endpoint)) {
+        const h = await probeMemoryHealth(opts.endpoint, 2000);
+        return finish({
+            ready: h.healthy,
+            started: false,
+            detail: h.healthy
+                ? `远程记忆服务正常：${opts.endpoint}`
+                : `远程记忆服务不可达：${h.detail ?? '未知原因'}（LCB 不代管拉起外部服务）`,
+            ...(h.healthy ? {} : { hint: '请自行确认远程记忆服务已启动；本机地址与端口见 config.yaml 的 memory.endpoint' }),
+        });
+    }
+    // 已健康（含用户手工起的外部实例）→ 幂等跳过
+    const before = await probeMemoryHealth(opts.endpoint, 2000);
+    if (before.healthy) {
+        return finish({ ready: true, started: false, detail: `服务已在运行：${opts.endpoint}${before.authMode ? `（${before.authMode} 模式）` : ''}` });
+    }
+    // 定位二进制与配置（与启动流水线 ① 同款判定，缺任一即给「检查修复」指引）
+    const uv = await detectUv();
+    const bin = uv ? await resolveServerBin(uv) : null;
+    if (!bin) {
+        return finish({
+            ready: false, started: false,
+            detail: `服务未运行，且未检测到 OpenViking 运行时（openviking-server）：${before.detail ?? '端口无监听'}`,
+            hint: '请到配置页「记忆增强 → 检查修复」补装运行时与服务',
+        });
+    }
+    const confPath = existsSync(MANAGED_OV_CONF) ? MANAGED_OV_CONF
+        : existsSync(EXTERNAL_OV_CONF) ? EXTERNAL_OV_CONF : undefined;
+    if (!confPath) {
+        return finish({
+            ready: false, started: false,
+            detail: `服务未运行，且未找到服务配置（ov.conf）：${before.detail ?? '端口无监听'}`,
+            hint: '请到配置页「记忆增强」填好模型三件套并保存（生成 ov.conf），再点「检查修复」',
+        });
+    }
+    const external = confPath === EXTERNAL_OV_CONF;
+    const port = readConfPort(confPath);
+    // 受管实例仍在但探不通（假活）→ 先回收再拉起，避免端口占用导致新进程秒退
+    if (managed && !managed.stopped) {
+        stopManagedServer();
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    const r = await launchManagedAndWait(bin, confPath, port, external, { budgetRounds: Math.max(5, Math.ceil(foregroundMs / 1000)) });
+    if (r.ready) {
+        return finish({
+            ready: true, started: true,
+            detail: `已拉起受管记忆服务：http://127.0.0.1:${port}${external ? '（外部 ov.conf，LCB 仅代为拉起、不改写）' : ''}`,
+        });
+    }
+    if (r.crashed) {
+        return finish({
+            ready: false, started: true,
+            detail: `自动拉起失败（服务进程已退出）：${r.detail}`,
+            hint: '请到配置页「记忆增强」检查模型三件套与 ov.conf，或点「检查修复」查看完整安装流水线',
+        });
+    }
+    // 慢启动：进程活着只是还没就绪 → 后台续等，不红叉、不杀进程；后续签发由调用方重试兜上
+    void waitSlowStart(r.port, () => { });
+    return finish({
+        ready: false, started: true,
+        detail: `记忆服务正在启动（冷启动超过 ${Math.round(foregroundMs / 1000)} 秒，进程仍在运行，已转入后台等待）`,
+        hint: '通常 1-3 分钟内就绪；若长时间未起，请到配置页「记忆增强」查看受管服务输出',
+    });
+}
 function spawnManaged(bin, confPath, port) {
     const proc = spawn(bin, ['--config', confPath, '--host', '127.0.0.1', '--port', String(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;
@@ -542,10 +728,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：插件 ============
@@ -920,9 +1121,9 @@ export function writeBackConfig(configPath, wb, pluginPath, opts = {}) {
     writeAtomic(configPath, doc.toString({ lineWidth: 0 }));
 }
 // ============ 主流水线 ============
-/** 读 config.yaml 的 memory.account（懒加载；损坏配置降级 undefined → 渲染取缺省 'lcb'）。
+/** 读 config.yaml 的 memory.account（懒加载；损坏配置降级 undefined → 调用方取缺省 default）。
  *  两条流水线原本不读 config.yaml（只有 configPath），stepPlugin 落 ovcli.conf 时需要它 */
-async function memoryAccount(configPath) {
+async function readMemoryAccount(configPath) {
     try {
         const { loadConfig } = await import('./config.js');
         return loadConfig(configPath).memory?.account;
@@ -931,9 +1132,30 @@ async function memoryAccount(configPath) {
         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 readMemoryAccount(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)
@@ -1000,35 +1222,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);
-        // ⑤ 插件（client 传 endpoint/account：顺带落客户端接入配置 ovcli.conf，§6.7 第 4 步）
-        set('plugin', 'running');
-        const pl = await stepPlugin({
-            endpoint: `http://127.0.0.1:${st.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:${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;
     }
 }