feat: v0.8.0 流语义补全 · 会话可靠 · 恢复力 — finish_reason 全链路贯通根治"思考中停止" · 2445 用例全量回归

P0 会话可靠性收口（根治"模型思考着会话就停止"）：
- P0-1 finish_reason 全链路贯通：DONE 事件与 IterationStep 新增 finishReason，OpenAI 共享 SSE / Anthropic message_delta.stop_reason / Ollama done_reason 三路采集，TRACE 层弃用硬编码 'stop' 记录真值
- P0-2 空响应守卫 + 降级重试：零产出流→可重试错误走退避；思考耗尽输出预算（reasoning-only + length）→自动关闭思考降级重试一次；仍失败→OUTPUT_LENGTH_EXCEEDED 结构化错误 + 故障转移；附带根治 abort 恰逢零工具调用轮被 COMPLETED 抢占的真实缺陷
- P0-3 思考×能力×预算三对齐：DeepSeek/MiMo/Agnes/Ollama 四家 supportsThinking=false 强制不发思考参数；小输出预算告警；设置页联动提示
- P0-4 渲染层可见性：截断/空完成/友好错误三类提示，i18n 全部出层
- P0-5 回归四件套：reasoning-only 终止判定、集成级空闲超时、504 引擎重试归类、思考中 abort→USER_INTERRUPT、P4-2 强制收尾路径

FEAT-1：LLM 设置新增「最大输出上限」——Provider 支持矩阵显隐 + 模型上限钳制提示 + 超限保存警告 + llm.maxTokens 热生效

P1 修复面收口：
- 渲染层三缺陷根治：后台会话回放缓冲（2000 条/4MB 有界 + agent:getReplayState + 事件总线）+ abort 双层自愈 + sendMessage 收尾兜底 + 中断卡片清扫
- 工具 abort 信号全覆盖：web_search/web_fetch/http_request/code_search/git 系列/delegate_task 全部接入引擎中断；web_search 时间预算收敛（720s→≤240s）；移除伪造 ToolExecutionContext 与死代码
- 安全：本地 Pinned CONNECT 代理根治浏览器通道 DNS rebinding（校验期 IP pinning，可注入 resolver 表测）；配置 URL 域名解析深校验（DeepCheckSoftFailure 软失败）；SSE 空 error 帧防御修复；Ollama generate/embed AbortSignal.any 合并
- 缺陷清单：UTF-16 BOM 读取、tmp 同毫秒碰撞（nanoid 后缀）、code_search JS 回退参数对称（case_sensitive/前后文独立）、list_directory include_node_modules、崩溃自愈退避（60s 窗 ≥3 次停 reload）、MemoryViewer/Sidebar i18n 收口

P2 能力演进：
- 会话回收站：SCHEMA_VERSION 3 + 迁移 10（deleted_at，存在性守卫），软删除/恢复/彻底删除/30 天自动清理（启动+24h），searchMessages 聚合剔除，Sidebar 回收站面板
- 会话回放播放器：sessions:listRecordings/readRecording（白名单+目录边界+20MB 上限），SessionReplayPlayer 时间轴/步进/变速，Trace 面板入口
- electron-updater 自动更新：双轨（手动 feed 比对保留），生产环境启动静默检查 + update:status 广播 + app:updateInstall + LogsSettings UpdatePanel + builder publish 配置
- @ 文件提及：workspace.listFiles/readFileClip（边界/512KB/NUL 拒绝/MEMORY.md 保护），ChatInput Fuse 联想+键盘导航+附件管线注入
- MCP Resources/Prompts 发现：可选能力 try/catch 降级，mcp:listServerContents，MCPSettings 展开视图
- 文档对齐：内部 API 标准 HTML（Adapter 清单补 MiMo/已实现注记/STREAM_RESET/DONE.finishReason/ repetition_truncation 映射）；README v0.8.0 亮点表

P3 测试基建：
- 新增 4 个测试文件：engine-stream-contract（6）、engine-stream-reliability（4：集成空闲超时/504 重试/思考中 abort/P4-2 强制收尾）、thinking-capability-gate（7）、pinned-proxy（9，含深校验 5）、session-trash（5，DB 域）、use-agent-stream hook 级（5）、agent.test 回放缓冲（2）
- 契约更新：orchestrator 被中断 SubAgent success=false（abort 优先级修复语义）、SSE 空 error 帧、UTF-16 正常读取、DeepSeek 未配置思考显式 disabled、迁移矩阵 v2→3
- 弱断言根治：registry WEBP 单向断言、hooks-contracts 自比恒真、memory 空 token 补强

全量验证：typecheck 0 错误 / lint 0 问题 / 系统 Node 2144 通过（301 DB 用例按 ABI 跳过）/ Electron ABI 2445/2445 全量通过 0 跳过

electron/ipc/__tests__/agent.test.ts

@@ -1054,3 +1054,73 @@ describe('llm:ollamaPull / ollamaPullCancel — 模型下载', () => {
     expect(result.success).toBe(false);
   });
 });
+
+// ===== v0.8.0 P1-1a: 后台会话回放缓冲 =====
+
+describe('agent:getReplayState — v0.8.0 P1-1a 后台会话回放缓冲', () => {
+  it('streamEvent + stateChange 按序入缓冲，runId 记录，INIT 清空上一 run', async () => {
+    const { ctx } = makeCtx();
+    registerAgentHandlers(ctx);
+    const em = ctx.agentEngineManager as unknown as EventEmitter;
+
+    em.emit('streamEvent', {
+      type: 'text_delta',
+      sessionId: 'sess_1',
+      seq: 0,
+      timestamp: Date.now(),
+      delta: 'a',
+    });
+    em.emit('stateChange', {
+      sessionId: 'sess_1',
+      state: 'THINKING',
+      iteration: 1,
+      runId: 'run_x',
+    });
+    em.emit('streamEvent', {
+      type: 'text_delta',
+      sessionId: 'sess_1',
+      seq: 1,
+      timestamp: Date.now(),
+      delta: 'b',
+      runId: 'run_x',
+    });
+
+    const r = (await getHandler('agent:getReplayState')(null, 'sess_1')) as {
+      success: boolean;
+      data: {
+        isRunning: boolean;
+        runId: string | null;
+        truncated: boolean;
+        events: Array<{ channel: string }>;
+      };
+    };
+    expect(r.success).toBe(true);
+    expect(r.data.events.length).toBe(3);
+    expect(r.data.runId).toBe('run_x');
+    expect(r.data.events.map((e) => e.channel)).toEqual([
+      'streamEvent',
+      'stateChange',
+      'streamEvent',
+    ]);
+
+    // 新 run INIT → 上一 run 缓冲作废
+    em.emit('stateChange', {
+      sessionId: 'sess_1',
+      state: 'INIT',
+      iteration: 0,
+      runId: 'run_y',
+    });
+    const r2 = (await getHandler('agent:getReplayState')(null, 'sess_1')) as {
+      success: boolean;
+      data: { events: unknown[] };
+    };
+    expect(r2.data.events.length).toBe(0);
+  });
+
+  it('无效 sessionId → 明确失败', async () => {
+    const { ctx } = makeCtx();
+    registerAgentHandlers(ctx);
+    const r = (await getHandler('agent:getReplayState')(null, '')) as { success: boolean };
+    expect(r.success).toBe(false);
+  });
+});

electron/ipc/agent.ts

@@ -59,8 +59,43 @@ interface IterationTrace {
   text: string;
   usage?: { input: number; output: number; total: number };
   responded: boolean; // 本轮 llm_response 是否已记录（PARSING 与下一轮 THINKING 去重）
+  /**
+   * v0.8.0 P0-1: 本轮 Provider 原生停止原因（DONE 事件携带的 finishReason）。
+   * v0.7.4 及之前 recordLLMResponse 硬编码 'stop'，length 截断在 TRACE 文件中
+   * 不可归因；现记录真值，缺省回退 'stop'。
+   */
+  finishReason?: string;
 }
 
+/**
+ * v0.8.0 P1-1a: 单会话的流式回放缓冲 —— 渲染层切走会话期间，事件管道仍照常
+ * 投递（按会话隔离被渲染层准入拒绝），此缓冲按序保存 streamEvent + stateChange
+ * 双通道事件；用户切回会话时经 agent:getReplayState 拉取并灌入渲染层事件总线，
+ * 实现"后台会话运行内容不丢失"。
+ *
+ * 有界设计：单会话上限 MAX_REPLAY_EVENTS 条 / MAX_REPLAY_BYTES 字节，溢出丢弃
+ * 最旧并置 truncated 标记；TERMINATED 后保留（供"完成后切回"看到最终内容），
+ * 下一次 run 启动（INIT stateChange）时清空重建。
+ */
+interface ReplayEntry {
+  channel: 'streamEvent' | 'stateChange';
+  payload: unknown;
+  ts: number;
+}
+
+interface ReplayBuffer {
+  events: ReplayEntry[];
+  bytes: number;
+  truncated: boolean;
+  /** 最近一次观察到的 runId（供渲染层回放后对齐 run 守卫） */
+  runId?: string;
+  terminated: boolean;
+}
+
+const MAX_REPLAY_EVENTS = 2000;
+const MAX_REPLAY_BYTES = 4 * 1024 * 1024;
+const MAX_REPLAY_SESSIONS = 50;
+
 export function registerAgentHandlers(ctx: IPCContext): void {
   const {
     agentEngineManager,
@@ -83,6 +118,54 @@ export function registerAgentHandlers(ctx: IPCContext): void {
   // ===== 常驻事件管道：text_delta 按会话节流（F8） =====
   const throttleStates = new Map<string, ThrottleState>();
   const iterationTraces = new Map<string, IterationTrace>();
+  // v0.8.0 P1-1a: 每会话流式回放缓冲（后台会话内容恢复）
+  const replayBuffers = new Map<string, ReplayBuffer>();
+
+  /** 追加一条事件到会话回放缓冲（有界：条数/字节双上限，溢出丢最旧） */
+  const appendReplay = (sessionId: string, entry: ReplayEntry): void => {
+    let buf = replayBuffers.get(sessionId);
+    if (!buf) {
+      // 会话数上限保护：超出后淘汰最早的缓冲（Map 迭代序 = 插入序）
+      if (replayBuffers.size >= MAX_REPLAY_SESSIONS) {
+        const oldest = replayBuffers.keys().next().value as string | undefined;
+        if (oldest !== undefined) replayBuffers.delete(oldest);
+      }
+      buf = { events: [], bytes: 0, truncated: false, terminated: false };
+      replayBuffers.set(sessionId, buf);
+    }
+    // run 启动（INIT）后旧 run 缓冲作废 —— 由 stateChange 监听器在 INIT 时清空，
+    // 此处仅在 terminated 缓冲上遇到新内容时兜底重置（正常路径 INIT 先行）
+    if (buf.terminated) {
+      replayBuffers.delete(sessionId);
+      buf = { events: [], bytes: 0, truncated: false, terminated: false };
+      replayBuffers.set(sessionId, buf);
+    }
+    let size = 0;
+    try {
+      size = JSON.stringify(entry.payload).length;
+    } catch {
+      size = 256; // 序列化失败按保守值计入
+    }
+    buf.events.push(entry);
+    buf.bytes += size;
+    while (
+      buf.events.length > MAX_REPLAY_EVENTS ||
+      (buf.bytes > MAX_REPLAY_BYTES && buf.events.length > 1)
+    ) {
+      const dropped = buf.events.shift();
+      buf.truncated = true;
+      if (dropped) {
+        try {
+          buf.bytes -= JSON.stringify(dropped.payload).length;
+        } catch {
+          buf.bytes -= 256;
+        }
+      }
+    }
+    // 记录 runId（首个携带者）
+    const payload = entry.payload as { runId?: string } | null;
+    if (!buf.runId && payload?.runId) buf.runId = payload.runId;
+  };
 
   // v0.7.3 P1-5: 会话级记忆固化时间戳（consolidation-policy 频率门控的状态持有方）
   // v0.7.4 P3-5: LRU 化 —— 旧实现每会话一条永不清除，长期运行后无界增长。
@@ -136,6 +219,9 @@ export function registerAgentHandlers(ctx: IPCContext): void {
   agentEngineManager.on('streamEvent', (event: MetonaStreamEvent) => {
     if (!event.sessionId) return;
     const sessionId = event.sessionId;
+    // v0.8.0 P1-1a: 全量事件进入回放缓冲（含 text_delta —— 必须在节流分支
+    // return 之前入队，否则切回会话时已缓冲的正文增量缺失）
+    appendReplay(sessionId, { channel: 'streamEvent', payload: event, ts: Date.now() });
     const trace = iterationTraces.get(sessionId);
 
     // F8: text_delta 聚合，其他事件立即转发（先 flush 保证顺序）
@@ -224,6 +310,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
         // 旧实现在 DONE 时删除 iterationTraces → 最终迭代的 TRACE 完整性缺失。
         // 现仅在 TERMINATED 分支统一收尾（flush throttle buffer + 删 iterationTraces）。
         // 注意：此处仍需转发 DONE 事件到前端（下方 broadcast 统一执行）。
+        // v0.8.0 P0-1: 捕获 Provider 原生停止原因（recordLLMResponse 记录真值）
+        if (trace && event.finishReason) trace.finishReason = event.finishReason;
         break;
       default:
         break;
@@ -247,6 +335,20 @@ export function registerAgentHandlers(ctx: IPCContext): void {
       broadcast('agent:stateChange', data);
 
       const sessionId = data.sessionId;
+      // v0.8.0 P1-1a: stateChange 事件进入回放缓冲。INIT（run 启动）清空上一 run
+      // 的缓冲；TERMINATED 置终态标记（保留缓冲供"完成后切回"回放最终内容）。
+      if (sessionId) {
+        const stateRaw = data.state ?? data.current ?? '';
+        if (stateRaw === 'INIT') {
+          replayBuffers.delete(sessionId);
+        } else {
+          appendReplay(sessionId, { channel: 'stateChange', payload: data, ts: Date.now() });
+          if (stateRaw === 'TERMINATED') {
+            const buf = replayBuffers.get(sessionId);
+            if (buf) buf.terminated = true;
+          }
+        }
+      }
       if (!sessionId || data.iteration == null) return;
       const stateValue = data.state ?? data.current ?? '';
       const trace = iterationTraces.get(sessionId);
@@ -258,7 +360,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
             sessionId,
             iteration: trace.iteration,
             content: trace.text,
-            finishReason: 'stop',
+            // v0.8.0 P0-1: 记录真实停止原因（旧实现硬编码 'stop'，length 截断不可归因）
+            finishReason: trace.finishReason ?? 'stop',
             tokenUsage: trace.usage ?? { input: 0, output: 0, total: 0 },
           });
         }
@@ -298,7 +401,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
           sessionId,
           iteration: trace.iteration,
           content: trace.text,
-          finishReason: 'stop',
+          // v0.8.0 P0-1: 记录真实停止原因（旧实现硬编码 'stop'，length 截断不可归因）
+          finishReason: trace.finishReason ?? 'stop',
           tokenUsage: trace.usage ?? { input: 0, output: 0, total: 0 },
         });
       }
@@ -991,6 +1095,27 @@ export function registerAgentHandlers(ctx: IPCContext): void {
     return { success: true };
   });
 
+  // ===== v0.8.0 P1-1a: 后台会话流回放（切回会话时恢复运行内容） =====
+  // 渲染层 setCurrentSession 检测到目标会话在 sessionRunStates 中运行（或刚结束）
+  // 时调用本通道：返回回放缓冲中按序保存的 streamEvent + stateChange 事件，
+  // 渲染层经事件总线灌入 useAgentStream 管线重建消息/Trace 状态，实时事件随后
+  // 无缝衔接（runId 对齐由缓冲记录的 runId 提供）。
+  ipcMain.handle('agent:getReplayState', (_event, sessionId: unknown) => {
+    if (typeof sessionId !== 'string' || !sessionId) {
+      return { success: false, error: 'Invalid sessionId' };
+    }
+    const buf = replayBuffers.get(sessionId);
+    return {
+      success: true,
+      data: {
+        isRunning: agentEngineManager.isRunning(sessionId),
+        runId: buf?.runId ?? null,
+        truncated: buf?.truncated ?? false,
+        events: buf?.events ?? [],
+      },
+    };
+  });
+
   // ===== v0.5.0: SubAgent 可观测性 =====
   // 1) 生命周期事件广播给前端（AgentMonitor 的 SubAgent 状态区）
   // 2) SubEngine 流事件录制到独立 TRACE 文件（sessionId = taskId），不污染父会话的流
@@ -1005,6 +1130,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
     text: string;
     usage: { input: number; output: number; total: number };
     responded: boolean;
+    /** v0.8.0 P0-1: 本轮 Provider 原生停止原因（DONE 事件携带） */
+    finishReason?: string;
   }
   const subTraces = new Map<string, SubTraceState>();
 
@@ -1117,7 +1244,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
             sessionId: taskId,
             iteration: st.iteration,
             content: st.text,
-            finishReason: 'stop',
+            // v0.8.0 P0-1: 记录真实停止原因（与主管道同口径）
+            finishReason: st.finishReason ?? 'stop',
             tokenUsage: st.usage,
           });
           sessionRecorder.recordIterationEnd(taskId, {
@@ -1152,7 +1280,8 @@ export function registerAgentHandlers(ctx: IPCContext): void {
             sessionId: taskId,
             iteration: st.iteration,
             content: st.text,
-            finishReason: 'stop',
+            // v0.8.0 P0-1: 记录真实停止原因（与主管道同口径）
+            finishReason: st.finishReason ?? 'stop',
             tokenUsage: st.usage,
           });
         }
@@ -1184,6 +1313,10 @@ export function registerAgentHandlers(ctx: IPCContext): void {
             };
           }
           break;
+        case MetonaStreamEventType.DONE:
+          // v0.8.0 P0-1: 捕获 Provider 原生停止原因（SubAgent TRACE 真值）
+          if (event.finishReason) st.finishReason = event.finishReason;
+          break;
         case MetonaStreamEventType.TOOL_CALL_COMPLETE:
           if (event.toolCall) {
             sessionRecorder.recordToolCall({

electron/ipc/app.ts

@@ -35,6 +35,18 @@ export function registerAppHandlers(ctx: IPCContext): void {
     return result;
   });
 
+  // ===== v0.8.0 P2-3: 下载并安装更新（electron-updater；未启用时明确失败） =====
+  ipcMain.handle('app:updateInstall', async () => {
+    const { getAutoUpdaterHandle } = await import('../services/update.service');
+    const handle = getAutoUpdaterHandle();
+    if (!handle) {
+      return { success: false, error: '自动更新未启用（未配置更新源或开发模式）' };
+    }
+    // fire-and-forget：进度经 update:status 广播，完成后 quitAndInstall
+    void handle.downloadAndInstall();
+    return { success: true };
+  });
+
   // ===== v0.7.3 P3-4: 健康快照（SLO 指标 + 最近健康检查报告）=====
   ipcMain.handle('app:healthSnapshot', async () => {
     try {

electron/ipc/config.ts

@@ -42,8 +42,9 @@ export function registerConfigHandlers(ctx: IPCContext): void {
     }
 
     // v0.7.4 P2-9-C: URL 类配置键高危目标校验（llm.baseURL/searxng.url/updateFeedUrl）
+    // v0.8.0 P1-5: 升级为 async 深校验（域名 DNS 解析拦云元数据绕过）
     try {
-      assertSafeConfigUrls([{ key, value }]);
+      await assertSafeConfigUrls([{ key, value }]);
     } catch (err) {
       log.warn(`[CONFIG] config:set rejected URL for ${key}: ${(err as Error).message}`);
       return { success: false, error: (err as Error).message };
@@ -104,8 +105,9 @@ export function registerConfigHandlers(ctx: IPCContext): void {
     }
 
     // v0.7.4 P2-9-C: 批量写入同样校验 URL 类配置键
+    // v0.8.0 P1-5: 升级为 async 深校验
     try {
-      assertSafeConfigUrls(entries as Array<{ key: string; value: unknown }>);
+      await assertSafeConfigUrls(entries as Array<{ key: string; value: unknown }>);
     } catch (err) {
       log.warn(`[CONFIG] config:setBatch rejected URL entry: ${(err as Error).message}`);
       return { success: false, error: (err as Error).message };

electron/ipc/mcp.ts

@@ -144,4 +144,12 @@ export function registerMCPHandlers(ctx: IPCContext): void {
       return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
   });
+
+  // ===== v0.8.0 P2-5: MCP Resources / Prompts 发现 =====
+  ipcMain.handle('mcp:listServerContents', async (_event, name: unknown) => {
+    if (typeof name !== 'string' || !name.trim()) {
+      return { success: false, error: 'Invalid server name' };
+    }
+    return { success: true, data: mcpManager.getServerContents(name) };
+  });
 }

electron/ipc/sessions.ts

@@ -6,12 +6,19 @@
  */
 
 import { ipcMain } from 'electron';
+import { join, resolve as resolvePath, sep } from 'path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import type { IPCContext } from './context';
 
 /** M-34 修复: 统一 sessionId 校验辅助函数 */
 const isValidSessionId = (id: unknown): id is string =>
   typeof id === 'string' && id.length > 0 && id.length <= 200;
 
+/** v0.8.0 P2-2: 会话录制文件名白名单（防路径逃逸/任意文件读取） */
+const RECORDING_NAME_RE = /^session_[A-Za-z0-9_-]+\.jsonl$/;
+/** v0.8.0 P2-2: 单个录制文件读取上限（防超大文件撑爆 IPC） */
+const MAX_RECORDING_BYTES = 20 * 1024 * 1024;
+
 export function registerSessionHandlers(ctx: IPCContext): void {
   const { sessionService, confirmationHook, agentEngineManager } = ctx;
 
@@ -40,6 +47,8 @@ export function registerSessionHandlers(ctx: IPCContext): void {
       agentEngineManager.abort(sessionId);
       await agentEngineManager.waitForAbort(sessionId);
     }
+    // v0.8.0 P2-1: 软删除 —— 会话进入回收站（deleted_at），30 天后自动清理，
+    // 可经 sessions:restore 恢复 / sessions:purge 彻底删除
     const result = { success: sessionService.delete(sessionId) };
     // v0.7.3 P2-3: 会话删除 = 会话终态 —— 决策记忆/pending 确认一并清理
     // （防 rememberedDecisions 随会话数累积泄漏）
@@ -52,6 +61,27 @@ export function registerSessionHandlers(ctx: IPCContext): void {
     return result;
   });
 
+  // ===== v0.8.0 P2-1: 回收站 =====
+  ipcMain.handle('sessions:listTrash', async () => {
+    return sessionService.listDeleted();
+  });
+
+  ipcMain.handle('sessions:restore', async (_event, sessionId: unknown) => {
+    if (!isValidSessionId(sessionId)) return { success: false, error: 'Invalid sessionId' };
+    return { success: sessionService.restore(sessionId) };
+  });
+
+  ipcMain.handle('sessions:purge', async (_event, sessionId: unknown) => {
+    if (!isValidSessionId(sessionId)) return { success: false, error: 'Invalid sessionId' };
+    // 彻底删除 = 终态：决策记忆/引擎与软删除同口径清理
+    const result = { success: sessionService.purge(sessionId) };
+    if (result.success) {
+      confirmationHook.forgetSession(sessionId);
+      agentEngineManager.disposeEngine(sessionId);
+    }
+    return result;
+  });
+
   ipcMain.handle('sessions:getMessages', async (_event, sessionId: unknown) => {
     // M-34 修复: 校验 sessionId
     if (!isValidSessionId(sessionId)) return [];
@@ -161,4 +191,64 @@ export function registerSessionHandlers(ctx: IPCContext): void {
     if (!isValidSessionId(sessionId)) return null;
     return sessionService.getTraceData(sessionId);
   });
+
+  // ===== v0.8.0 P2-2: 会话回放（JSONL 录制读取） =====
+  ipcMain.handle('sessions:listRecordings', async (_event, sessionId: unknown) => {
+    if (!isValidSessionId(sessionId)) return { success: false, error: 'Invalid sessionId' };
+    try {
+      const logsDir = join(ctx.workspaceService.getPath(), 'logs');
+      if (!existsSync(logsDir)) return { success: true, data: [] };
+      const prefix = `session_${sessionId}_`;
+      const files = readdirSync(logsDir)
+        .filter((n) => n.startsWith(prefix) && RECORDING_NAME_RE.test(n))
+        .map((name) => {
+          try {
+            const st = statSync(join(logsDir, name));
+            return { name, size: st.size, mtime: st.mtimeMs };
+          } catch {
+            return null;
+          }
+        })
+        .filter((f): f is { name: string; size: number; mtime: number } => f !== null)
+        .sort((a, b) => b.mtime - a.mtime);
+      return { success: true, data: files };
+    } catch (error) {
+      return { success: false, error: (error as Error).message };
+    }
+  });
+
+  ipcMain.handle('sessions:readRecording', async (_event, name: unknown) => {
+    if (typeof name !== 'string' || !RECORDING_NAME_RE.test(name)) {
+      return { success: false, error: 'Invalid recording file name' };
+    }
+    try {
+      const logsDir = resolvePath(ctx.workspaceService.getPath(), 'logs');
+      const filePath = resolvePath(logsDir, name);
+      // 目录边界校验（双保险：文件名白名单已杜绝子目录，此处防 symlink/拼接逃逸）
+      if (!filePath.startsWith(logsDir + sep)) {
+        return { success: false, error: 'Recording path escapes logs directory' };
+      }
+      if (!existsSync(filePath)) return { success: false, error: 'Recording file not found' };
+      const size = statSync(filePath).size;
+      if (size > MAX_RECORDING_BYTES) {
+        return { success: false, error: `Recording file too large (${size} bytes)` };
+      }
+      const raw = readFileSync(filePath, 'utf-8');
+      // 逐行解析，坏行跳过并计数（录制文件允许尾部截断）
+      const events: Array<Record<string, unknown>> = [];
+      let skipped = 0;
+      for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          events.push(JSON.parse(trimmed) as Record<string, unknown>);
+        } catch {
+          skipped++;
+        }
+      }
+      return { success: true, data: { name, events, skipped } };
+    } catch (error) {
+      return { success: false, error: (error as Error).message };
+    }
+  });
 }

electron/ipc/shared.ts

@@ -10,7 +10,11 @@ import log from 'electron-log';
 import type { IPCContext } from './context';
 import { broadcast } from './context';
 import { isSensitiveConfigKey } from '../utils/secure-config';
-import { assertSafeConfigTarget } from '../harness/tools/built-in/ssrf-guard';
+// v0.8.0 P1-5: 配置 URL 深校验（域名真实 DNS 解析，拦"解析到云元数据 IP"绕过）
+import {
+  assertSafeConfigTargetDeep,
+  DeepCheckSoftFailure,
+} from '../harness/tools/built-in/ssrf-guard';
 
 /**
  * v0.7.4 P2-9-C: URL 类配置键 —— 写入时须过 assertSafeConfigTarget 高危目标校验。
@@ -33,12 +37,25 @@ const URL_CONFIG_KEYS = new Set([
 /**
  * 校验一批配置写入中的 URL 类键值。任一非法即抛错（调用方整体拒绝）。
  * 非 URL 类键 / 空值 / 非字符串值跳过（空 baseURL 表示"未配置"，允许）。
+ *
+ * v0.8.0 P1-5: 升级为深校验 —— 静态规则（assertSafeConfigTarget）之外对域名
+ * 做真实 DNS 解析，任一解析结果命中链路本地/云元数据/组播保留段即拒绝；
+ * DNS 解析失败视为软失败放行（离线配置合法），仅 WARN 留痕。
  */
-export function assertSafeConfigUrls(entries: Array<{ key: string; value: unknown }>): void {
+export async function assertSafeConfigUrls(
+  entries: Array<{ key: string; value: unknown }>,
+): Promise<void> {
   for (const { key, value } of entries) {
     if (!URL_CONFIG_KEYS.has(key)) continue;
     if (typeof value !== 'string' || value.trim() === '') continue;
-    assertSafeConfigTarget(value);
+    await assertSafeConfigTargetDeep(value).catch((err) => {
+      // 软失败（DNS 解析失败）放行，仅日志留痕；硬失败（高危目标）向上抛
+      if (err instanceof DeepCheckSoftFailure) {
+        log.warn(`[CONFIG] URL deep check skipped for ${key}: ${(err as Error).message}`);
+        return;
+      }
+      throw err;
+    });
   }
 }
 

electron/ipc/workspace.ts

@@ -12,6 +12,34 @@ import log from 'electron-log';
 export function registerWorkspaceHandlers(ctx: IPCContext): void {
   const { workspaceService } = ctx;
 
+  // ===== v0.8.0 P2-4: @ 文件提及 =====
+
+  // 工作空间文件名索引（联想数据源；renderer 侧 Fuse 模糊过滤）
+  ipcMain.handle('workspace:listFiles', async (_event, limit: unknown) => {
+    const maxFiles =
+      typeof limit === 'number' && Number.isFinite(limit) && limit > 0
+        ? Math.min(5000, Math.floor(limit))
+        : 2000;
+    try {
+      return { success: true, data: workspaceService.listFiles(maxFiles) };
+    } catch (error) {
+      return { success: false, error: (error as Error).message };
+    }
+  });
+
+  // 读取提及文件的文本片段（路径边界 + 512KB 上限 + 二进制拒绝 + MEMORY.md 保护）
+  ipcMain.handle('workspace:readFileClip', async (_event, relPath: unknown, maxBytes: unknown) => {
+    if (typeof relPath !== 'string' || !relPath.trim()) {
+      return { success: false, error: 'Invalid path' };
+    }
+    const cap =
+      typeof maxBytes === 'number' && Number.isFinite(maxBytes) && maxBytes > 0
+        ? Math.min(1024 * 1024, Math.floor(maxBytes))
+        : 512 * 1024;
+    log.info(`[WORKSPACE] readFileClip: ${relPath.slice(0, 120)} (cap=${cap})`);
+    return workspaceService.readFileClip(relPath, cap);
+  });
+
   // 校验工作空间路径：检测路径有效性 + 必需文件状态 + 数据库是否存在
   ipcMain.handle('workspace:check', async (_event, targetPath: string) => {
     if (!targetPath || typeof targetPath !== 'string') {
@@ -67,96 +95,111 @@ export function registerWorkspaceHandlers(ctx: IPCContext): void {
   });
 
   // 从旧工作空间继承文件到新工作空间
-  ipcMain.handle('workspace:inheritFiles', async (_event, params: {
-    targetPath: string;
-    sourcePath: string;
-    files: string[];
-  }) => {
-    const { targetPath, sourcePath, files } = params;
-    if (!targetPath || !sourcePath || !Array.isArray(files)) {
-      return { success: false, error: '参数无效' };
-    }
-
-    const { existsSync, mkdirSync, copyFileSync } = await import('fs');
-    const { resolve } = await import('path');
-
-    const resolvedTarget = resolve(targetPath);
-    const resolvedSource = resolve(sourcePath);
-
-    // 确保目标目录存在
-    if (!existsSync(resolvedTarget)) {
-      mkdirSync(resolvedTarget, { recursive: true });
-    }
-
-    // 继承白名单：键为前端传入的标识，值为实际相对路径分段
-    // 白名单映射防止路径遍历攻击（不直接使用用户传入的路径拼接到 fs 调用）
-    const INHERIT_WHITELIST: Record<string, string[]> = {
-      'SOUL.md': ['SOUL.md'],
-      '.metona/agent.db': ['.metona', 'agent.db'],
-    };
-
-    const inherited: string[] = [];
-    const failed: Array<{ file: string; error: string }> = [];
-
-    for (const fileName of files) {
-      const pathSegments = INHERIT_WHITELIST[fileName];
-      // 不在白名单中：拒绝（防止路径遍历）
-      if (!pathSegments) {
-        failed.push({ file: fileName, error: '不在继承白名单中' });
-        continue;
+  ipcMain.handle(
+    'workspace:inheritFiles',
+    async (
+      _event,
+      params: {
+        targetPath: string;
+        sourcePath: string;
+        files: string[];
+      },
+    ) => {
+      const { targetPath, sourcePath, files } = params;
+      if (!targetPath || !sourcePath || !Array.isArray(files)) {
+        return { success: false, error: '参数无效' };
       }
-      const srcFile = join(resolvedSource, ...pathSegments);
-      const dstFile = join(resolvedTarget, ...pathSegments);
-      try {
-        // 确保目标文件的父目录存在（如 .metona/）
-        const dstDir = join(resolvedTarget, ...pathSegments.slice(0, -1));
-        if (!existsSync(dstDir)) {
-          mkdirSync(dstDir, { recursive: true });
-        }
-        if (!existsSync(srcFile)) {
-          failed.push({ file: fileName, error: '源文件不存在' });
+
+      const { existsSync, mkdirSync, copyFileSync } = await import('fs');
+      const { resolve } = await import('path');
+
+      const resolvedTarget = resolve(targetPath);
+      const resolvedSource = resolve(sourcePath);
+
+      // 确保目标目录存在
+      if (!existsSync(resolvedTarget)) {
+        mkdirSync(resolvedTarget, { recursive: true });
+      }
+
+      // 继承白名单：键为前端传入的标识，值为实际相对路径分段
+      // 白名单映射防止路径遍历攻击（不直接使用用户传入的路径拼接到 fs 调用）
+      const INHERIT_WHITELIST: Record<string, string[]> = {
+        'SOUL.md': ['SOUL.md'],
+        '.metona/agent.db': ['.metona', 'agent.db'],
+      };
+
+      const inherited: string[] = [];
+      const failed: Array<{ file: string; error: string }> = [];
+
+      for (const fileName of files) {
+        const pathSegments = INHERIT_WHITELIST[fileName];
+        // 不在白名单中：拒绝（防止路径遍历）
+        if (!pathSegments) {
+          failed.push({ file: fileName, error: '不在继承白名单中' });
           continue;
         }
-
-        // === 数据库文件特殊处理 ===
-        // agent.db 启用了 WAL 模式，直接 copyFileSync 会丢失 WAL 中未 checkpoint 的事务；
-        // 用 better-sqlite3 的 backup API（自带 checkpoint + 一致性快照）
-        if (fileName === '.metona/agent.db') {
-          try {
-            const Database = (await import('better-sqlite3')).default;
-            const srcDb = new Database(srcFile, { readonly: true, fileMustExist: true });
-            try {
-              srcDb.backup(dstFile);
-              inherited.push(fileName);
-              log.info(`[WORKSPACE] Inherited ${fileName} (via SQLite backup): ${resolvedSource} → ${resolvedTarget}`);
-            } finally {
-              srcDb.close();
-            }
-          } catch (err) {
-            // backup 失败时回退到 copyFileSync（至少保证基本可用）
-            log.warn(`[WORKSPACE] SQLite backup failed, fallback to copyFileSync: ${(err as Error).message}`);
-            try {
-              copyFileSync(srcFile, dstFile);
-              inherited.push(fileName);
-              log.info(`[WORKSPACE] Inherited ${fileName} (fallback copyFileSync): ${resolvedSource} → ${resolvedTarget}`);
-            } catch (err2) {
-              failed.push({ file: fileName, error: `backup 和 fallback 均失败: ${(err2 as Error).message}` });
-            }
+        const srcFile = join(resolvedSource, ...pathSegments);
+        const dstFile = join(resolvedTarget, ...pathSegments);
+        try {
+          // 确保目标文件的父目录存在（如 .metona/）
+          const dstDir = join(resolvedTarget, ...pathSegments.slice(0, -1));
+          if (!existsSync(dstDir)) {
+            mkdirSync(dstDir, { recursive: true });
           }
-          continue;
+          if (!existsSync(srcFile)) {
+            failed.push({ file: fileName, error: '源文件不存在' });
+            continue;
+          }
+
+          // === 数据库文件特殊处理 ===
+          // agent.db 启用了 WAL 模式，直接 copyFileSync 会丢失 WAL 中未 checkpoint 的事务；
+          // 用 better-sqlite3 的 backup API（自带 checkpoint + 一致性快照）
+          if (fileName === '.metona/agent.db') {
+            try {
+              const Database = (await import('better-sqlite3')).default;
+              const srcDb = new Database(srcFile, { readonly: true, fileMustExist: true });
+              try {
+                srcDb.backup(dstFile);
+                inherited.push(fileName);
+                log.info(
+                  `[WORKSPACE] Inherited ${fileName} (via SQLite backup): ${resolvedSource} → ${resolvedTarget}`,
+                );
+              } finally {
+                srcDb.close();
+              }
+            } catch (err) {
+              // backup 失败时回退到 copyFileSync（至少保证基本可用）
+              log.warn(
+                `[WORKSPACE] SQLite backup failed, fallback to copyFileSync: ${(err as Error).message}`,
+              );
+              try {
+                copyFileSync(srcFile, dstFile);
+                inherited.push(fileName);
+                log.info(
+                  `[WORKSPACE] Inherited ${fileName} (fallback copyFileSync): ${resolvedSource} → ${resolvedTarget}`,
+                );
+              } catch (err2) {
+                failed.push({
+                  file: fileName,
+                  error: `backup 和 fallback 均失败: ${(err2 as Error).message}`,
+                });
+              }
+            }
+            continue;
+          }
+
+          // === 普通文件直接复制 ===
+          copyFileSync(srcFile, dstFile);
+          inherited.push(fileName);
+          log.info(`[WORKSPACE] Inherited ${fileName}: ${resolvedSource} → ${resolvedTarget}`);
+        } catch (err) {
+          failed.push({ file: fileName, error: (err as Error).message });
         }
-
-        // === 普通文件直接复制 ===
-        copyFileSync(srcFile, dstFile);
-        inherited.push(fileName);
-        log.info(`[WORKSPACE] Inherited ${fileName}: ${resolvedSource} → ${resolvedTarget}`);
-      } catch (err) {
-        failed.push({ file: fileName, error: (err as Error).message });
       }
-    }
 
-    return { success: true, inherited, failed };
-  });
+      return { success: true, inherited, failed };
+    },
+  );
 
   // #51 修复: 校验源数据库完整性，防止继承损坏的数据库导致新工作空间数据丢失
   ipcMain.handle('workspace:checkDatabaseIntegrity', async (_event, sourcePath: string) => {
@@ -175,7 +218,9 @@ export function registerWorkspaceHandlers(ctx: IPCContext): void {
         const result = db.prepare('PRAGMA integrity_check').get() as { integrity_check: string };
         const ok = result.integrity_check === 'ok';
         if (!ok) {
-          log.warn(`[WORKSPACE] Source database integrity check failed: ${result.integrity_check} (source=${sourcePath})`);
+          log.warn(
+            `[WORKSPACE] Source database integrity check failed: ${result.integrity_check} (source=${sourcePath})`,
+          );
         }
         return { success: true, ok, detail: result.integrity_check };
       } finally {