feat: v0.7.2 安全收口 · 断链接线 · 观测补洞 — 230 用例扩充与全量回归

P1 修复面收口: /clear 全链路根治(前端清空联动 DB messages+摘要游标+TRACE 快照,
IPC 语义改"操作完成"; 流式中拒绝); web_browser open 补 SSRF 校验(Chromium 旁路关闭,
与 web_fetch/http_request 同源 validateSSRF); MCP 工具结果纳入注入扫描(mcp_* 前缀
按网络来源同级 full 模式, 收敛 resolveScanMode 单点); Trace 落库/入 store 双重瘦身
(tool_result base64/超长字段剥离, metadata 防 MB 级膨胀); 文本附件 512KB 闸门
(file.slice 首段读取+truncated 标志随消息持久化+主进程附件提示感知截断);
单实例锁(requestSingleInstanceLock + second-instance 聚焦已有窗口)

P2 安全纵深: ConfirmationHook 多窗口化(确认请求/超时提示改全窗口广播,
getAllWindows 空时回退 mainWindow, fail-closed 判定升级双通道); mcp_servers.headers
全链路接线(safeParseHeaders 容错解析+SSE/StreamableHTTP requestInit 注入+IPC 逐项
校验+设置页 JSON 输入, 远程 MCP 鉴权头可用)

P3 断链接线: llm:listModels IPC(六家 adapter 动态模型发现首次接线, 配置完整性
前置校验); Ollama pullModel IPC+设置页下载卡片(进度/取消/能力徽标, v0.7.0 死代码
激活); 后台会话运行指示(sessionRunStates 图+Sidebar 状态点, 多会话并发可见);
IR 卫生(移除 THINKING_START/END 死枚举, constraints 标注预留)

P4 质量与文档: i18n 第二阶段(确认弹框/侧栏/状态栏/AgentMonitor/终止原因出层,
外观设置 zh-CN/en-US 切换, ui.locale 持久化, 渲染时求值规避异步注册); README/D1
文档对齐(http_request 风险等级/用例数/实现状态注记); 版本号 0.7.2

测试: 507 → 737 用例(+230, 11 个新文件)。覆盖补齐: context-builder/consolidator/
orchestrator/workspace.service/session-recorder/config-layering/secure-config/
network-proxy + IPC mcp/tasks/memory/app/data 域 + 渲染层 store 与流事件管线纯函数。
测试驱动修复: workspace.appendMemory 中文分区 \b 词边界失效(JS \b 不含 CJK),
固化条目恒追加文件末尾产生重复分区头 → (?=\n|$) 前瞻断言根治

回归: typecheck 双端 0 错误; ESLint 0/0; 系统 Node 687 通过 50 跳过;
Electron ABI 全量 737/737 零跳过

electron/ipc/__tests__/app-data.test.ts

@@ -0,0 +1,393 @@
+/**
+ * IPC App / Data 域测试（v0.7.2 覆盖补齐）
+ *
+ * 锁定安全与数据完整性契约：
+ * 1. app:openExternal 协议白名单（M-12：file:/smb:/javascript: 拒绝）
+ * 2. error:report 渲染层错误上报：超长字段截断 + 审计落库
+ * 3. audit:query 的 eventType 枚举校验与 limit 边界（M-45）
+ * 4. data:export 的导出脱敏双保险（dataUrl 剥离 + 配置掩码 + 会话条数上限）
+ * 5. data:clear* 危险操作的事务语义与审计日志
+ */
+
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+
+const ipcMainHandleMock = vi.fn();
+const ipcMainOnMock = vi.fn();
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: (...args: unknown[]) => ipcMainHandleMock(...args),
+    on: (...args: unknown[]) => ipcMainOnMock(...args),
+  },
+  shell: { openExternal: vi.fn(async () => undefined), showItemInFolder: vi.fn() },
+  dialog: { showOpenDialog: vi.fn(async () => ({ canceled: true, filePaths: [] })) },
+  BrowserWindow: { fromWebContents: vi.fn(() => null) },
+  app: {
+    getVersion: vi.fn(() => '0.7.2'),
+    getPath: vi.fn(() => '/tmp/userdata'),
+    relaunch: vi.fn(),
+    exit: vi.fn(),
+  },
+}));
+
+vi.mock('electron-log', () => ({
+  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}));
+
+import { registerAppHandlers } from '../app';
+import { registerDataHandlers } from '../data';
+import type { IPCContext } from '../context';
+
+function getHandler(channel: string): (...args: unknown[]) => Promise<unknown> {
+  const call = ipcMainHandleMock.mock.calls.find(([ch]) => ch === channel);
+  if (!call) throw new Error(`IPC handler not registered: ${channel}`);
+  return call[1] as (...args: unknown[]) => Promise<unknown>;
+}
+
+function getListener(channel: string): (...args: unknown[]) => void {
+  const call = ipcMainOnMock.mock.calls.find(([ch]) => ch === channel);
+  if (!call) throw new Error(`IPC listener not registered: ${channel}`);
+  return call[1] as (...args: unknown[]) => void;
+}
+
+beforeEach(() => {
+  ipcMainHandleMock.mockClear();
+  ipcMainOnMock.mockClear();
+});
+
+// ===== App 域 =====
+
+describe('app:openExternal — 协议白名单（M-12）', () => {
+  function makeCtx(): IPCContext {
+    return { configService: { get: vi.fn(() => null) } } as unknown as IPCContext;
+  }
+
+  it('http/https/mailto 放行', async () => {
+    registerAppHandlers(makeCtx());
+    const handler = getHandler('app:openExternal');
+    for (const url of ['https://example.com', 'http://example.com/x', 'mailto:a@b.com']) {
+      expect(await handler(null, url)).toMatchObject({ success: true });
+    }
+  });
+
+  it.each([
+    'file:///etc/passwd',
+    'smb://host/share',
+    'javascript:alert(1)',
+    'data:text/html,<script>',
+    'ftp://host/file',
+  ])('%s → 拒绝', async (url) => {
+    registerAppHandlers(makeCtx());
+    const result = (await getHandler('app:openExternal')(null, url)) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not allowed');
+  });
+
+  it('非字符串/空 URL 拒绝', async () => {
+    registerAppHandlers(makeCtx());
+    expect(await getHandler('app:openExternal')(null, '')).toMatchObject({ success: false });
+    expect(await getHandler('app:openExternal')(null, 123)).toMatchObject({ success: false });
+  });
+});
+
+describe('audit 域 — 校验矩阵（M-45）', () => {
+  function makeCtx(): { ctx: IPCContext; query: Mock } {
+    const query = vi.fn(() => []);
+    return {
+      ctx: {
+        auditService: {
+          query,
+          log: vi.fn(),
+          verifyChain: vi.fn(() => ({
+            valid: true,
+            totalRecords: 0,
+            verifiedRecords: 0,
+            tamperedId: null,
+          })),
+        },
+      } as unknown as IPCContext,
+      query,
+    };
+  }
+
+  it('audit:query 非法 eventType 拒绝（枚举白名单）', async () => {
+    const { ctx } = makeCtx();
+    registerAppHandlers(ctx);
+    const result = (await getHandler('audit:query')(null, { eventType: 'DROP TABLE' })) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid eventType');
+  });
+
+  it('audit:query limit 边界（1-1000 之外拒绝，防超大查询）', async () => {
+    const { ctx, query } = makeCtx();
+    registerAppHandlers(ctx);
+    const handler = getHandler('audit:query');
+
+    expect(await handler(null, { limit: 0 })).toMatchObject({ success: false });
+    expect(await handler(null, { limit: 1001 })).toMatchObject({ success: false });
+    expect(await handler(null, { limit: Number.NaN })).toMatchObject({ success: false });
+    await handler(null, { limit: 500 });
+    expect(query).toHaveBeenCalledWith(expect.objectContaining({ limit: 500 }));
+  });
+
+  it('audit:verifyChain 透传结果', async () => {
+    const { ctx } = makeCtx();
+    registerAppHandlers(ctx);
+    const result = (await getHandler('audit:verifyChain')(null)) as {
+      success: boolean;
+      valid: boolean;
+    };
+    expect(result).toMatchObject({ success: true, valid: true });
+  });
+});
+
+describe('searxng:testConnection — 连接测试', () => {
+  function makeCtx(): IPCContext {
+    return { configService: { get: vi.fn(() => null) } } as unknown as IPCContext;
+  }
+
+  it('非法 URL 直接拒绝（不发起网络请求）', async () => {
+    registerAppHandlers(makeCtx());
+    const result = (await getHandler('searxng:testConnection')(null, 'ftp://x', '', '')) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('http');
+  });
+
+  it('Basic 认证 → Authorization 头为 Base64 编码', async () => {
+    registerAppHandlers(makeCtx());
+    const fetchSpy = vi.fn(async (..._args: unknown[]) => ({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+    }));
+    vi.stubGlobal('fetch', fetchSpy);
+
+    await getHandler('searxng:testConnection')(null, 'https://sx.local', 'user:pass', 'basic');
+    const headers = (fetchSpy.mock.calls[0][1] as { headers: Record<string, string> }).headers;
+    expect(headers['Authorization']).toBe(`Basic ${Buffer.from('user:pass').toString('base64')}`);
+    vi.unstubAllGlobals();
+  });
+
+  it('网络异常 → success:false + 错误信息', async () => {
+    registerAppHandlers(makeCtx());
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async () => {
+        throw new Error('ECONNREFUSED');
+      }),
+    );
+    const result = (await getHandler('searxng:testConnection')(
+      null,
+      'https://sx.local',
+      '',
+      '',
+    )) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('ECONNREFUSED');
+    vi.unstubAllGlobals();
+  });
+});
+
+describe('error:report — 渲染层错误上报通道（P0-3）', () => {
+  it('超长字段截断 + 审计落库（TOOL 层）', async () => {
+    const log = vi.fn();
+    registerAppHandlers({ auditService: { log } } as unknown as IPCContext);
+    const listener = getListener('error:report');
+
+    listener(null, {
+      type: 'render-crash',
+      error: 'e'.repeat(2000),
+      stack: 's'.repeat(10000),
+      componentStack: 'c'.repeat(8000),
+      timestamp: Date.now(),
+    });
+
+    expect(log).toHaveBeenCalledTimes(1);
+    const entry = log.mock.calls[0][0] as { eventType: string; details: Record<string, unknown> };
+    expect(entry.eventType).toBe('error');
+    expect((entry.details.error as string).length).toBe(1000);
+    expect((entry.details.stack as string).length).toBe(4000);
+    expect((entry.details.componentStack as string).length).toBe(4000);
+  });
+
+  it('非法载荷安全忽略（单向通道不抛错）', () => {
+    const log = vi.fn();
+    registerAppHandlers({ auditService: { log } } as unknown as IPCContext);
+    const listener = getListener('error:report');
+    expect(() => listener(null, null)).not.toThrow();
+    expect(() => listener(null, 'plain string')).not.toThrow();
+    expect(log).not.toHaveBeenCalled();
+  });
+});
+
+// ===== Data 域 =====
+
+describe('data:export — 导出脱敏双保险', () => {
+  function makeCtx(
+    messages: unknown[],
+    sessions?: unknown[],
+  ): { ctx: IPCContext; sessionService: Record<string, Mock> } {
+    const sessionService = {
+      getMessages: vi.fn(() => messages),
+      list: vi.fn(() => sessions ?? []),
+    };
+    const configService = {
+      getAll: vi.fn(() => ({ 'llm.apiKey': 'sk-export-raw', 'ui.theme': 'dark' })),
+    };
+    return {
+      ctx: { sessionService, configService } as unknown as IPCContext,
+      sessionService,
+    };
+  }
+
+  it('单会话导出：toolResult.dataUrl 被剥离（view_image base64 防泄漏）', async () => {
+    const bigDataUrl = `data:image/png;base64,${'A'.repeat(100)}`;
+    const messages = [
+      {
+        id: 'm1',
+        role: 'tool',
+        toolResult: { toolCallId: 'tc_1', result: { path: 'x.png', dataUrl: bigDataUrl } },
+      },
+      {
+        id: 'm2',
+        role: 'user',
+        attachments: [{ name: 'pic.png', preview: 'data:image/jpeg;base64,BBBB' }],
+      },
+    ];
+    const { ctx } = makeCtx(messages);
+    registerDataHandlers(ctx);
+
+    const result = (await getHandler('data:export')(null, 's1')) as {
+      success: boolean;
+      data: unknown[];
+    };
+    expect(result.success).toBe(true);
+    const toolMsg = result.data[0] as { toolResult: { result: Record<string, unknown> } };
+    expect(toolMsg.toolResult.result.dataUrl).toBeUndefined();
+    expect(toolMsg.toolResult.result.path).toBe('x.png'); // 小字段保留
+    expect(toolMsg.toolResult.result._displayNote).toBeDefined();
+
+    const userMsg = result.data[1] as { attachments: Array<Record<string, unknown>> };
+    expect(userMsg.attachments[0].preview).toBeUndefined(); // preview 剥离
+    expect(userMsg.attachments[0].name).toBe('pic.png');
+  });
+
+  it('全量导出：配置敏感值脱敏（S-1），普通字段原样', async () => {
+    const { ctx } = makeCtx([], [{ id: 's1', title: 't' }]);
+    registerDataHandlers(ctx);
+
+    const result = (await getHandler('data:export')(null, undefined)) as {
+      success: boolean;
+      data: { config: Record<string, unknown>; sessions: unknown[] };
+    };
+    expect(result.data.config['llm.apiKey']).toBe('***-raw'); // maskSensitive：后 4 位保留
+    expect(result.data.config['ui.theme']).toBe('dark'); // 非敏感原样
+    expect(JSON.stringify(result.data.config)).not.toContain('sk-export-raw');
+  });
+
+  it('导出失败 → success:false', async () => {
+    const { ctx, sessionService } = makeCtx([]);
+    sessionService.getMessages.mockImplementation(() => {
+      throw new Error('db gone');
+    });
+    registerDataHandlers(ctx);
+    const result = (await getHandler('data:export')(null, 's1')) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('db gone');
+  });
+});
+
+describe('data:clear* — 危险操作事务语义', () => {
+  function makeDbMock(): { prepare: Mock; exec: Mock } {
+    const prepare = vi.fn(() => ({
+      run: vi.fn(),
+      get: vi.fn(() => ({ c: 2 })),
+      all: vi.fn(() => []),
+    }));
+    const exec = vi.fn();
+    return { prepare, exec };
+  }
+
+  it('clearSessions：BEGIN/DELETE/COMMIT 事务包裹 + 删除计数', async () => {
+    const { prepare, exec } = makeDbMock();
+    registerDataHandlers({
+      sessionService: { getDB: () => ({ prepare, exec }) },
+    } as unknown as IPCContext);
+
+    const result = (await getHandler('data:clearSessions')(null)) as {
+      success: boolean;
+      deletedSessions: number;
+    };
+    expect(result).toMatchObject({ success: true, deletedSessions: 2, deletedMessages: 2 });
+    const execCalls = exec.mock.calls.map((c) => c[0] as string);
+    expect(execCalls).toEqual(expect.arrayContaining(['BEGIN', 'COMMIT']));
+  });
+
+  it('clearSessions 失败 → ROLLBACK（消息/会话表一致性）', async () => {
+    // DELETE 走 db.exec（非 prepare）—— 失败注入点在 exec 的 sessions 删除
+    const prepare = vi.fn(() => ({
+      run: vi.fn(),
+      get: vi.fn(() => ({ c: 1 })),
+      all: vi.fn(() => []),
+    }));
+    const exec = vi.fn((sql: string) => {
+      if (sql.includes('DELETE FROM sessions')) {
+        throw new Error('foreign key constraint');
+      }
+    });
+    registerDataHandlers({
+      sessionService: { getDB: () => ({ prepare, exec }) },
+    } as unknown as IPCContext);
+
+    const result = (await getHandler('data:clearSessions')(null)) as { success: boolean };
+    expect(result.success).toBe(false);
+    const execCalls = exec.mock.calls.map((c) => c[0] as string);
+    expect(execCalls).toContain('ROLLBACK');
+  });
+
+  it('clearMemories 三张记忆表事务包裹（M-41 一致性）', async () => {
+    const { prepare, exec } = makeDbMock();
+    registerDataHandlers({
+      sessionService: { getDB: () => ({ prepare, exec }) },
+    } as unknown as IPCContext);
+
+    const result = (await getHandler('data:clearMemories')(null)) as {
+      success: boolean;
+      deletedEpisodic: number;
+    };
+    expect(result.success).toBe(true);
+    const execCalls = exec.mock.calls.map((c) => c[0] as string);
+    expect(execCalls).toEqual(expect.arrayContaining(['BEGIN', 'COMMIT']));
+  });
+
+  it('clearAuditLogs：先删防篡改触发器再清表，最后重建触发器（INSERT-ONLY 契约）', async () => {
+    const { prepare, exec } = makeDbMock();
+    registerDataHandlers({
+      sessionService: { getDB: () => ({ prepare, exec }) },
+    } as unknown as IPCContext);
+
+    const result = (await getHandler('data:clearAuditLogs')(null)) as { success: boolean };
+    expect(result.success).toBe(true);
+    const execCalls = exec.mock.calls.map((c) => c[0] as string);
+    expect(execCalls[0]).toBe('BEGIN');
+    expect(execCalls.some((c) => c.includes('DROP TRIGGER IF EXISTS audit_no_delete'))).toBe(true);
+    expect(execCalls.some((c) => c.includes('CREATE TRIGGER audit_no_delete BEFORE DELETE'))).toBe(
+      true,
+    );
+    expect(execCalls[execCalls.length - 1]).toBe('COMMIT');
+  });
+});

electron/ipc/__tests__/mcp-tasks-memory.test.ts

@@ -0,0 +1,387 @@
+/**
+ * IPC MCP / Tasks / Memory 域测试（v0.7.2 覆盖补齐）
+ *
+ * 锁定三类安全相关契约：
+ * 1. mcp:addServer 的传输方式/必填字段/headers 逐项校验矩阵（v0.7.2 P2-8）
+ * 2. tasks 域的枚举校验与会话越权防护（WHERE session_id = ? 契约）
+ * 3. memory 域的查询参数收敛（topK 钳制/type 枚举）与删除表映射
+ */
+
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+
+const ipcMainHandleMock = vi.fn();
+vi.mock('electron', () => ({
+  ipcMain: { handle: (...args: unknown[]) => ipcMainHandleMock(...args) },
+}));
+
+vi.mock('electron-log', () => ({
+  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}));
+
+import { registerMCPHandlers } from '../mcp';
+import { registerTaskHandlers } from '../tasks';
+import { registerMemoryHandlers } from '../memory';
+import type { IPCContext } from '../context';
+
+function getHandler(channel: string): (...args: unknown[]) => Promise<unknown> {
+  const call = ipcMainHandleMock.mock.calls.find(([ch]) => ch === channel);
+  if (!call) throw new Error(`IPC handler not registered: ${channel}`);
+  return call[1] as (...args: unknown[]) => Promise<unknown>;
+}
+
+beforeEach(() => {
+  ipcMainHandleMock.mockClear();
+});
+
+// ===== MCP 域 =====
+
+describe('mcp:addServer — 校验矩阵', () => {
+  function makeCtx(): { ctx: IPCContext; addServer: Mock } {
+    const addServer = vi.fn(async () => undefined);
+    return { ctx: { mcpManager: { addServer } } as unknown as IPCContext, addServer };
+  }
+
+  it.each([
+    [null, 'Invalid config'],
+    [undefined, 'Invalid config'],
+    [{ transport: 'stdio', command: 'npx' }, 'name is required'],
+    [{ name: 'x', transport: 'ftp', command: 'npx' }, 'Invalid transport'],
+    [{ name: 'x', transport: 'stdio' }, 'command is required'],
+    [{ name: 'x', transport: 'stdio', command: '  ' }, 'command is required'],
+    [{ name: 'x', transport: 'streamable-http' }, 'url is required'],
+    [{ name: 'x', transport: 'sse', url: 'not a url' }, 'Invalid url format'],
+  ])('非法载荷 %# 拒绝', async (payload, expectedError) => {
+    const { ctx } = makeCtx();
+    registerMCPHandlers(ctx);
+    const result = (await getHandler('mcp:addServer')(null, payload)) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toContain(expectedError);
+  });
+
+  it('stdio 合法载荷透传（不含 headers）', async () => {
+    const { ctx, addServer } = makeCtx();
+    registerMCPHandlers(ctx);
+
+    const result = await getHandler('mcp:addServer')(null, {
+      name: 'fs-server',
+      transport: 'stdio',
+      command: 'npx',
+      args: ['-y', 'server'],
+    });
+    expect(result).toEqual({ success: true });
+    expect(addServer).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: 'fs-server',
+        transport: 'stdio',
+        command: 'npx',
+        enabled: true,
+      }),
+    );
+  });
+
+  it('v0.7.2 P2-8: headers 必须为扁平 string→string 对象', async () => {
+    const { ctx } = makeCtx();
+    registerMCPHandlers(ctx);
+    const handler = getHandler('mcp:addServer');
+
+    // 非对象
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: 'Bearer x',
+      }),
+    ).toMatchObject({ success: false });
+    // 数组
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: [],
+      }),
+    ).toMatchObject({ success: false });
+    // 值非字符串
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: { Authorization: 123 },
+      }),
+    ).toMatchObject({ success: false });
+    // 空键
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: { '': 'v' },
+      }),
+    ).toMatchObject({ success: false });
+    // 超过 20 项
+    const tooMany = Object.fromEntries(Array.from({ length: 21 }, (_, i) => [`h${i}`, 'v']));
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: tooMany,
+      }),
+    ).toMatchObject({ success: false });
+    // 超长值
+    expect(
+      await handler(null, {
+        name: 'x',
+        transport: 'streamable-http',
+        url: 'https://a.com/mcp',
+        headers: { Authorization: 'x'.repeat(5000) },
+      }),
+    ).toMatchObject({ success: false });
+  });
+
+  it('headers 合法时透传给 manager；未提供时不携带该字段', async () => {
+    const { ctx, addServer } = makeCtx();
+    registerMCPHandlers(ctx);
+    const handler = getHandler('mcp:addServer');
+
+    await handler(null, {
+      name: 'remote',
+      transport: 'streamable-http',
+      url: 'https://a.com/mcp',
+      headers: { Authorization: 'Bearer tok' },
+    });
+    expect(addServer).toHaveBeenLastCalledWith(
+      expect.objectContaining({ headers: { Authorization: 'Bearer tok' } }),
+    );
+
+    await handler(null, {
+      name: 'remote2',
+      transport: 'streamable-http',
+      url: 'https://b.com/mcp',
+    });
+    const call = addServer.mock.calls[1][0] as Record<string, unknown>;
+    expect(call.headers).toBeUndefined();
+  });
+
+  it('manager 抛错 → success:false + 错误信息', async () => {
+    const { ctx, addServer } = makeCtx();
+    addServer.mockRejectedValueOnce(new Error('connect timeout'));
+    registerMCPHandlers(ctx);
+    const result = (await getHandler('mcp:addServer')(null, {
+      name: 'x',
+      transport: 'stdio',
+      command: 'node',
+    })) as {
+      success: boolean;
+      error?: string;
+    };
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('connect timeout');
+  });
+});
+
+describe('mcp:removeServer / toggleServer — 校验', () => {
+  it('非法 name 拒绝；合法调用透传', async () => {
+    const removeServer = vi.fn(async () => undefined);
+    const toggleServer = vi.fn(async () => undefined);
+    registerMCPHandlers({ mcpManager: { removeServer, toggleServer } } as unknown as IPCContext);
+
+    expect(await getHandler('mcp:removeServer')(null, '')).toMatchObject({ success: false });
+    expect(await getHandler('mcp:toggleServer')(null, 'x', 'yes')).toMatchObject({
+      success: false,
+    });
+    expect(removeServer).not.toHaveBeenCalled();
+    expect(toggleServer).not.toHaveBeenCalled();
+
+    await getHandler('mcp:removeServer')(null, 'srv');
+    expect(removeServer).toHaveBeenCalledWith('srv');
+    await getHandler('mcp:toggleServer')(null, 'srv', false);
+    expect(toggleServer).toHaveBeenCalledWith('srv', false);
+  });
+});
+
+// ===== Tasks 域 =====
+
+describe('tasks 域 — 会话越权防护与校验', () => {
+  function makeDb(): { db: Record<string, Mock>; prepare: Mock } {
+    const run = vi.fn();
+    const get = vi.fn();
+    const all = vi.fn(() => []);
+    const prepare = vi.fn(() => ({ run, get, all }));
+    return { db: { run, get, all }, prepare };
+  }
+
+  function makeCtx(): { ctx: IPCContext; prepare: Mock; run: Mock; get: Mock; all: Mock } {
+    const { db, prepare } = makeDb();
+    const sessionService = { getDB: () => ({ prepare }) };
+    return {
+      ctx: { sessionService } as unknown as IPCContext,
+      prepare,
+      run: db.run,
+      get: db.get,
+      all: db.all,
+    };
+  }
+
+  it('tasks:create 校验 sessionId/title/priority/parentId', async () => {
+    const { ctx } = makeCtx();
+    registerTaskHandlers(ctx);
+    const handler = getHandler('tasks:create');
+
+    expect(await handler(null, null)).toMatchObject({ success: false });
+    expect(await handler(null, { sessionId: '', title: 't' })).toMatchObject({ success: false });
+    expect(await handler(null, { sessionId: 's', title: '  ' })).toMatchObject({ success: false });
+    expect(await handler(null, { sessionId: 's', title: 't', priority: 'urgent' })).toMatchObject({
+      success: false,
+    });
+    expect(await handler(null, { sessionId: 's', title: 't', parentId: 42 })).toMatchObject({
+      success: false,
+    });
+  });
+
+  it('tasks:create 合法路径：order_idx = 同组 MAX+1，ID 统一 nanoid 前缀', async () => {
+    const { ctx, prepare, run } = makeCtx();
+    (prepare as unknown as Mock).mockImplementation(() => ({
+      run,
+      get: vi.fn(() => ({ maxOrder: 4 })),
+      all: vi.fn(() => []),
+    }));
+    registerTaskHandlers(ctx);
+
+    const result = (await getHandler('tasks:create')(null, {
+      sessionId: 's1',
+      title: '新任务',
+      priority: 'high',
+      parentId: null,
+    })) as { success: boolean; id: string };
+    expect(result.success).toBe(true);
+    expect(result.id).toMatch(/^task_/);
+  });
+
+  it('tasks:update 强制 WHERE session_id = ?（越权防护契约）', async () => {
+    const { ctx, prepare, run } = makeCtx();
+    prepare.mockImplementation(() => ({
+      run,
+      get: vi.fn(() => ({ id: 't1' })),
+      all: vi.fn(() => []),
+    }));
+    registerTaskHandlers(ctx);
+
+    await getHandler('tasks:update')(null, 't1', { status: 'completed' }, 'sess-owner');
+    const sql = (prepare.mock.calls.find((c) => String(c[0]).startsWith('UPDATE'))?.[0] ??
+      '') as string;
+    expect(sql).toContain('AND session_id = ?');
+    expect(run).toHaveBeenCalled();
+  });
+
+  it('tasks:update 枚举校验（status/priority/title/description 类型）', async () => {
+    const { ctx } = makeCtx();
+    registerTaskHandlers(ctx);
+    const handler = getHandler('tasks:update');
+
+    expect(await handler(null, 't1', { status: 'done' }, 's')).toMatchObject({ success: false });
+    expect(await handler(null, 't1', { priority: 'critical!' }, 's')).toMatchObject({
+      success: false,
+    });
+    expect(await handler(null, 't1', { title: 123 }, 's')).toMatchObject({ success: false });
+    expect(await handler(null, 't1', { description: {} }, 's')).toMatchObject({ success: false });
+    // 空更新为幂等 no-op（既有契约：fields 为空直接 success，不触发 UPDATE）
+    expect(await handler(null, 't1', {}, 's')).toMatchObject({ success: true });
+    expect(await handler(null, 't1', { status: 'completed' }, '')).toMatchObject({
+      success: false,
+    }); // 越权防护
+  });
+
+  it('tasks:delete 强制 WHERE session_id = ?', async () => {
+    const { ctx, prepare, run } = makeCtx();
+    registerTaskHandlers(ctx);
+
+    await getHandler('tasks:delete')(null, 't1', 'sess-owner');
+    const sql = (prepare.mock.calls[0][0] ?? '') as string;
+    expect(sql).toContain('AND session_id = ?');
+    expect(run).toHaveBeenCalled();
+  });
+
+  it('tasks:list 校验 sessionId 可选参数', async () => {
+    const { ctx, all } = makeCtx();
+    registerTaskHandlers(ctx);
+
+    expect(await getHandler('tasks:list')(null, 42)).toMatchObject({ success: false });
+    await getHandler('tasks:list')(null);
+    expect(all).toHaveBeenCalled();
+  });
+});
+
+// ===== Memory 域 =====
+
+describe('memory 域 — 查询参数收敛与删除映射', () => {
+  function makeCtx(): { ctx: IPCContext; prepare: Mock } {
+    const prepare = vi.fn(() => ({ run: vi.fn(), get: vi.fn(), all: vi.fn(() => []) }));
+    return {
+      ctx: {
+        memoryManager: { search: vi.fn(() => []) },
+        sessionService: { getDB: () => ({ prepare }) },
+      } as unknown as IPCContext,
+      prepare,
+    };
+  }
+
+  it('db:searchMemories 空 query 返回空数组；topK 钳制 1-100', async () => {
+    const { ctx } = makeCtx();
+    registerMemoryHandlers(ctx);
+    const handler = getHandler('db:searchMemories');
+    const search = (ctx.memoryManager as unknown as { search: Mock }).search;
+
+    expect(await handler(null, '   ')).toEqual([]);
+    await handler(null, 'q', { topK: 500 });
+    expect(search).toHaveBeenCalledWith('q', expect.objectContaining({ topK: 10 })); // 非法回退默认 10
+    await handler(null, 'q', { topK: 3 });
+    expect(search).toHaveBeenLastCalledWith('q', expect.objectContaining({ topK: 3 }));
+  });
+
+  it('db:searchMemories type 必须为合法 MemoryType（非法被剔除）', async () => {
+    const { ctx } = makeCtx();
+    registerMemoryHandlers(ctx);
+    const handler = getHandler('db:searchMemories');
+    const search = (ctx.memoryManager as unknown as { search: Mock }).search;
+
+    await handler(null, 'q', { type: 'semantic' });
+    expect(search).toHaveBeenLastCalledWith('q', expect.objectContaining({ type: 'semantic' }));
+    await handler(null, 'q', { type: 'hacked' });
+    expect(search).toHaveBeenLastCalledWith(
+      'q',
+      expect.not.objectContaining({ type: expect.anything() }),
+    );
+  });
+
+  it('memory:listAll 校验 type 枚举与 limit 范围（LIMIT -1 防护）', async () => {
+    const { ctx } = makeCtx();
+    registerMemoryHandlers(ctx);
+    const handler = getHandler('memory:listAll');
+
+    expect(await handler(null, { type: 'nope' })).toMatchObject({ success: false });
+    expect(await handler(null, { limit: -1 })).toMatchObject({ success: false });
+    expect(await handler(null, { limit: 5000 })).toMatchObject({ success: false });
+  });
+
+  it('memory:delete 按类型映射到正确的表（防止三元默认落到 working_memories）', async () => {
+    const { ctx, prepare } = makeCtx();
+    registerMemoryHandlers(ctx);
+    const handler = getHandler('memory:delete');
+
+    await handler(null, 'episodic', 'm1');
+    expect(String(prepare.mock.calls[0][0])).toContain('episodic_memories');
+    prepare.mockClear();
+
+    await handler(null, 'semantic', 'm2');
+    expect(String(prepare.mock.calls[0][0])).toContain('semantic_memories');
+    prepare.mockClear();
+
+    expect(await handler(null, 'unknown', 'm3')).toMatchObject({ success: false });
+  });
+});

electron/ipc/__tests__/sessions-tools-config.test.ts

@@ -0,0 +1,411 @@
+/**
+ * IPC 域 Handler 测试（v0.7.2 P4-14 覆盖补齐）
+ *
+ * sessions / tools / config 三个域此前零测试。本文件锁定三类契约：
+ * 1. 参数校验矩阵（M-34/M-35/M-42 系列修复的回归防线）—— 非法输入被拒绝
+ *    且不触达 service 层
+ * 2. v0.7.2 A1 语义修正 —— sessions:clearMessages 的成功判定是"操作完成"
+ *    而非"有行被删除"（空会话清空同样 success:true）
+ * 3. tools:toggle / setAutoExecute 的未知工具拒绝（防配置 key 污染）与
+ *    config:set/setBatch 的类型校验、敏感值脱敏审计
+ */
+
+import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+
+// ===== Mock electron（ipcMain） =====
+const ipcMainHandleMock = vi.fn();
+const ipcMainOnMock = vi.fn();
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: (...args: unknown[]) => ipcMainHandleMock(...args),
+    on: (...args: unknown[]) => ipcMainOnMock(...args),
+  },
+}));
+
+// ===== Mock broadcast（ipc/context，shared.ts 的 config:changed 广播） =====
+const broadcastMock = vi.fn();
+vi.mock('../context', () => ({
+  broadcast: (...args: unknown[]) => broadcastMock(...args),
+}));
+
+import { registerSessionHandlers } from '../sessions';
+import { registerToolHandlers } from '../tools';
+import { registerConfigHandlers } from '../config';
+import type { IPCContext } from '../context';
+
+function getHandler(channel: string): (...args: unknown[]) => Promise<unknown> {
+  const call = ipcMainHandleMock.mock.calls.find(([ch]) => ch === channel);
+  if (!call) throw new Error(`IPC handler not registered: ${channel}`);
+  return call[1] as (...args: unknown[]) => Promise<unknown>;
+}
+
+function getListener(channel: string): (...args: unknown[]) => void {
+  const call = ipcMainOnMock.mock.calls.find(([ch]) => ch === channel);
+  if (!call) throw new Error(`IPC listener not registered: ${channel}`);
+  // ipcMain.on 处理器签名 (event, ...args) —— 返回宽松签名以便按双参调用
+  return call[1] as (...args: unknown[]) => void;
+}
+
+beforeEach(() => {
+  ipcMainHandleMock.mockClear();
+  ipcMainOnMock.mockClear();
+  broadcastMock.mockClear();
+});
+
+// ===== sessions 域 =====
+
+describe('sessions 域 — 参数校验矩阵', () => {
+  function makeCtx(): { ctx: IPCContext; raw: Record<string, unknown> } {
+    const raw = {
+      sessionService: {
+        list: vi.fn(() => []),
+        create: vi.fn(),
+        rename: vi.fn(() => true),
+        delete: vi.fn(() => true),
+        getMessages: vi.fn(() => []),
+        pin: vi.fn(() => true),
+        archive: vi.fn(() => true),
+        deleteMessage: vi.fn(() => true),
+        clearMessages: vi.fn(),
+        truncateMessagesAfter: vi.fn(() => true),
+        searchMessages: vi.fn(() => []),
+        saveTraceData: vi.fn(),
+        getTraceData: vi.fn(() => null),
+      },
+    };
+    return { ctx: raw as unknown as IPCContext, raw };
+  }
+
+  it('rename / delete / pin / archive 对非法 sessionId 拒绝且不触达 service', async () => {
+    const { ctx, raw } = makeCtx();
+    registerSessionHandlers(ctx);
+    const svc = raw.sessionService as Record<string, Mock>;
+
+    for (const bad of [null, undefined, 123, '', 'x'.repeat(201)]) {
+      expect(await getHandler('sessions:rename')(null, bad, 't')).toMatchObject({ success: false });
+      expect(await getHandler('sessions:delete')(null, bad)).toMatchObject({ success: false });
+      expect(await getHandler('sessions:pin')(null, bad, true)).toMatchObject({ success: false });
+      expect(await getHandler('sessions:archive')(null, bad, true)).toMatchObject({
+        success: false,
+      });
+    }
+    expect(svc.rename).not.toHaveBeenCalled();
+    expect(svc.delete).not.toHaveBeenCalled();
+    expect(svc.pin).not.toHaveBeenCalled();
+    expect(svc.archive).not.toHaveBeenCalled();
+  });
+
+  it('rename 拒绝空 title；pin/archive 拒绝非布尔', async () => {
+    const { ctx, raw } = makeCtx();
+    registerSessionHandlers(ctx);
+    const svc = raw.sessionService as Record<string, Mock>;
+
+    expect(await getHandler('sessions:rename')(null, 's1', '  ')).toMatchObject({ success: false });
+    expect(await getHandler('sessions:pin')(null, 's1', 'yes')).toMatchObject({ success: false });
+    expect(await getHandler('sessions:archive')(null, 's1', 1)).toMatchObject({ success: false });
+    expect(svc.rename).not.toHaveBeenCalled();
+    expect(svc.pin).not.toHaveBeenCalled();
+    expect(svc.archive).not.toHaveBeenCalled();
+  });
+
+  it('getMessages 对非法 sessionId 返回空数组；合法调用透传', async () => {
+    const { ctx, raw } = makeCtx();
+    registerSessionHandlers(ctx);
+    const svc = raw.sessionService as Record<string, Mock>;
+
+    expect(await getHandler('sessions:getMessages')(null, 42)).toEqual([]);
+    await getHandler('sessions:getMessages')(null, 's1');
+    expect(svc.getMessages).toHaveBeenCalledWith('s1');
+  });
+
+  it('saveTrace 严格校验：traceSteps 必须为数组且 tokenUsage 必填', async () => {
+    const { ctx, raw } = makeCtx();
+    registerSessionHandlers(ctx);
+    const svc = raw.sessionService as Record<string, Mock>;
+
+    expect(await getHandler('sessions:saveTrace')(null, 's1', null)).toMatchObject({
+      success: false,
+    });
+    expect(await getHandler('sessions:saveTrace')(null, 's1', { tokenUsage: {} })).toMatchObject({
+      success: false,
+    });
+    expect(await getHandler('sessions:saveTrace')(null, 's1', { traceSteps: 'x' })).toMatchObject({
+      success: false,
+    });
+    expect(svc.saveTraceData).not.toHaveBeenCalled();
+
+    await getHandler('sessions:saveTrace')(null, 's1', {
+      traceSteps: [],
+      tokenUsage: { totalTokens: 0 },
+    });
+    expect(svc.saveTraceData).toHaveBeenCalledWith('s1', {
+      traceSteps: [],
+      tokenUsage: { totalTokens: 0 },
+    });
+  });
+});
+
+describe('sessions:clearMessages — v0.7.2 A1 语义修正', () => {
+  function makeCtx(): IPCContext {
+    return {
+      sessionService: { clearMessages: vi.fn() },
+    } as unknown as IPCContext;
+  }
+
+  it('操作完成即 success:true（空会话 / 0 行删除同样是成功）', async () => {
+    registerSessionHandlers(makeCtx());
+    const result = await getHandler('sessions:clearMessages')(null, 's1');
+    expect(result).toEqual({ success: true });
+  });
+
+  it('service 抛错 → success:false + 错误信息', async () => {
+    const ctx = {
+      sessionService: {
+        clearMessages: vi.fn(() => {
+          throw new Error('db locked');
+        }),
+      },
+    } as unknown as IPCContext;
+    registerSessionHandlers(ctx);
+    const result = await getHandler('sessions:clearMessages')(null, 's1');
+    expect(result).toEqual({ success: false, error: 'db locked' });
+  });
+
+  it('非法 sessionId 拒绝且不触达 service', async () => {
+    const ctx = makeCtx();
+    registerSessionHandlers(ctx);
+    const result = await getHandler('sessions:clearMessages')(null, '');
+    expect(result).toMatchObject({ success: false });
+    expect(
+      (ctx.sessionService as unknown as { clearMessages: Mock }).clearMessages,
+    ).not.toHaveBeenCalled();
+  });
+});
+
+// ===== tools 域 =====
+
+describe('tools 域 — 工具开关与确认链路', () => {
+  const TOOL_A = {
+    name: 'write_file',
+    description: 'd',
+    category: 'filesystem',
+    riskLevel: 'medium',
+    requiresPermission: true,
+    enabled: true,
+  };
+  const TOOL_B = { ...TOOL_A, name: 'run_command', riskLevel: 'high' };
+
+  function makeCtx(): { ctx: IPCContext; raw: Record<string, unknown> } {
+    const raw = {
+      toolRegistry: {
+        listAllTools: vi.fn(() => [TOOL_A, TOOL_B]),
+        listTools: vi.fn(() => [TOOL_A, TOOL_B]),
+        setToolEnabled: vi.fn(),
+      },
+      confirmationHook: {
+        resolveConfirmation: vi.fn(),
+        resolveConfirmationsBatch: vi.fn(() => ['tc_1']),
+        getPendingConfirmations: vi.fn(() => []),
+        getRememberedDenials: vi.fn(() => []),
+        resetRememberedDenial: vi.fn(() => true),
+        setAutoExecute: vi.fn(),
+        getAutoExecuteList: vi.fn(() => []),
+      },
+      agentEngineManager: { setToolsAll: vi.fn() },
+      configService: { set: vi.fn() },
+      toolsReadyRef: { ready: true, toolCount: 2 },
+    };
+    return { ctx: raw as unknown as IPCContext, raw };
+  }
+
+  it('tools:list 透传字段', async () => {
+    const { ctx } = makeCtx();
+    registerToolHandlers(ctx);
+    const list = (await getHandler('tools:list')(null)) as Array<Record<string, unknown>>;
+    expect(list).toHaveLength(2);
+    expect(list[0]).toMatchObject({ name: 'write_file', riskLevel: 'medium', enabled: true });
+  });
+
+  it('tools:toggle 未知工具拒绝（防配置 key 污染）且不触达 registry/config', async () => {
+    const { ctx, raw } = makeCtx();
+    registerToolHandlers(ctx);
+    const r = await getHandler('tools:toggle')(null, 'not_a_tool', true);
+    expect(r).toMatchObject({ success: false });
+    expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
+    expect((raw.toolRegistry as { setToolEnabled: Mock }).setToolEnabled).not.toHaveBeenCalled();
+  });
+
+  it('tools:toggle 合法路径：持久化配置 + registry + 引擎工具列表三处同步', async () => {
+    const { ctx, raw } = makeCtx();
+    registerToolHandlers(ctx);
+    const r = await getHandler('tools:toggle')(null, 'write_file', false);
+    expect(r).toEqual({ success: true });
+    expect((raw.configService as { set: Mock }).set).toHaveBeenCalledWith(
+      'tools.write_file.enabled',
+      false,
+    );
+    expect((raw.toolRegistry as { setToolEnabled: Mock }).setToolEnabled).toHaveBeenCalledWith(
+      'write_file',
+      false,
+    );
+    expect((raw.agentEngineManager as { setToolsAll: Mock }).setToolsAll).toHaveBeenCalled();
+  });
+
+  it('tools:isReady 读取共享就绪引用', async () => {
+    const { ctx } = makeCtx();
+    registerToolHandlers(ctx);
+    expect(await getHandler('tools:isReady')(null)).toEqual({ ready: true, toolCount: 2 });
+  });
+
+  it('tool:confirmationResponse 校验结构（无效载荷被忽略）', async () => {
+    const { ctx, raw } = makeCtx();
+    registerToolHandlers(ctx);
+    const listener = getListener('tool:confirmationResponse');
+
+    // 处理器签名 (event, data) —— 首参为 event，载荷在第二参
+    listener(null, null);
+    listener(null, { approved: true });
+    listener(null, { toolCallId: 'tc_1', approved: 'yes' });
+
+    const hook = (raw.confirmationHook as { resolveConfirmation: Mock }).resolveConfirmation;
+    expect(hook).not.toHaveBeenCalled();
+
+    listener(null, { toolCallId: 'tc_1', approved: true, remember: true, autoExecute: false });
+    expect(hook).toHaveBeenCalledWith('tc_1', true, true, false);
+  });
+
+  it('tool:confirmationResponseBatch 校验 toolCallIds 数组', async () => {
+    const { ctx, raw } = makeCtx();
+    registerToolHandlers(ctx);
+    const listener = getListener('tool:confirmationResponseBatch');
+    const hook = (raw.confirmationHook as { resolveConfirmationsBatch: Mock })
+      .resolveConfirmationsBatch;
+
+    listener(null, { toolCallIds: 'tc_1', approved: true });
+    listener(null, { toolCallIds: [], approved: true });
+    listener(null, { toolCallIds: ['tc_1', 42], approved: true });
+    expect(hook).not.toHaveBeenCalled();
+
+    listener(null, { toolCallIds: ['tc_1', 'tc_2'], approved: false, remember: true });
+    expect(hook).toHaveBeenCalledWith(['tc_1', 'tc_2'], false, true, false);
+  });
+
+  it('tool:setAutoExecute 未知工具拒绝；拒绝记忆接口透传 sessionId', async () => {
+    const { ctx, raw } = makeCtx();
+    registerToolHandlers(ctx);
+
+    expect(await getHandler('tool:setAutoExecute')(null, 'nope', true)).toMatchObject({
+      success: false,
+    });
+    expect(await getHandler('tool:setAutoExecute')(null, 'write_file', 'yes')).toMatchObject({
+      success: false,
+    });
+    expect(await getHandler('tool:setAutoExecute')(null, 'write_file', true)).toEqual({
+      success: true,
+    });
+
+    await getHandler('tool:getRememberedDenials')(null, 'sess-9');
+    expect(
+      (raw.confirmationHook as { getRememberedDenials: Mock }).getRememberedDenials,
+    ).toHaveBeenCalledWith('sess-9');
+  });
+});
+
+// ===== config 域 =====
+
+describe('config 域 — 配置写入与审计', () => {
+  function makeCtx(overrides: Record<string, unknown> = {}): {
+    ctx: IPCContext;
+    raw: Record<string, unknown>;
+  } {
+    const raw = {
+      configService: {
+        get: vi.fn((key: string) => (key === 'llm.provider' ? 'deepseek' : null)),
+        set: vi.fn(),
+      },
+      auditService: { log: vi.fn() },
+      agentEngineManager: { updateConfigAll: vi.fn() },
+      orchestrator: { updateDefaultConfig: vi.fn() },
+      confirmationHook: { setConfirmationTimeout: vi.fn() },
+      reloadAdapter: vi.fn(() => true),
+      ...overrides,
+    };
+    return { ctx: raw as unknown as IPCContext, raw };
+  }
+
+  it('config:get / config:set 类型校验矩阵', async () => {
+    const { ctx, raw } = makeCtx();
+    registerConfigHandlers(ctx);
+
+    await getHandler('config:get')(null, 'ui.theme');
+    expect((raw.configService as { get: Mock }).get).toHaveBeenCalledWith('ui.theme');
+
+    expect(await getHandler('config:set')(null, '', 'x')).toMatchObject({ success: false });
+    expect(await getHandler('config:set')(null, 'k', { nested: true })).toMatchObject({
+      success: false,
+    });
+    expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
+  });
+
+  it('config:set 敏感值脱敏入审计（明文 API Key 不落审计日志）', async () => {
+    const { ctx, raw } = makeCtx();
+    registerConfigHandlers(ctx);
+
+    await getHandler('config:set')(null, 'llm.apiKey', 'sk-test-1234567890');
+
+    const auditCall = (raw.auditService as { log: Mock }).log.mock.calls[0][0] as {
+      target: string;
+      details: { value: unknown };
+    };
+    expect(auditCall.target).toBe('llm.apiKey');
+    expect(auditCall.details.value).toBe('***7890');
+  });
+
+  it('config:setBatch 非法载荷整体拒绝（非数组 / 空 / 坏 key / 坏值类型）', async () => {
+    const { ctx, raw } = makeCtx();
+    registerConfigHandlers(ctx);
+
+    for (const bad of [null, [], [{ key: '', value: 1 }], [{ key: 'k', value: {} }]]) {
+      expect(await getHandler('config:setBatch')(null, bad)).toMatchObject({ success: false });
+    }
+    expect((raw.configService as { set: Mock }).set).not.toHaveBeenCalled();
+  });
+
+  it('config:setBatch 合法路径：逐条写入 + 审计 + 广播；Provider 变更先清 apiKey', async () => {
+    const { ctx, raw } = makeCtx();
+    registerConfigHandlers(ctx);
+
+    const r = await getHandler('config:setBatch')(null, [
+      { key: 'ui.theme', value: 'light' },
+      { key: 'llm.provider', value: 'ollama' },
+      { key: 'llm.model', value: 'qwen3:8b' },
+    ]);
+    expect(r).toEqual({ success: true });
+
+    const set = (raw.configService as { set: Mock }).set;
+    // Provider 变更（deepseek → ollama）在写入前先清 apiKey（C-1 契约）
+    expect(set).toHaveBeenCalledWith('llm.apiKey', '');
+    expect(set).toHaveBeenCalledWith('ui.theme', 'light');
+    expect(set).toHaveBeenCalledWith('llm.provider', 'ollama');
+    expect(set).toHaveBeenCalledWith('llm.model', 'qwen3:8b');
+
+    // 每条写入都有审计记录
+    expect((raw.auditService as { log: Mock }).log).toHaveBeenCalledTimes(3);
+    // 配置变更广播到渲染进程（前端 store 实时更新）
+    const broadcastKeys = broadcastMock.mock.calls
+      .filter(([ch]) => ch === 'config:changed')
+      .map(([, payload]) => (payload as { key: string }).key);
+    expect(broadcastKeys).toEqual(
+      expect.arrayContaining(['ui.theme', 'llm.provider', 'llm.model']),
+    );
+  });
+
+  it('config:setBatch 中 LLM key 变更触发 reloadAdapter；失败时整体报错', async () => {
+    const { ctx, raw } = makeCtx({ reloadAdapter: vi.fn(() => false) });
+    registerConfigHandlers(ctx);
+
+    const r = await getHandler('config:setBatch')(null, [{ key: 'llm.model', value: 'm' }]);
+    expect(r).toMatchObject({ success: false });
+    expect(raw.reloadAdapter as Mock).toHaveBeenCalled();
+  });
+});

electron/ipc/agent.ts

@@ -18,6 +18,7 @@ import type { MetonaMessage, MetonaStreamEvent, MetonaError } from '../harness/t
 import { MetonaErrorCode, MetonaStreamEventType } from '../harness/types';
 import { estimateMessagesTokens } from '../harness/utils/token-estimator';
 import { DeepSeekAdapter } from '../harness/adapters/deepseek.adapter';
+import { OllamaAdapter } from '../harness/adapters/ollama.adapter';
 import log from 'electron-log';
 
 /** 单会话的 text_delta 节流状态 */
@@ -439,11 +440,17 @@ export function registerAgentHandlers(ctx: IPCContext): void {
           .map((att, i) => {
             const typeLabel =
               att.type === 'image' ? 'image' : att.type === 'text' ? 'text file' : 'file';
+            // v0.7.2 A5: 文本附件被上传入口截断（512KB 上限）时，明确告知 LLM 内容不完整，
+            // 防止模型把残缺内容当作完整文件事实
+            const truncatedNote =
+              (att as { truncated?: boolean }).truncated === true
+                ? ' (TRUNCATED — only the first 512KB is included; the full content is NOT available)'
+                : '';
             const note =
               att.type === 'image'
                 ? 'already provided to you via vision capability — you can SEE it directly, do NOT call view_image or any tool to read it again'
                 : att.type === 'text'
-                  ? 'content already inlined in the user message, do NOT search in workspace or read it again'
+                  ? `content${truncatedNote} already inlined in the user message, do NOT search in workspace or read it again`
                   : 'uploaded directly by user, do NOT search in workspace';
             return `${i + 1}. [${typeLabel}] ${att.name} — ${note}`;
           })
@@ -723,6 +730,93 @@ export function registerAgentHandlers(ctx: IPCContext): void {
     }
   });
 
+  // ===== v0.7.2 P3-9: 动态模型列表（六家 adapter 的 listModels 首次获得 IPC 消费者）=====
+  // 此前 DeepSeek/OpenAI/Ollama 均实现了实时模型发现（/models、/api/tags），
+  // 但 preload/IPC 层无任何通道 —— 设置页模型输入只能靠用户手填。
+  // 契约：列表基于"已保存"的 LLM 配置（与引擎实际使用的 adapter 同源）；
+  // 配置不完整时显式失败，绝不返回兜底 adapter 的误导性静态列表。
+  ipcMain.handle('llm:listModels', async () => {
+    try {
+      const provider = configService.get<string>('llm.provider') ?? '';
+      const model = configService.get<string>('llm.model') ?? '';
+      const apiKey = configService.get<string>('llm.apiKey') || '';
+      if (!provider || !model) {
+        return { success: false, error: 'LLM 未配置（Provider/Model 为空），无法获取模型列表' };
+      }
+      if (!apiKey && provider !== 'ollama') {
+        return { success: false, error: 'API Key 未配置，无法获取模型列表' };
+      }
+      // 列表基于当前已保存配置 —— 先幂等重载 adapter（配置签名未变时为 no-op）
+      if (!ctx.reloadAdapter()) {
+        return { success: false, error: 'LLM 配置校验失败，请先在设置中修正配置' };
+      }
+      const adapter = agentEngineManager.getAdapter();
+      if (!adapter.listModels) {
+        return { success: false, error: '当前 Provider 不支持模型列表查询' };
+      }
+      const models = await adapter.listModels();
+      return { success: true, data: models };
+    } catch (error) {
+      log.warn('[AGENT] listModels failed:', (error as Error).message);
+      return { success: false, error: (error as Error).message };
+    }
+  });
+
+  // ===== v0.7.2 P3-10: Ollama 模型下载（adapter.pullModel 首次接线 IPC/UI）=====
+  // v0.6.4 P4-1 已实现 pull 的进度回调与外部取消信号，但主进程侧零消费者。
+  // 契约：同一时刻仅允许一个下载任务（全局 AbortController）；
+  // 进度经 llm:ollamaPullProgress 广播（{ model, status, completed?, total? }），
+  // 结束（成功/失败/取消）统一广播 llm:ollamaPullEnded 供前端复位 UI。
+  let ollamaPullController: AbortController | null = null;
+
+  ipcMain.handle('llm:ollamaPull', async (_event, modelName: unknown) => {
+    if (typeof modelName !== 'string' || !modelName.trim()) {
+      return { success: false, error: 'Invalid model name' };
+    }
+    // 模型名仅进入 JSON body（不经 shell），仍做字符白名单防转义边界
+    // 合法形态如 qwen3:8b / llama3.1:70b-instruct-q4_K_M / user/model
+    if (!/^[A-Za-z0-9._:/-]+$/.test(modelName.trim())) {
+      return { success: false, error: `Invalid model name: ${modelName.slice(0, 60)}` };
+    }
+    const adapter = agentEngineManager.getAdapter();
+    if (!(adapter instanceof OllamaAdapter)) {
+      return { success: false, error: '仅 Ollama Provider 支持模型下载' };
+    }
+    if (ollamaPullController) {
+      return { success: false, error: '已有模型下载任务进行中，请先取消' };
+    }
+    const controller = new AbortController();
+    ollamaPullController = controller;
+    const trimmed = modelName.trim();
+    try {
+      await adapter.pullModel(
+        trimmed,
+        (progress) => {
+          broadcast('llm:ollamaPullProgress', { model: trimmed, ...progress });
+        },
+        controller.signal,
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+        aborted: controller.signal.aborted,
+      };
+    } finally {
+      ollamaPullController = null;
+      broadcast('llm:ollamaPullEnded', { model: trimmed });
+    }
+  });
+
+  ipcMain.handle('llm:ollamaPullCancel', async () => {
+    if (!ollamaPullController) {
+      return { success: false, error: '没有进行中的下载任务' };
+    }
+    ollamaPullController.abort();
+    return { success: true };
+  });
+
   // ===== 中断会话 =====
 
   ipcMain.handle('agent:abortSession', async (_event, sessionId) => {

electron/ipc/mcp.ts

@@ -17,7 +17,14 @@ export function registerMCPHandlers(ctx: IPCContext): void {
     'mcp:addServer',
     async (
       _event,
-      config: { name: string; transport: string; command?: string; args?: string[]; url?: string },
+      config: {
+        name: string;
+        transport: string;
+        command?: string;
+        args?: string[];
+        url?: string;
+        headers?: Record<string, string>;
+      },
     ) => {
       // M-38 修复: 完整参数校验，防止字段缺失或类型不符导致异常行为
       if (!config || typeof config !== 'object') {
@@ -56,6 +63,33 @@ export function registerMCPHandlers(ctx: IPCContext): void {
           return { success: false, error: 'Invalid url format' };
         }
       }
+      // v0.7.2 P2-8: headers 校验 —— 可选，必须是扁平的 string→string 对象。
+      // 上限约束（≤20 项、键 ≤128 字符、值 ≤4096 字符）防止把 headers
+      // 当作数据通道滥用；非法条目整体拒绝而非静默丢弃（配置期显式失败）。
+      if (config.headers !== undefined) {
+        if (
+          !config.headers ||
+          typeof config.headers !== 'object' ||
+          Array.isArray(config.headers)
+        ) {
+          return {
+            success: false,
+            error: 'headers must be an object of string key-value pairs',
+          };
+        }
+        const entries = Object.entries(config.headers as Record<string, unknown>);
+        if (entries.length > 20) {
+          return { success: false, error: 'headers supports at most 20 entries' };
+        }
+        for (const [k, v] of entries) {
+          if (typeof k !== 'string' || !k.trim() || k.length > 128) {
+            return { success: false, error: `Invalid header name: ${String(k).slice(0, 40)}` };
+          }
+          if (typeof v !== 'string' || v.length > 4096) {
+            return { success: false, error: `Invalid header value for "${k.slice(0, 40)}"` };
+          }
+        }
+      }
       try {
         await mcpManager.addServer({
           name: config.name,
@@ -63,6 +97,7 @@ export function registerMCPHandlers(ctx: IPCContext): void {
           command: config.command,
           args: config.args,
           url: config.url,
+          headers: config.headers as Record<string, string> | undefined, // 已逐项校验
           enabled: true,
         });
         log.info(`MCP server added: ${config.name}`);

electron/ipc/sessions.ts

@@ -61,9 +61,17 @@ export function registerSessionHandlers(ctx: IPCContext): void {
     return { success: sessionService.deleteMessage(messageId) };
   });
 
+  // v0.7.2 A1 根治: 语义修正 —— "清空会话"的成功判定是"操作完成"而非"有行被删除"。
+  // 原实现透传 DELETE 影响行数（changes > 0），空会话清空会返回 success:false，
+  // 导致前端误报失败而不清空本地状态（/clear 断链的 IPC 侧根源之一）。
   ipcMain.handle('sessions:clearMessages', async (_event, sessionId: unknown) => {
     if (!isValidSessionId(sessionId)) return { success: false, error: 'Invalid sessionId' };
-    return { success: sessionService.clearMessages(sessionId) };
+    try {
+      sessionService.clearMessages(sessionId);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: (error as Error).message };
+    }
   });
 
   // P2-11: 消息截断（编辑重发 / 重新生成）