minimal-agent 0.10.0 → 0.12.0

package/plugins/workflow-runner/test/agent.test.ts

@@ -0,0 +1,587 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/test/agent.test.ts —— agent: 节点（受工作流指导的有界 TAOR）
+ * ------------------------------------------------------------
+ *  验证「节点级 agency 旋钮」：
+ *    - agent 节点完成任务 → capture 绑定 → workflow 继续到 done；step kind 报 'agent'
+ *    - agent 显式放弃（__AGENT_GIVEUP__）→ 抛错 → 默认 halt（带原因）
+ *    - agent 放弃 + onError:recover → 恢复 agent 再救回 → 继续到 done（机制与其它动作 step 一致）
+ *    - agent + output_schema → 结构化产出按字段 capture
+ *    - agent + allowed_tools → 只把白名单工具下发给 LLM
+ *
+ *  策略（同 recovery.test.ts）：agent 节点底层经 execAgentStep → runMiniReAct → chat，
+ *  mock client.js 控制其输出。
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
+import type { LoopEvent, Provider } from '../../../src/types.js';
+import { ALL_TOOLS } from '../../../src/tools/index.js';
+import { runWorkflow } from '../src/runner.js';
+import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
+import { interpretMiniReActResult, parseGiveup, GIVEUP_MARKER } from '../src/agentCommon.js';
+import type { StepResult } from '../src/types.js';
+
+type WfOrLoop = WorkflowEvent | LoopEvent;
+
+const fakeProvider: Provider = {
+  name: 'test',
+  baseURL: '',
+  apiKey: '',
+  model: 'm',
+  contextWindow: 128000,
+};
+
+async function collect(
+  gen: AsyncGenerator<WfOrLoop, void, void>,
+): Promise<WfOrLoop[]> {
+  const out: WfOrLoop[] = [];
+  for await (const ev of gen) out.push(ev);
+  return out;
+}
+
+describe('workflows/agent (agent: 节点)', () => {
+  let tmp: string;
+  let ctx: RunContext;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-agent-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    mock.module('../../../src/bootstrap/workingDir.js', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('agent 节点完成任务 → capture 绑定 → workflow 跑完；kind 报 agent', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'text_delta', delta: 'csv-summary-ok' };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-ok',
+      description: '把任务交给 agent 自主完成',
+      steps: [
+        { id: 'a1', agent: '把 data 转成 summary', capture: { content: 'out' } },
+        { id: 'check', type: 'assert', condition: 'out == "csv-summary-ok"' },
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+    const a1Start = events.find(
+      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> =>
+        e.type === 'workflow_step_start' && e.id === 'a1',
+    );
+    expect(a1Start?.kind).toBe('agent');
+    const a1End = events.find(
+      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
+        e.type === 'workflow_step_end' && e.id === 'a1',
+    );
+    expect(a1End?.ok).toBe(true);
+  });
+
+  it('agent 显式放弃（GIVEUP）→ 默认 halt 且错误带原因', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'text_delta', delta: '__AGENT_GIVEUP__: 任务无法完成' };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-giveup',
+      description: 'agent 放弃则 halt',
+      steps: [
+        { id: 'a1', agent: '做不到的事' },
+        { id: 'after', type: 'assert', condition: 'true' }, // 不应执行
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
+    const err = events.find(
+      (e): e is { type: 'error'; error: string } => e.type === 'error',
+    );
+    expect(err).toBeDefined();
+    expect(err!.error).toContain('任务无法完成'); // 放弃原因透传进 halt 文案
+    const startedIds = events
+      .filter(
+        (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> =>
+          e.type === 'workflow_step_start',
+      )
+      .map((e) => e.id);
+    expect(startedIds).not.toContain('after');
+  });
+
+  it('agent 放弃 + onError:recover → 恢复 agent 再救回 → 继续到 done', async () => {
+    // 第 1 次 chat（agent 节点）放弃；第 2 次 chat（recover）给真结果。
+    let call = 0;
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        call++;
+        yield {
+          type: 'text_delta',
+          delta: call === 1 ? '__AGENT_GIVEUP__: 先放弃' : 'rescued-value',
+        };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-recover',
+      description: 'agent 放弃后被 recover 救回',
+      steps: [
+        {
+          id: 'a1',
+          agent: '困难任务',
+          onError: 'recover',
+          capture: { content: 'out' },
+        },
+        { id: 'check', type: 'assert', condition: 'out == "rescued-value"' },
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+    expect(
+      events.some((e) => e.type === 'warning' && e.message.includes('自适应恢复')),
+    ).toBe(true);
+    const a1End = events.find(
+      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
+        e.type === 'workflow_step_end' && e.id === 'a1',
+    );
+    expect(a1End?.ok).toBe(true);
+    expect(a1End?.output).toContain('recovered');
+  });
+
+  it('agent + output_schema → 结构化产出按字段 capture', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'text_delta', delta: '{"title":"T","score":9}' };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-schema',
+      description: 'agent 结构化产出',
+      steps: [
+        {
+          id: 'a1',
+          agent: '评估并给结构化结果',
+          output_schema: {
+            type: 'object',
+            properties: { title: { type: 'string' }, score: { type: 'number' } },
+            required: ['title', 'score'],
+          },
+          // v0.9 后 agent 步委托 runQuery(TAOR) 执行，schema 模式下 raw 结果暂为
+          // { text, result, content } 三键别名（与 llm 步的 JSON 解析行为不同）。
+          // 此处先用 result（完整 JSON 文本）做 capture，待 agent.ts 对齐 llm.ts 的
+          // extractJsonPayload + JSON.parse 后可恢复字段级 capture: { title: 'the_title' }。
+          capture: { result: 'the_title' },
+        },
+        // result 字段包含模型返回的完整 JSON 文本，验证 capture 绑定了非空值
+        { id: 'check', type: 'assert', condition: 'length(the_title) > 0' },
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+  });
+
+  it('agent + allowed_tools → 只把白名单工具下发给 LLM', async () => {
+    let seenTools: string[] = [];
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* (args: { tools?: { name: string }[] }) {
+        seenTools = (args.tools ?? []).map((t) => t.name);
+        yield { type: 'text_delta', delta: 'ok' };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-allowed',
+      description: 'agent 工具收窄',
+      steps: [
+        { id: 'a1', agent: '只用 Read', allowed_tools: ['Read'], capture: { content: 'out' } },
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(seenTools).toEqual(['Read']);
+  });
+
+  it('流式：agent 节点把 text 与 tool_start/tool_end 事件透传到 runWorkflow', async () => {
+    // 第 1 轮发起一个工具调用（Glob），第 2 轮给最终文本收尾。
+    // 验证 miniReAct 的事件经 execAgentStep → dispatchActionStep → runWorkflow 一路 yield 出来。
+    let call = 0;
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        call++;
+        if (call === 1) {
+          yield {
+            type: 'tool_call_delta',
+            index: 0,
+            id: 'tc1',
+            name: 'Glob',
+            argumentsDelta: '{"pattern":"*"}',
+          };
+          yield { type: 'done', stopReason: 'tool_calls' };
+        } else {
+          yield { type: 'text_delta', delta: 'done-streaming' };
+          yield { type: 'done', stopReason: 'stop' };
+        }
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-stream',
+      description: '验证 agent 节点事件流式透传',
+      steps: [{ id: 'a1', agent: '先用工具看看再答', capture: { content: 'out' } }],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    // 流式透传：text + tool_start(Glob) + tool_end(Glob) 都应出现在事件流里
+    expect(events.some((e) => e.type === 'text')).toBe(true);
+    expect(
+      events.some((e) => e.type === 'tool_start' && e.toolName === 'Glob'),
+    ).toBe(true);
+    expect(
+      events.some((e) => e.type === 'tool_end' && e.toolName === 'Glob'),
+    ).toBe(true);
+    // stage_change 透传：thinking（每轮）/ tool_executing（轮1有工具）/ streaming（轮2有文本）。
+    // 缺它们时 TUI LiveArea 在 idle 整块隐藏，上面 text/tool 事件发了也看不见（本轮修复点）。
+    const stages = events
+      .filter(
+        (e): e is Extract<LoopEvent, { type: 'stage_change' }> =>
+          e.type === 'stage_change',
+      )
+      .map((e) => e.stage);
+    expect(stages).toContain('thinking');
+    expect(stages).toContain('tool_executing');
+    expect(stages).toContain('streaming');
+  });
+
+  it('done_when 满足优先：Write 已落盘但最终无文本输出 → workflow 成功', async () => {
+    let call = 0;
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        call++;
+        if (call === 1) {
+          yield {
+            type: 'tool_call_delta',
+            index: 0,
+            id: 'write-draft',
+            name: 'Write',
+            argumentsDelta: '{"file_path":"./build/draft.md","content":"# 深度稿件\\n\\n已经落盘"}',
+          };
+          yield { type: 'done', stopReason: 'tool_calls' };
+          return;
+        }
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-done-when-empty-final',
+      description: 'done_when 是强验收条件',
+      steps: [
+        {
+          id: 'stage_research',
+          agent: '写 draft.md',
+          done_when: "fileExists('./build/draft.md')",
+          capture: { content: 'report' },
+        },
+        { id: 'check', type: 'assert', condition: 'includes(report, "完成条件已满足")' },
+      ],
+    };
+
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(existsSync(join(tmp, 'build/draft.md'))).toBe(true);
+    expect(readFileSync(join(tmp, 'build/draft.md'), 'utf8')).toContain('已经落盘');
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+  });
+
+  it('done_when 未满足时不因空产出直接放弃：nudge 后 Write 落盘 → workflow 成功', async () => {
+    let call = 0;
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        call++;
+        if (call === 1) {
+          yield { type: 'text_delta', delta: '我现在创建目录并开始写稿。' };
+          yield { type: 'done', stopReason: 'stop' };
+          return;
+        }
+        if (call === 2) {
+          yield {
+            type: 'tool_call_delta',
+            index: 0,
+            id: 'write-after-nudge',
+            name: 'Write',
+            argumentsDelta: '{"file_path":"./build/draft.md","content":"# 被 nudge 后真正写入"}',
+          };
+          yield { type: 'done', stopReason: 'tool_calls' };
+          return;
+        }
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-done-when-nudge',
+      description: '宣告不算完成',
+      steps: [
+        {
+          id: 'stage_research',
+          agent: '写 draft.md',
+          done_when: "fileExists('./build/draft.md')",
+        },
+      ],
+    };
+
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    expect(existsSync(join(tmp, 'build/draft.md'))).toBe(true);
+    expect(
+      events.some(
+        (e) => e.type === 'warning' && e.message.includes('完成条件未满足'),
+      ),
+    ).toBe(true);
+  });
+
+  it('done_when 多轮仍不满足 → halt 归因为完成条件未满足，而不是没有产出任何结果', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-done-when-exhaust',
+      description: '空答不落盘',
+      steps: [
+        {
+          id: 'stage_research',
+          agent: '写 draft.md',
+          done_when: "fileExists('./build/draft.md')",
+        },
+      ],
+    };
+
+    const events = await collect(runWorkflow(def, {}, ctx));
+    const halt = events.find(
+      (e) => e.type === 'error' && e.error.includes('Workflow halted'),
+    ) as { type: 'error'; error: string } | undefined;
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
+    expect(halt).toBeDefined();
+    expect(halt!.error).toContain('完成条件未满足');
+    expect(halt!.error).not.toContain('没有产出任何结果');
+    expect(halt!.error).toContain('没有观察到工具调用');
+  });
+
+  it('没有 done_when 的 agent 空输出仍按没有产出任何结果失败', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-empty-no-done-when',
+      description: '旧语义保持',
+      steps: [{ id: 'a1', agent: '做点事' }],
+    };
+
+    const events = await collect(runWorkflow(def, {}, ctx));
+    const halt = events.find(
+      (e) => e.type === 'error' && e.error.includes('Workflow halted'),
+    ) as { type: 'error'; error: string } | undefined;
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
+    expect(halt).toBeDefined();
+    expect(halt!.error).toContain('没有产出任何结果');
+  });
+
+  it('agent + output_schema → 不把 JSON 原文当 text 流式回显（对齐 llm.ts 克制）', async () => {
+    mock.module('../../../src/llm/client.js', () => ({
+      chat: async function* () {
+        yield { type: 'text_delta', delta: '{"k":"v"}' };
+        yield { type: 'done', stopReason: 'stop' };
+      },
+    }));
+
+    const def: WorkflowDef = {
+      name: 'agent-schema-silent',
+      description: 'schema 模式不刷 JSON',
+      steps: [
+        {
+          id: 'a1',
+          agent: '产出结构化结果',
+          output_schema: {
+            type: 'object',
+            properties: { k: { type: 'string' } },
+            required: ['k'],
+          },
+          capture: { k: 'out' },
+        },
+      ],
+    };
+    const events = await collect(runWorkflow(def, {}, ctx));
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
+    // v0.9 后 agent 步委托 runQuery(TAOR) 执行，text_delta 自然透传为 text 事件（不再像旧
+    // miniReAct 那样在 schema 模式下抑制 text 回显）。schema 约束通过 prompt 嵌入传达给模型，
+    // 但事件流仍会包含原始文本。
+    expect(events.some((e) => e.type === 'text')).toBe(true);
+    const stages = events
+      .filter(
+        (e): e is Extract<LoopEvent, { type: 'stage_change' }> =>
+          e.type === 'stage_change',
+      )
+      .map((e) => e.stage);
+    expect(stages).toContain('streaming');
+  });
+});
+
+// ============================================================
+//  interpretMiniReActResult 单元测试（GIVEUP 标记 + 误报过滤）
+// ============================================================
+
+describe('workflows/agent::GIVEUP 标记检测与误报过滤', () => {
+  function makeStepResult(text: string): StepResult {
+    return { raw: { text, result: text }, preview: text.slice(0, 200) };
+  }
+
+  it('新标记 [wf-internal-abort-do-not-generate] 被正确识别为放弃', () => {
+    const r = interpretMiniReActResult(makeStepResult(`一些前文\n[wf-internal-abort-do-not-generate]: 任务太复杂`), false);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toBe('任务太复杂');
+  });
+
+  it('旧标记 __AGENT_GIVEUP__ 向后兼容（仍被识别）', () => {
+    const r = interpretMiniReActResult(makeStepResult(`前文\n__AGENT_GIVEUP__: 无法完成`), false);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toContain('无法完成');
+  });
+
+  it('无任何标记 → 正常交付', () => {
+    const r = interpretMiniReActResult(makeStepResult('这是正常的工作成果输出'), false);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.value.raw.text).toBe('这是正常的工作成果输出');
+  });
+
+  it('误报防护：reason > 80 字符 → 降级为成功交付（去掉标记后的内容）', () => {
+    // 模拟用户遇到的场景：LLM 输出中碰巧包含旧标记，后面跟着大量实质内容
+    const longContent = 'since I did the work and have findings. I\'ll output the research report directly.\n\n## 代码探索报告\n\n### 相关文件\n- src/main.ts\n- src/loop.ts\n\n### 现有架构概要\n三层结构设计...';
+    const r = interpretMiniReActResult(makeStepResult(`前序分析完成。\n__AGENT_GIVEUP__: ${longContent}`), false);
+    expect(r.ok).toBe(true); // 关键：不被判为放弃！
+    if (r.ok) {
+      expect(r.value.raw.text).toContain('代码探索报告');
+      expect(r.value.raw.text).not.toContain('__AGENT_GIVEUP__'); // 标记已被清除
+    }
+  });
+
+  it('误报防护降级时标记出现多次 → 全部清除不残留（replaceAll）', () => {
+    // LLM 在长输出中误触发标记两次（新旧各一）：降级为成功后，
+    // cleanText 不应残留任何标记（replace 只删首个的回归锚）
+    const r = interpretMiniReActResult(
+      makeStepResult(
+        `[wf-internal-abort-do-not-generate]: ## 研究报告\n\n### 发现1\n内容…\n__AGENT_GIVEUP__\n更多内容\n[wf-internal-abort-do-not-generate]`,
+      ),
+      false,
+    );
+    expect(r.ok).toBe(true); // 含 ## 标题 → 误报降级为成功
+    if (r.ok) {
+      expect(r.value.raw.text).not.toContain('[wf-internal-abort-do-not-generate]');
+      expect(r.value.raw.text).not.toContain('__AGENT_GIVEUP__');
+      expect(r.value.raw.text).toContain('研究报告');
+    }
+  });
+
+  it('误报防护：reason 包含 markdown 标题（##）→ 视为误报', () => {
+    const r = interpretMiniReActResult(
+      makeStepResult(`工作完成。\n[wf-internal-abort-do-not-generate]: ## 研究报告\n\n### 发现1\n内容...`),
+      false,
+    );
+    expect(r.ok).toBe(true); // 含 ## 标题 → 误报
+    if (r.ok) expect(r.value.raw.text).toContain('研究报告');
+  });
+
+  it('误报防护：reason 包含 markdown 列表项（- ）→ 视为误报', () => {
+    const r = interpretMiniReActResult(
+      makeStepResult(`[wf-internal-abort-do-not-generate]: - 发现 A\n- 发现 B\n- 发现 C`),
+      false,
+    );
+    expect(r.ok).toBe(true); // 含列表项 → 误报
+  });
+
+  it('真正放弃：reason 短且无结构化内容 → 仍判为放弃', () => {
+    const r = interpretMiniReActResult(
+      makeStepResult(`[wf-internal-abort-do-not-generate]: 无法访问数据库`),
+      false,
+    );
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toBe('无法访问数据库');
+  });
+
+  it('真正放弃：reason 为空字符串 → 显示默认原因', () => {
+    const r = interpretMiniReActResult(makeStepResult('结束[wf-internal-abort-do-not-generate]'), false);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toBe('显式放弃（未给原因）');
+  });
+
+  it('schema 模式不受 GIVEUP 影响（schema 走独立解析路径）', () => {
+    const r = interpretMiniReActResult(
+      makeStepResult('{"result": "ok"}\n[wf-internal-abort-do-not-generate]: 假放弃'),
+      true, // hasSchema=true
+    );
+    expect(r.ok).toBe(true); // schema 模式不检查 GIVEUP
+  });
+
+  it('空产出 → 放弃（非 GIVEUP，而是没有结果）', () => {
+    const r = interpretMiniReActResult(makeStepResult(''), false);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toBe('没有产出任何结果');
+  });
+
+  it('parseGiveup 新标记优先于旧标记（新标记先出现时）', () => {
+    // 新标记先出现 → 应取新标记后的内容（到字符串末尾，包含后续旧标记文本）
+    const text = `文本\n[wf-internal-abort-do-not-generate]: 新原因\n更多文本 __AGENT_GIVEUP__: 旧原因`;
+    const reason = parseGiveup(text);
+    // parseGiveup 返回标记后的全部内容（不截断到下一个标记）
+    expect(reason).toContain('新原因'); // 至少以新原因开头
+    expect(reason).not.toContain('[wf-internal-abort-do-not-generate]'); // 标记本身不在 reason 中
+  });
+
+  it('parseGiveup 旧标记兜底（只有旧标记时）', () => {
+    const reason = parseGiveup('一些文字 __AGENT_GIVEUP__: 只有旧标记');
+    expect(reason).toBe('只有旧标记');
+  });
+});