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/harness/agent-loop/__tests__/engine-stream-contract.test.ts

@@ -0,0 +1,230 @@
+/**
+ * v0.8.0 P0-5: 引擎流结束契约测试 —— "模型思考着会话停止"根治回归防线。
+ *
+ * 钉住 chatStreamWithRetry 的流结束契约（P0-2）与 finish_reason 贯通（P0-1）：
+ * 1. 零产出流 → EmptyResponseError → 退避重试 → 重试耗尽 ERROR；
+ * 2. reasoning-only + finish_reason=length → 一次性降级重试（thinkingEnabled=false）
+ *    → 降级后成功 COMPLETED；
+ * 3. 降级重试仍 length → OutputTruncatedError → ERROR 事件携带
+ *    MetonaErrorCode.OUTPUT_LENGTH_EXCEEDED；
+ * 4. 有正文 + length → COMPLETED 且最终 DONE 事件携带 finishReason='length'；
+ * 5. 引擎最终 DONE 贯通最后一轮 step.finishReason。
+ */
+
+import { describe, it, expect } from 'vitest';
+import { AgentLoopEngine } from '../engine';
+import type { AgentLoopOutput } from '../types';
+import type {
+  MetonaRequest,
+  MetonaStreamEvent,
+  IMetonaProviderAdapter,
+  MetonaResponse,
+} from '../../types';
+import { MetonaStreamEventType, MetonaErrorCode } from '../../types';
+
+const SYSTEM_PROMPT = {
+  roleDefinition: 'test',
+  outputConstraints: '',
+  safetyGuidelines: '',
+};
+
+function makeAdapter(
+  script: (request: MetonaRequest) => MetonaStreamEvent[],
+): IMetonaProviderAdapter & { calls: MetonaRequest[] } {
+  const calls: MetonaRequest[] = [];
+  const adapter = {
+    providerId: 'mock' as const,
+    supportedModels: ['m'],
+    supportsToolCalling: true,
+    supportsThinking: true,
+    calls,
+    getContextWindow(): number {
+      return 128_000;
+    },
+    async send(_request: MetonaRequest): Promise<MetonaResponse> {
+      throw new Error('send() not expected in this test');
+    },
+    async *sendStream(request: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
+      calls.push(request);
+      for (const ev of script(request)) {
+        yield ev;
+      }
+    },
+  };
+  return adapter as unknown as IMetonaProviderAdapter & { calls: MetonaRequest[] };
+}
+
+function makeEngine(adapter: IMetonaProviderAdapter, retryCount = 1): AgentLoopEngine {
+  return new AgentLoopEngine(
+    {
+      maxIterations: 3,
+      totalTimeoutMs: 10_000,
+      retryCount,
+      thinkingEnabled: true,
+      thinkingEffort: 'high',
+      contextWindow: 128_000,
+    },
+    adapter,
+  );
+}
+
+function textDelta(t: string): MetonaStreamEvent {
+  return {
+    type: MetonaStreamEventType.TEXT_DELTA,
+    requestId: 'r',
+    sessionId: 's',
+    iteration: 1,
+    seq: 0,
+    timestamp: Date.now(),
+    delta: t,
+  };
+}
+
+function reasoningDelta(t: string): MetonaStreamEvent {
+  return {
+    type: MetonaStreamEventType.REASONING_DELTA,
+    requestId: 'r',
+    sessionId: 's',
+    iteration: 1,
+    seq: 0,
+    timestamp: Date.now(),
+    delta: t,
+  };
+}
+
+function doneEvent(finishReason?: string): MetonaStreamEvent {
+  return {
+    type: MetonaStreamEventType.DONE,
+    requestId: 'r',
+    sessionId: 's',
+    iteration: 1,
+    seq: 0,
+    timestamp: Date.now(),
+    ...(finishReason ? { finishReason } : {}),
+  };
+}
+
+describe('engine stream-end contract (v0.8.0 P0-2)', () => {
+  it('scenario 2: reasoning-only + length → one degraded retry with thinking disabled → COMPLETED', async () => {
+    let call = 0;
+    const adapter = makeAdapter((req) => {
+      call++;
+      if (call === 1) {
+        // 第一次：思考烧满输出预算（reasoning-only + length 截断）
+        expect(req.params.thinkingEnabled).toBe(true);
+        return [reasoningDelta('thinking...'), doneEvent('length')];
+      }
+      // 降级重试：thinkingEnabled 必须已被引擎置 false
+      expect(req.params.thinkingEnabled).toBe(false);
+      return [textDelta('answer'), doneEvent('stop')];
+    });
+    const engine = makeEngine(adapter);
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+
+    expect(output.terminationReason).toBe('completed');
+    expect(output.finalAnswer).toBe('answer');
+    expect(adapter.calls.length).toBe(2);
+    // 降级重试经过 RETRY 事件（引擎消费后向渲染层转 STREAM_RESET）
+    expect(events.some((e) => e.type === MetonaStreamEventType.STREAM_RESET)).toBe(true);
+  });
+
+  it('scenario 2b: degraded retry still length → OUTPUT_LENGTH_EXCEEDED error (no infinite retry)', async () => {
+    const adapter = makeAdapter(() => [reasoningDelta('thinking...'), doneEvent('length')]);
+    const engine = makeEngine(adapter);
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const output: AgentLoopOutput = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+
+    // 恰好两次调用（原始 + 一次性降级重试），随后终止
+    expect(adapter.calls.length).toBe(2);
+    expect(output.terminationReason).toBe('error');
+    const errorEvent = events.find((e) => e.type === MetonaStreamEventType.ERROR);
+    expect(errorEvent).toBeDefined();
+    expect(errorEvent?.error?.code).toBe(MetonaErrorCode.OUTPUT_LENGTH_EXCEEDED);
+  });
+
+  it('scenario 1: zero-content stream → retryable → retry exhausted → ERROR', async () => {
+    const adapter = makeAdapter(() => []);
+    const engine = makeEngine(adapter, 1);
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+
+    expect(output.terminationReason).toBe('error');
+    expect(adapter.calls.length).toBe(2); // 原始 1 次 + 重试 1 次（retryCount=1）
+    const errorEvent = events.find((e) => e.type === MetonaStreamEventType.ERROR);
+    expect(errorEvent?.error?.message).toContain('empty stream');
+  });
+
+  it('scenario 4: text + length → COMPLETED with DONE.finishReason=length (no retry)', async () => {
+    const adapter = makeAdapter(() => [textDelta('partial answer'), doneEvent('length')]);
+    const engine = makeEngine(adapter);
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+
+    expect(output.terminationReason).toBe('completed');
+    expect(output.finalAnswer).toBe('partial answer');
+    expect(adapter.calls.length).toBe(1); // 有产出不重试
+    const done = events.find((e) => e.type === MetonaStreamEventType.DONE);
+    expect(done?.finishReason).toBe('length');
+  });
+
+  it('P0-1: normal stop → DONE carries finishReason=stop from adapter', async () => {
+    const adapter = makeAdapter(() => [textDelta('ok'), doneEvent('stop')]);
+    const engine = makeEngine(adapter);
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+
+    expect(output.terminationReason).toBe('completed');
+    const done = events.find((e) => e.type === MetonaStreamEventType.DONE);
+    expect(done?.finishReason).toBe('stop');
+  });
+
+  it('reasoning-only + natural stop (no length) → retryable empty response path', async () => {
+    const adapter = makeAdapter(() => [reasoningDelta('hmm'), doneEvent('stop')]);
+    const engine = makeEngine(adapter, 1);
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+    // 无产出且非 length 截断 → EmptyResponseError（可重试）→ 重试耗尽 ERROR
+    expect(output.terminationReason).toBe('error');
+    expect(adapter.calls.length).toBe(2);
+  });
+});

electron/harness/agent-loop/__tests__/engine-stream-reliability.test.ts

@@ -0,0 +1,243 @@
+/**
+ * v0.8.0 P0-5 回归测试（第二批）：流可靠性四件套的剩余项。
+ *
+ * 1. parseSSEStream 集成级空闲超时：挂死 ReadableStream → 60s 无数据 →
+ *    SseUpstreamError(504)（P1-2 防线的集成真实性，此前仅纯函数层覆盖）；
+ * 2. SseUpstreamError(504) 经引擎 isRetryableError 归类 → 退避重试后成功；
+ * 3. REASONING_DELTA 持续输出中 abort → USER_INTERRUPT（"思考中点停止"场景）；
+ * 4. 引擎 P4-2：上一 run 卡死（不响应 abort）→ 新 run 等待 30s → 强制 abort
+ *    → 再等 5s → 抛错（防"会话永久排队"）。
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { parseSSEStream, SseUpstreamError } from '../../adapters/shared/sse-stream';
+import { AgentLoopEngine } from '../engine';
+import type { MetonaRequest, MetonaStreamEvent, IMetonaProviderAdapter } from '../../types';
+import { MetonaStreamEventType } from '../../types';
+
+const SYSTEM_PROMPT = {
+  roleDefinition: 'test',
+  outputConstraints: '',
+  safetyGuidelines: '',
+};
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+// ===== 1. 集成级空闲超时 =====
+
+describe('parseSSEStream integrated idle timeout (P0-5 #2)', () => {
+  function makeHungBody(): ReadableStream<Uint8Array> {
+    return {
+      getReader: () => ({
+        // 永不 resolve 的 read —— 模拟"服务器保活但不再推数据"
+        read: () => new Promise<never>(() => {}),
+        releaseLock: () => {},
+      }),
+    } as unknown as ReadableStream<Uint8Array>;
+  }
+
+  it('挂死流 60s 无数据 → SseUpstreamError(504)', async () => {
+    vi.useFakeTimers();
+    const iterator = parseSSEStream(makeHungBody(), 'r', 's', 1);
+    let thrown: unknown = null;
+    const firstRead = iterator.next().catch((e: unknown) => {
+      thrown = e;
+      return { done: true, value: undefined } as const;
+    });
+    // 推进 61s：IDLE_TIMEOUT_MS=60_000 触发 idle controller → read() 竞速失败
+    await vi.advanceTimersByTimeAsync(61_000);
+    await firstRead;
+    expect(thrown).toBeInstanceOf(SseUpstreamError);
+    expect((thrown as SseUpstreamError).status).toBe(504);
+    expect((thrown as Error).message).toContain('idle timeout');
+  });
+});
+
+// ===== 2. SseUpstreamError(504) → 引擎重试 =====
+
+describe('engine: SseUpstreamError(504) retry classification (P0-5 #3)', () => {
+  it('504 首败 → 退避重试 → 第二次流成功 → COMPLETED', async () => {
+    let call = 0;
+    const adapter = {
+      providerId: 'mock' as const,
+      supportedModels: ['m'],
+      supportsToolCalling: true,
+      supportsThinking: true,
+      getContextWindow: () => 128_000,
+      async send(): Promise<unknown> {
+        throw new Error('not used');
+      },
+      async *sendStream(_r: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
+        call++;
+        if (call === 1) {
+          throw new SseUpstreamError('Stream idle timeout after 60000ms (no data received)', {
+            status: 504,
+          });
+        }
+        yield {
+          type: MetonaStreamEventType.TEXT_DELTA,
+          requestId: 'r',
+          sessionId: 's',
+          iteration: 1,
+          seq: 0,
+          timestamp: Date.now(),
+          delta: 'recovered',
+        };
+        yield {
+          type: MetonaStreamEventType.DONE,
+          requestId: 'r',
+          sessionId: 's',
+          iteration: 1,
+          seq: 1,
+          timestamp: Date.now(),
+          finishReason: 'stop',
+        };
+      },
+    } as unknown as IMetonaProviderAdapter;
+
+    const engine = new AgentLoopEngine(
+      { maxIterations: 3, totalTimeoutMs: 15_000, retryCount: 2, contextWindow: 128_000 },
+      adapter,
+    );
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+    const output = await engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+    expect(output.terminationReason).toBe('completed');
+    expect(output.finalAnswer).toBe('recovered');
+    expect(call).toBe(2);
+    // 重试经过 RETRY 事件（引擎消费后向渲染层转 STREAM_RESET）
+    expect(events.some((e) => e.type === MetonaStreamEventType.STREAM_RESET)).toBe(true);
+  });
+});
+
+// ===== 3. REASONING_DELTA 中途 abort =====
+
+describe('engine: abort during reasoning stream (P0-5 #4)', () => {
+  it('思考增量持续输出中 abort → USER_INTERRUPT，迟到 reasoning 不再产出事件', async () => {
+    const adapter = {
+      providerId: 'mock' as const,
+      supportedModels: ['m'],
+      supportsToolCalling: true,
+      supportsThinking: true,
+      getContextWindow: () => 128_000,
+      async send(): Promise<unknown> {
+        throw new Error('not used');
+      },
+      // 持续每 10ms 推送一个 reasoning delta，直到 abort 或 500 个（挂起）
+      async *sendStream(_r: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
+        for (let i = 0; i < 500; i++) {
+          if (_r.params.thinkingEnabled === false) return;
+          yield {
+            type: MetonaStreamEventType.REASONING_DELTA,
+            requestId: 'r',
+            sessionId: 's',
+            iteration: 1,
+            seq: i,
+            timestamp: Date.now(),
+            delta: `t${i};`,
+          };
+          await new Promise((r) => setTimeout(r, 10));
+        }
+        yield {
+          type: MetonaStreamEventType.DONE,
+          requestId: 'r',
+          sessionId: 's',
+          iteration: 1,
+          seq: 999,
+          timestamp: Date.now(),
+        };
+      },
+    } as unknown as IMetonaProviderAdapter;
+
+    const engine = new AgentLoopEngine(
+      { maxIterations: 3, totalTimeoutMs: 30_000, retryCount: 0, contextWindow: 128_000 },
+      adapter,
+    );
+    const events: MetonaStreamEvent[] = [];
+    engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
+
+    const run = engine.runStream(
+      { role: 'user', content: 'hi', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+    // 等待至少 3 个 reasoning delta 到达（确认流确实在思考态输出中）
+    await new Promise((r) => setTimeout(r, 80));
+    expect(
+      events.filter((e) => e.type === MetonaStreamEventType.REASONING_DELTA).length,
+    ).toBeGreaterThanOrEqual(3);
+    engine.abort();
+    const output = await run;
+    expect(output.terminationReason).toBe('user_interrupt');
+    const lastReasoningIdx = events
+      .map((e) => e.type)
+      .lastIndexOf(MetonaStreamEventType.REASONING_DELTA);
+    const doneIdx = events.findIndex((e) => e.type === MetonaStreamEventType.DONE);
+    // abort 生效后不再有迟到 reasoning（abort 尾巴过滤在引擎侧）
+    expect(lastReasoningIdx).toBeLessThan(doneIdx);
+  }, 15_000);
+});
+
+// ===== 4. P4-2: 上一 run 卡死 → 30s 强制 abort + 5s 再等待 → 抛错 =====
+
+describe('engine: stuck previous run force-abort path (P4-2)', () => {
+  it('上一 run 不响应 abort → 新 run 30s 超时强制 abort → 5s 后仍卡 → 抛错', async () => {
+    vi.useFakeTimers();
+    let released = false;
+    const stuckAdapter = {
+      providerId: 'mock' as const,
+      supportedModels: ['m'],
+      supportsToolCalling: true,
+      supportsThinking: true,
+      getContextWindow: () => 128_000,
+      async send(): Promise<unknown> {
+        throw new Error('not used');
+      },
+      // 第一次 run：永远挂起且不响应 abort（模拟卡死的底层 fetch）；
+      // 挂起生成器无 yield 属场景定义（require-yield 由下行指令豁免）
+      // eslint-disable-next-line require-yield
+      async *sendStream(): AsyncIterable<MetonaStreamEvent> {
+        while (!released) {
+          await new Promise(() => {});
+        }
+        return;
+      },
+    } as unknown as IMetonaProviderAdapter;
+
+    const engine = new AgentLoopEngine(
+      { maxIterations: 3, totalTimeoutMs: 600_000, retryCount: 0, contextWindow: 128_000 },
+      stuckAdapter,
+    );
+    const firstRun = engine.runStream(
+      { role: 'user', content: 'first', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+    firstRun.catch(() => {});
+
+    // 新消息进入 → 等待上一 run 结束（30s 超时）→ 强制 abort → 5s 再等待 → 抛错
+    const secondRun = engine.runStream(
+      { role: 'user', content: 'second', timestamp: Date.now() },
+      's1',
+      [],
+      SYSTEM_PROMPT,
+    );
+    const expectation = expect(secondRun).rejects.toThrow(/Previous run did not finish/i);
+
+    // 驱动 30s 等待超时 + 5s 强制 abort 等待
+    await vi.advanceTimersByTimeAsync(30_500);
+    await vi.advanceTimersByTimeAsync(5_500);
+    // 清理：放行挂死流，让 firstRun 收敛
+    released = true;
+    await expectation;
+  }, 20_000);
+});

electron/harness/agent-loop/engine.ts

@@ -48,6 +48,37 @@ class DeadLoopError extends Error {
   }
 }
 
+/**
+ * v0.8.0 P0-2: 空响应错误 — 流结束但零产出（无 reasoning、无正文、无工具调用）。
+ * 属可重试的瞬时故障（上游断流被 [DONE] 兜底合成 / 网关干净空响应），携带
+ * status=503 使 engine.isRetryableError 的 5xx 分支命中，走指数退避重试；
+ * 重试耗尽后以 ERROR 收尾并给用户明确文案（此前该形态被静默判定 COMPLETED，
+ * 即"模型思考着会话就停止"的根因之一）。
+ */
+export class EmptyResponseError extends Error {
+  readonly status = 503;
+  constructor(message: string) {
+    super(message);
+    this.name = 'EmptyResponseError';
+  }
+}
+
+/**
+ * v0.8.0 P0-2: 输出截断错误 — 思考耗尽型截断（reasoning 烧满输出预算、正文零字节，
+ * finish_reason=length），一次性降级重试（关闭思考）后仍复现时抛出。
+ * 不可重试（status=400），携带 code=OUTPUT_LENGTH_EXCEEDED（IR 预留错误码首次
+ * 投产），engine.finish() 据此向前端发送结构化错误；非可重试语义同时触发
+ * Provider 故障转移（备用 Provider 输出预算更大时即构成自愈）。
+ */
+export class OutputTruncatedError extends Error {
+  readonly status = 400;
+  readonly code = MetonaErrorCode.OUTPUT_LENGTH_EXCEEDED;
+  constructor(message: string) {
+    super(message);
+    this.name = 'OutputTruncatedError';
+  }
+}
+
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxIterations: 20,
   totalTimeoutMs: 600_000,
@@ -88,6 +119,12 @@ export class AgentLoopEngine extends EventEmitter {
   private lastRealInputTokens = 0;
   /** 当前 run 的唯一标识（用于前端过滤旧流事件） */
   private runId: string = '';
+  /**
+   * v0.8.0 P0-1: 最近一轮 LLM 流的 Provider 原生停止原因（归一化 OpenAI 语义）。
+   * 由 adapter DONE 事件携带、引擎捕获；finish() 据此在最终 DONE 事件上转发，
+   * 前端/TRACE 据此区分自然完成与输出上限截断。
+   */
+  private lastIterationFinishReason: string | undefined;
   /** 正在进行的 run Promise（用于 run lock，防止并发 run 污染状态） */
   private currentRunPromise: Promise<AgentLoopOutput> | null = null;
 
@@ -269,6 +306,8 @@ export class AgentLoopEngine extends EventEmitter {
     this.toolCallHistory = [];
     // v0.7.4 P4-1: 重置工具结果历史（进度信号，与调用历史按轮对应）
     this.toolResultHistory = [];
+    // v0.8.0 P0-1: 重置最近一轮停止原因
+    this.lastIterationFinishReason = undefined;
 
     try {
       await this.transitionTo(AgentLoopState.INIT);
@@ -316,6 +355,16 @@ export class AgentLoopEngine extends EventEmitter {
 
         const step = await this.executeOneIterationStream(request, sessionId);
         this.iterations.push(step);
+        // v0.8.0 P0-1: 记录最近一轮停止原因（供 finish() 的 DONE 事件转发）
+        this.lastIterationFinishReason = step.finishReason;
+
+        // v0.8.0 P0-2 回归根治: abort 优先级 —— 旧实现该检查位于 while 循环
+        // 末尾，若 abort 恰逢"零工具调用轮"（如思考中点停止），空轮会先命中
+        // 下方 COMPLETED 分支，把 USER_INTERRUPT 静默吞成 completed（与新
+        // 回归测试 engine-stream-reliability 同时发现）。此处前置检查修复。
+        if (this.aborted) {
+          return this.finish(TerminationReason.USER_INTERRUPT);
+        }
 
         // 将 assistant 回复加入消息历史
         // 崩溃修复（会话停止根因）: 原条件 `if (step.thought)` 在模型发起纯工具调用
@@ -499,13 +548,20 @@ export class AgentLoopEngine extends EventEmitter {
       let reasoningContent = '';
       const toolCallsBuffer = new Map<number, { name: string; argsBuffer: string }>();
       let tokenUsage: TokenUsage | undefined;
+      // v0.8.0 P0-1: 本轮流的 Provider 原生停止原因（adapter DONE 携带）
+      let iterationFinishReason: string | undefined;
 
       // 流式接收响应
       for await (const event of this.chatStreamWithRetry(request)) {
         if (this.aborted) break;
 
         // 过滤掉每轮的 DONE 事件 — 只在全部迭代完成后发送一个最终 DONE
-        if (event.type === MetonaStreamEventType.DONE) continue;
+        // v0.8.0 P0-1: 先捕获 adapter 携带的 Provider 原生停止原因再过滤 ——
+        // 引擎与 TRACE 据此区分自然完成与输出上限截断（length 此前完全不可见）
+        if (event.type === MetonaStreamEventType.DONE) {
+          if (event.finishReason) iterationFinishReason = event.finishReason;
+          continue;
+        }
 
         // 过滤掉 RETRY 类型的 ERROR 事件 — 不转发到前端，避免触发虚假错误 UI
         // RETRY 事件仅用于 Engine 内部清空缓冲区（见下方 switch 分支）
@@ -598,6 +654,11 @@ export class AgentLoopEngine extends EventEmitter {
       // === v0.2.0: PARSING 状态 — 解析流式缓冲区中的工具调用 ===
       await this.transitionTo(AgentLoopState.PARSING);
 
+      // v0.8.0 P0-1: 记录本轮停止原因到迭代步骤（TRACE/审计/前端提示的输入）
+      if (iterationFinishReason) {
+        step.finishReason = iterationFinishReason;
+      }
+
       // L-19 修复: 提取 finalizeToolCallsFromBuffer 子方法（PARSING 阶段）
       this.finalizeToolCallsFromBuffer(step, toolCallsBuffer);
 
@@ -1031,6 +1092,11 @@ export class AgentLoopEngine extends EventEmitter {
     let attempt = 0;
     let currentAdapter = this.adapter;
     let failoverUsed = false;
+    // v0.8.0 P0-2: 降级重试状态。思考耗尽型截断（reasoning 烧满输出预算、正文
+    // 零字节）时以 thinkingEnabled=false 重发一次（每 run 最多一次）；activeRequest
+    // 被替换后，后续的重试与故障转移均使用降级版请求（降级跨故障转移保持）。
+    let degradedThinkingRetryUsed = false;
+    let activeRequest = request;
 
     while (true) {
       try {
@@ -1038,9 +1104,9 @@ export class AgentLoopEngine extends EventEmitter {
           // 重试时：先发送一个 retry 事件，让 UI 清空已接收的 delta
           yield {
             type: MetonaStreamEventType.ERROR,
-            requestId: request.meta.requestId,
-            sessionId: request.meta.sessionId,
-            iteration: request.meta.iteration,
+            requestId: activeRequest.meta.requestId,
+            sessionId: activeRequest.meta.sessionId,
+            iteration: activeRequest.meta.iteration,
             seq: 0,
             timestamp: Date.now(),
             error: {
@@ -1050,7 +1116,86 @@ export class AgentLoopEngine extends EventEmitter {
             },
           };
         }
-        yield* currentAdapter.sendStream(request);
+        // v0.8.0 P0-2: 逐事件跟踪内容产出与停止原因（原 yield* 直通改显式转发）。
+        // yield* 正常返回后执行流结束契约检查；异常路径不进入检查（走 catch 重试）。
+        // - sawThought: 思考有产出（REASONING_DELTA）
+        // - sawOutput:  正文/工具调用有产出（TEXT_DELTA / TOOL_CALL_*）
+        // - lastFinishReason: adapter DONE 携带的 Provider 原生停止原因
+        let sawThought = false;
+        let sawOutput = false;
+        let lastFinishReason: string | undefined;
+        for await (const event of currentAdapter.sendStream(activeRequest)) {
+          if (event.type === MetonaStreamEventType.REASONING_DELTA) {
+            sawThought = true;
+          }
+          if (
+            event.type === MetonaStreamEventType.TEXT_DELTA ||
+            event.type === MetonaStreamEventType.TOOL_CALL_DELTA ||
+            event.type === MetonaStreamEventType.TOOL_CALL_COMPLETE
+          ) {
+            sawOutput = true;
+          }
+          if (event.type === MetonaStreamEventType.DONE && event.finishReason) {
+            lastFinishReason = event.finishReason;
+          }
+          yield event;
+        }
+
+        // ===== 流结束契约检查（根治"空回复 → 静默 COMPLETED → 会话无声停止"）=====
+        if (!sawOutput) {
+          if (!sawThought) {
+            // 零产出流：连接中断被 [DONE] 兜底合成 / 上游干净空响应 —— 可重试
+            // 瞬时故障（status=503 命中 5xx 重试分支），重试耗尽后 ERROR 收尾
+            throw new EmptyResponseError(
+              'Model returned an empty stream (no reasoning, no text, no tool calls). ' +
+                'This is usually caused by an upstream connection drop or an output-limit cutoff.',
+            );
+          }
+          if (lastFinishReason === 'length') {
+            // 思考耗尽型截断（v0.7.4 生产事故形态：finish_reason=length、正文零
+            // 字节）—— 先做一次性降级重试（临时关闭思考重发），仍复现则终止。
+            if (!degradedThinkingRetryUsed && activeRequest.params.thinkingEnabled === true) {
+              degradedThinkingRetryUsed = true;
+              attempt = 0;
+              activeRequest = {
+                ...activeRequest,
+                params: { ...activeRequest.params, thinkingEnabled: false },
+              };
+              log.warn(
+                '[AgentLoop] Output budget exhausted by reasoning (finish_reason=length, empty content) — retrying once with thinking disabled',
+              );
+              yield {
+                type: MetonaStreamEventType.ERROR,
+                requestId: activeRequest.meta.requestId,
+                sessionId: activeRequest.meta.sessionId,
+                iteration: activeRequest.meta.iteration,
+                seq: 0,
+                timestamp: Date.now(),
+                error: {
+                  code: MetonaErrorCode.RETRY,
+                  message: 'Thinking consumed the output budget — retrying with thinking disabled',
+                  retryable: true,
+                },
+              };
+              continue;
+            }
+            // 降级重试不可用（已用 / 思考本就关闭）仍截断 —— 终止：携带 IR 预留
+            // 的 OUTPUT_LENGTH_EXCEEDED 码，finish() 映射为结构化错误事件，
+            // 非 retryable 同时触发 Provider 故障转移（备用预算更大即自愈）。
+            throw new OutputTruncatedError(
+              'The model consumed the entire output token budget on reasoning and produced no answer ' +
+                '(finish_reason=length). Raise the max output limit, disable thinking, or switch to a model with a larger output budget.',
+            );
+          }
+          // 思考有产出但自然结束且零正文（罕见的服务端异常收尾）—— 与零产出流
+          // 同按可重试空响应处理（retryCount 兜底防循环）
+          throw new EmptyResponseError(
+            'Model stream ended after reasoning without any answer content.',
+          );
+        }
+        // sawOutput=true：正文/工具调用已有产出。length 截断场景不再重试 ——
+        // 工具参数截断由 _truncatedArguments 自愈（v0.6.3 契约）、正文截断由
+        // DONE.finishReason='length' 驱动前端截断提醒（P0-4）。
         return;
       } catch (error) {
         if (this.aborted) throw error;
@@ -1136,6 +1281,11 @@ export class AgentLoopEngine extends EventEmitter {
 
   /** 判断错误是否可重试 */
   private isRetryableError(error: unknown): boolean {
+    // v0.8.0 P0-2: 流结束契约错误的显式归类（EmptyResponseError 自带 status=503、
+    // OutputTruncatedError 自带 status=400，本可由下方 5xx/4xx 分支覆盖；此处
+    // 显式 instanceof 使两类新错误的语义不依赖 status 字段约定）
+    if (error instanceof EmptyResponseError) return true;
+    if (error instanceof OutputTruncatedError) return false;
     const err = error as { status?: number; code?: string; message?: string };
     // 429 Too Many Requests — 可重试
     if (err.status === 429) return true;
@@ -1482,9 +1632,17 @@ export class AgentLoopEngine extends EventEmitter {
     if ((reason === TerminationReason.ERROR || reason === TerminationReason.DEAD_LOOP) && error) {
       // v0.3.17: 识别 ContentFilterError，映射为 CONTENT_FILTERED 错误码 + 友好消息
       // v0.6.4: 流式路径的拦截以 err.code='content_filtered' 抵达（无 instanceof 上下文），一并识别
+      // v0.8.0 P0-2: 透传流结束契约错误的结构化错误码（OUTPUT_LENGTH_EXCEEDED 等），
+      // 前端据此展示针对性文案而非泛化 UNKNOWN
       const isContentFilter =
         error instanceof ContentFilterError ||
         (error as Error & { code?: string }).code === MetonaErrorCode.CONTENT_FILTERED;
+      const rawErrorCode = (error as Error & { code?: string }).code;
+      const errorCode = isContentFilter
+        ? MetonaErrorCode.CONTENT_FILTERED
+        : rawErrorCode === MetonaErrorCode.OUTPUT_LENGTH_EXCEEDED
+          ? MetonaErrorCode.OUTPUT_LENGTH_EXCEEDED
+          : MetonaErrorCode.UNKNOWN;
       this.emit('streamEvent', {
         type: MetonaStreamEventType.ERROR,
         requestId: this.currentRequestId,
@@ -1494,7 +1652,7 @@ export class AgentLoopEngine extends EventEmitter {
         timestamp: Date.now(),
         runId: this.runId,
         error: {
-          code: isContentFilter ? MetonaErrorCode.CONTENT_FILTERED : MetonaErrorCode.UNKNOWN,
+          code: errorCode,
           message: isContentFilter
             ? '内容被 Provider 安全审核拦截，请修改图片或文本后重试'
             : error.message,
@@ -1513,6 +1671,9 @@ export class AgentLoopEngine extends EventEmitter {
       timestamp: Date.now(),
       runId: this.runId,
       terminationReason: reason,
+      // v0.8.0 P0-1: 转发最后一轮的 Provider 原生停止原因（前端据此展示
+      // "回答可能因输出上限被截断"等提示；无流式轮次时为 undefined）
+      ...(this.lastIterationFinishReason ? { finishReason: this.lastIterationFinishReason } : {}),
     });
 
     // H-3: 通过 stateChange 发射 TERMINATED 状态（前端可据此清理 UI）

electron/harness/agent-loop/index.ts

@@ -1,4 +1,6 @@
 export { AgentLoopEngine } from './engine';
+// v0.8.0 P0-2: 流结束契约错误（空响应重试 / 思考耗尽截断终止）—— 导出供测试断言
+export { EmptyResponseError, OutputTruncatedError } from './engine';
 export {
   AgentLoopState,
   TerminationReason,

electron/harness/agent-loop/types.ts

@@ -48,6 +48,13 @@ export interface IterationStep {
   toolCalls?: MetonaToolCall[];
   toolResults?: MetonaToolResult[];
   tokenUsage?: TokenUsage;
+  /**
+   * v0.8.0 P0-1: 本轮 LLM 流的 Provider 原生停止原因（归一化 OpenAI 语义：
+   * 'stop' | 'length' | 'tool_calls' | 'content_filter'）。
+   * 由 adapter DONE 事件携带、引擎捕获；TRACE 层据此记录真值，
+   * 引擎据此区分"自然完成"与"输出上限截断"（P0-2 空响应守卫的输入）。
+   */
+  finishReason?: string;
 }
 
 export interface TokenUsage {