foliko 2.0.18 → 2.0.20

package/tests/plugins/planner.test.js

@@ -0,0 +1,630 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const {
+  PlannerPlugin,
+  PlanStore,
+  PlanSerializer,
+} = require('../../plugins/core/planner/index.js');
+
+// ============================================================
+// 测试夹具
+// ============================================================
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'planner-test-'));
+}
+
+function makeFakeFramework(tempDir, sessionId = 'test_session_xxx') {
+  return {
+    getCwd: () => process.cwd(),
+    getExecutionContext: () => ({ sessionId }),
+    pluginManager: {
+      get: (name) => null,
+    },
+    _sessionContexts: new Map(),
+  };
+}
+
+function makePlugin(tempDir) {
+  const plugin = new PlannerPlugin({ dir: tempDir });
+  const fw = makeFakeFramework(tempDir);
+  plugin.install(fw);
+  plugin.start(fw);
+  return plugin;
+}
+
+// ============================================================
+// PlanSerializer 单测
+// ============================================================
+describe('PlanSerializer', () => {
+  it('toMarkdown 生成有效 frontmatter 和 checkbox 步骤', () => {
+    const plan = {
+      planId: 'plan_x',
+      title: '测试计划',
+      task: '原始任务',
+      sessionId: 'sess_1',
+      status: 'in_progress',
+      totalSteps: 3,
+      completedSteps: 1,
+      failedSteps: 1,
+      createdAt: '2026-07-06T00:00:00.000Z',
+      updatedAt: '2026-07-06T00:01:00.000Z',
+      steps: [
+        { index: 0, name: '步骤1', description: '详细', status: 'completed' },
+        { index: 1, name: '步骤2', status: 'failed' },
+        { index: 2, name: '步骤3', status: 'pending' },
+      ],
+    };
+    const md = PlanSerializer.toMarkdown(plan);
+    expect(md).toMatch(/^---\n/);
+    expect(md).toContain('planId: "plan_x"');
+    expect(md).toContain('title: "测试计划"');
+    expect(md).toContain('- [x] 1. 步骤1 — 详细');
+    expect(md).toContain('- [!] 2. 步骤2');
+    expect(md).toContain('- [ ] 3. 步骤3');
+  });
+
+  it('fromMarkdown 解析 frontmatter 字段', () => {
+    const md = `---
+planId: "plan_abc"
+title: "标题"
+status: "in_progress"
+totalSteps: 2
+completedSteps: 0
+failedSteps: 0
+createdAt: "2026-07-06T00:00:00.000Z"
+updatedAt: "2026-07-06T00:00:00.000Z"
+---
+
+# 标题
+
+## 任务描述
+测试任务
+
+## 计划步骤
+- [x] 1. 步骤1 — 已完成
+- [ ] 2. 步骤2
+
+## 执行日志
+暂无
+`;
+    const plan = PlanSerializer.fromMarkdown(md);
+    expect(plan.planId).toBe('plan_abc');
+    expect(plan.title).toBe('标题');
+    expect(plan.status).toBe('in_progress');
+    expect(plan.totalSteps).toBe(2);
+    expect(plan.steps).toHaveLength(2);
+    expect(plan.steps[0].status).toBe('completed');
+    expect(plan.steps[1].status).toBe('pending');
+  });
+
+  it('round-trip: toMarkdown → fromMarkdown 保留状态', () => {
+    const plan = {
+      planId: 'plan_rt',
+      title: 'Round-Trip',
+      task: '',
+      sessionId: null,
+      status: 'in_progress',
+      totalSteps: 2,
+      completedSteps: 1,
+      failedSteps: 0,
+      createdAt: '2026-07-06T10:00:00.000Z',
+      updatedAt: '2026-07-06T10:01:00.000Z',
+      steps: [
+        { index: 0, name: 'A', description: null, status: 'completed' },
+        { index: 1, name: 'B', description: null, status: 'pending' },
+      ],
+    };
+    const md = PlanSerializer.toMarkdown(plan);
+    const restored = PlanSerializer.fromMarkdown(md);
+    expect(restored.status).toBe('in_progress');
+    expect(restored.steps).toHaveLength(2);
+    expect(restored.steps[0].status).toBe('completed');
+    expect(restored.steps[1].status).toBe('pending');
+  });
+
+  it('frontmatter 含双引号转义', () => {
+    const plan = {
+      planId: 'p1', title: '标题"含引号', status: 'in_progress',
+      totalSteps: 1, completedSteps: 0, failedSteps: 0,
+      steps: [{ index: 0, name: 's', status: 'pending' }],
+      createdAt: 'x', updatedAt: 'y', sessionId: null, task: '',
+    };
+    const md = PlanSerializer.toMarkdown(plan);
+    expect(md).toContain('title: "标题\\"含引号"');
+  });
+});
+
+// ============================================================
+// PlanStore 单测
+// ============================================================
+describe('PlanStore', () => {
+  let tempDir, store;
+  beforeEach(() => {
+    tempDir = makeTempDir();
+    store = new PlanStore(tempDir);
+  });
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('save → load 保留 frontmatter 字段', () => {
+    const plan = {
+      planId: 'p1', title: 't', task: '', sessionId: null,
+      status: 'in_progress', totalSteps: 1, completedSteps: 0, failedSteps: 0,
+      createdAt: 'x', updatedAt: 'y',
+      steps: [{ index: 0, name: 's', status: 'pending' }],
+    };
+    store.save(plan);
+    expect(fs.existsSync(path.join(tempDir, 'p1.md'))).toBe(true);
+    const loaded = store.load('p1');
+    expect(loaded.planId).toBe('p1');
+    expect(loaded.steps).toHaveLength(1);
+  });
+
+  it('原子写：save 中途失败不应留下半残 .md', () => {
+    const plan = {
+      planId: 'p_atomic', title: 't', task: '', sessionId: null,
+      status: 'in_progress', totalSteps: 1, completedSteps: 0, failedSteps: 0,
+      createdAt: 'x', updatedAt: 'y',
+      steps: [{ index: 0, name: 's', status: 'pending' }],
+    };
+    let callCount = 0;
+    const origWrite = fs.writeFileSync;
+    fs.writeFileSync = (p, data, ...args) => {
+      callCount++;
+      if (p.endsWith('.tmp') && callCount === 1) {
+        throw new Error('disk full');
+      }
+      return origWrite(p, data, ...args);
+    };
+    try {
+      expect(() => store.save(plan)).toThrow('disk full');
+    } finally {
+      fs.writeFileSync = origWrite;
+    }
+    expect(fs.existsSync(path.join(tempDir, 'p_atomic.md'))).toBe(false);
+  });
+
+  it('list 按 updatedAt 倒序', () => {
+    const basePlan = {
+      title: 't', task: '', sessionId: null, status: 'in_progress',
+      totalSteps: 1, completedSteps: 0, failedSteps: 0,
+      steps: [{ index: 0, name: 's', status: 'pending' }],
+    };
+    store.save({ ...basePlan, planId: 'p_old', updatedAt: '2026-07-01T00:00:00.000Z', createdAt: '2026-07-01T00:00:00.000Z' });
+    store.save({ ...basePlan, planId: 'p_new', updatedAt: '2026-07-06T00:00:00.000Z', createdAt: '2026-07-06T00:00:00.000Z' });
+    const list = store.list();
+    expect(list[0].planId).toBe('p_new');
+    expect(list[1].planId).toBe('p_old');
+  });
+
+  it('delete 清理文件', () => {
+    const plan = {
+      planId: 'p_del', title: 't', task: '', sessionId: null,
+      status: 'in_progress', totalSteps: 1, completedSteps: 0, failedSteps: 0,
+      createdAt: 'x', updatedAt: 'y',
+      steps: [{ index: 0, name: 's', status: 'pending' }],
+    };
+    store.save(plan);
+    expect(store.delete('p_del')).toBe(true);
+    expect(store.exists('p_del')).toBe(false);
+  });
+});
+
+// ============================================================
+// PlannerPlugin 集成测试
+// ============================================================
+describe('PlannerPlugin', () => {
+  let tempDir, plugin;
+  beforeEach(() => {
+    tempDir = makeTempDir();
+    plugin = makePlugin(tempDir);
+  });
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('plan_create 持久化 .md 并返回 planId', async () => {
+    const r = await plugin._createPlan({
+      title: '测试',
+      task: 'do something',
+      steps: [{ name: 's1' }, { name: 's2' }],
+    });
+    expect(r.success).toBe(true);
+    expect(r.planId).toMatch(/^plan_/);
+    expect(fs.existsSync(r.markdownPath)).toBe(true);
+    expect(r.stepsCount).toBe(2);
+  });
+
+  it('plan_create 拒绝空 steps', async () => {
+    const r = await plugin._createPlan({ title: 't', task: '', steps: [] });
+    expect(r.success).toBe(false);
+  });
+
+  it('plan_create 拒绝循环引用（step.tool === plan_create）', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '',
+      steps: [{ name: 'loop', tool: 'plan_create' }],
+    });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/循环/);
+  });
+
+  it('plan_execute_step 推进状态、自动激活下一步', async () => {
+    const r = await plugin._createPlan({
+      title: '推进测试', task: '',
+      steps: [{ name: 's1' }, { name: 's2' }, { name: 's3' }],
+    });
+    const r1 = await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'completed',
+      tool: 'read', args: { path: '/tmp' }, durationMs: 100,
+    });
+    expect(r1.success).toBe(true);
+    expect(r1.progress).toBe('1/3');
+    expect(r1.nextStep).toBe(1);
+    expect(r1.attempts).toBe(1);
+    expect(r1.isRetry).toBe(false);
+
+    const r2 = await plugin._executeStep({
+      planId: r.planId, stepIndex: 1, status: 'completed',
+    });
+    expect(r2.nextStep).toBe(2);
+  });
+
+  it('★ retry 时清空旧 error 并追加日志历史（修复 bug）', async () => {
+    const r = await plugin._createPlan({
+      title: 'retry 测试', task: '',
+      steps: [{ name: 's1' }, { name: 's2' }],
+    });
+    // 第一次失败
+    await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'failed',
+      tool: 'edit_file', error: '文件不存在',
+    });
+    const plan1 = plugin._loadPlan(r.planId);
+    expect(plan1.steps[0].status).toBe('failed');
+    expect(plan1.steps[0].error).toBe('文件不存在');
+    expect(plan1.steps[0].attempts).toBe(1);
+    expect(plan1.steps[0].log).toContain('尝试 1');
+    expect(plan1.steps[0].log).toContain('错误: 文件不存在');
+
+    // 第二次重试：成功（不传 error）
+    const r2 = await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'completed',
+      tool: 'edit_file', args: { path: '/x' }, durationMs: 50,
+    });
+    expect(r2.attempts).toBe(2);
+    expect(r2.isRetry).toBe(true);
+    const plan2 = plugin._loadPlan(r.planId);
+    expect(plan2.steps[0].status).toBe('completed');
+    expect(plan2.steps[0].error).toBeNull();  // ★ 关键：旧 error 已被清空
+    expect(plan2.steps[0].note).toBeNull();
+    expect(plan2.completedSteps).toBe(1);
+    expect(plan2.failedSteps).toBe(0);
+
+    // ★ 日志保留两次尝试的完整历史
+    expect(plan2.steps[0].log).toContain('尝试 1');
+    expect(plan2.steps[0].log).toContain('尝试 2');
+    expect(plan2.steps[0].log).toContain('错误: 文件不存在');   // 第一次失败的记录保留
+    expect(plan2.steps[0].log).toContain('completed');          // 第二次成功
+
+    // 重新加载磁盘验证持久化也对
+    const plugin2 = makePlugin(tempDir);
+    const reloaded = plugin2._loadPlan(r.planId);
+    expect(reloaded.steps[0].attempts).toBe(2);
+    expect(reloaded.steps[0].log).toContain('尝试 1');
+    expect(reloaded.steps[0].log).toContain('尝试 2');
+
+    // 磁盘 markdown 也要有两次尝试
+    const md = fs.readFileSync(plugin._store._toFilePath(r.planId), 'utf-8');
+    expect(md).toMatch(/尝试 1/);
+    expect(md).toMatch(/尝试 2/);
+  });
+
+  it('★ retry 时清空旧 result（不残留上次结果）', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }],
+    });
+    await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'completed',
+      tool: 'read', result: { oldData: 'should be cleared' },
+    });
+    let plan = plugin._loadPlan(r.planId);
+    expect(plan.steps[0].result).toEqual({ oldData: 'should be cleared' });
+
+    // retry 不传 result → 清空
+    await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'in_progress',
+    });
+    plan = plugin._loadPlan(r.planId);
+    expect(plan.steps[0].result).toBeNull();
+  });
+
+  it('plan_execute_step 越界 stepIndex 返回 error', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }],
+    });
+    const r2 = await plugin._executeStep({
+      planId: r.planId, stepIndex: 99, status: 'completed',
+    });
+    expect(r2.success).toBe(false);
+  });
+
+  it('plan_execute_step 连续 2 步失败返回 shouldAbort', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '',
+      steps: [{ name: 's1' }, { name: 's2' }, { name: 's3' }],
+    });
+    await plugin._executeStep({ planId: r.planId, stepIndex: 0, status: 'failed', error: 'a' });
+    const r2 = await plugin._executeStep({ planId: r.planId, stepIndex: 1, status: 'failed', error: 'b' });
+    expect(r2.shouldAbort).toBe(true);
+    expect(r2.abortReason).toBeTruthy();
+  });
+
+  it('plan_complete 仅在所有步骤都完成时成功', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }, { name: 's2' }],
+    });
+    const rFail = await plugin._completePlan({ planId: r.planId });
+    expect(rFail.success).toBe(false);
+
+    await plugin._executeStep({ planId: r.planId, stepIndex: 0, status: 'completed' });
+    await plugin._executeStep({ planId: r.planId, stepIndex: 1, status: 'completed' });
+    const rOK = await plugin._completePlan({ planId: r.planId, summary: '搞定' });
+    expect(rOK.success).toBe(true);
+    expect(rOK.status).toBe('completed');
+  });
+
+  it('plan_continue 从第一个未完成步骤恢复', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '',
+      steps: [{ name: 's1' }, { name: 's2' }, { name: 's3' }],
+    });
+    await plugin._executeStep({ planId: r.planId, stepIndex: 0, status: 'completed' });
+
+    const plugin2 = makePlugin(tempDir);
+    const rCont = await plugin2._continuePlan({ planId: r.planId });
+    expect(rCont.success).toBe(true);
+    expect(rCont.resumableFrom).toBe(1);
+    expect(rCont.nextStepName).toBe('s2');
+  });
+
+  it('plan_continue 已完成计划返回 error', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }],
+    });
+    await plugin._executeStep({ planId: r.planId, stepIndex: 0, status: 'completed' });
+    await plugin._completePlan({ planId: r.planId });
+    const rCont = await plugin._continuePlan({ planId: r.planId });
+    expect(rCont.success).toBe(false);
+  });
+
+  it('plan_fail 设置 status=failed', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }],
+    });
+    const r2 = await plugin._failPlan({ planId: r.planId, reason: '测试中止' });
+    expect(r2.success).toBe(true);
+    const plan = plugin._loadPlan(r.planId);
+    expect(plan.status).toBe('failed');
+  });
+
+  it('plan_delete 删除文件并清理内存索引', async () => {
+    const r = await plugin._createPlan({
+      title: 't', task: '', steps: [{ name: 's1' }],
+    });
+    expect(plugin._index.has(r.planId)).toBe(true);
+    const r2 = await plugin._deletePlan({ planId: r.planId });
+    expect(r2.success).toBe(true);
+    expect(plugin._index.has(r.planId)).toBe(false);
+    expect(fs.existsSync(plugin._store._toFilePath(r.planId))).toBe(false);
+  });
+
+  it('plan_list 列出所有/按状态过滤', async () => {
+    const a = await plugin._createPlan({ title: 'a', task: '', steps: [{ name: 'x' }] });
+    const b = await plugin._createPlan({ title: 'b', task: '', steps: [{ name: 'x' }] });
+    await plugin._executeStep({ planId: a.planId, stepIndex: 0, status: 'completed' });
+    await plugin._completePlan({ planId: a.planId });
+
+    const all = await plugin._listPlans({});
+    expect(all.count).toBe(2);
+
+    const completed = await plugin._listPlans({ status: 'completed' });
+    expect(completed.count).toBe(1);
+    expect(completed.plans[0].title).toBe('a');
+
+    const inProgress = await plugin._listPlans({ status: 'in_progress' });
+    expect(inProgress.count).toBe(1);
+    expect(inProgress.plans[0].title).toBe('b');
+  });
+
+  it('plan_show 返回 markdown 文本', async () => {
+    const r = await plugin._createPlan({
+      title: 'show-test', task: '',
+      steps: [{ name: 's1' }, { name: 's2' }],
+    });
+    const r2 = await plugin._showPlan({ planId: r.planId });
+    expect(r2.success).toBe(true);
+    expect(r2.markdown).toContain('# show-test');
+    expect(r2.markdown).toContain('- [-] 1. s1');
+    expect(r2.markdown).toContain('- [ ] 2. s2');
+  });
+
+  it('进程重启：从磁盘加载所有计划到内存索引', async () => {
+    await plugin._createPlan({ title: 'p1', task: '', steps: [{ name: 'x' }] });
+    await plugin._createPlan({ title: 'p2', task: '', steps: [{ name: 'y' }] });
+
+    const plugin2 = new PlannerPlugin({ dir: tempDir });
+    plugin2.install(makeFakeFramework(tempDir));
+    expect(plugin2._index.size).toBe(2);
+  });
+
+  it('生成的 markdown 是可解析的（round-trip 一致）', async () => {
+    const r = await plugin._createPlan({
+      title: '一致性测试', task: '原任务',
+      steps: [{ name: 'A' }, { name: 'B' }, { name: 'C' }],
+    });
+    await plugin._executeStep({
+      planId: r.planId, stepIndex: 0, status: 'completed',
+      tool: 'read', args: { path: '/x' }, durationMs: 50,
+    });
+    await plugin._executeStep({
+      planId: r.planId, stepIndex: 1, status: 'failed',
+      tool: 'edit', error: '文件不存在',
+    });
+
+    const md = fs.readFileSync(plugin._store._toFilePath(r.planId), 'utf-8');
+    const restored = PlanSerializer.fromMarkdown(md);
+    expect(restored.status).toBe('in_progress');
+    expect(restored.completedSteps).toBe(1);
+    expect(restored.failedSteps).toBe(1);
+    expect(restored.steps).toHaveLength(3);
+    expect(restored.steps[0].status).toBe('completed');
+    expect(restored.steps[1].status).toBe('failed');
+    expect(restored.steps[2].status).toBe('pending');
+  });
+
+  // ============================================================
+  // planner-status 动态 prompt part（防止长上下文遗忘）
+  // ============================================================
+  describe('planner-status 动态 prompt', () => {
+    function makePluginWithPrompts(tempDir, sessionId = 'sess_42') {
+      const fw = {
+        getCwd: () => process.cwd(),
+        getExecutionContext: () => ({ sessionId }),
+        getCurrentSessionId: () => sessionId,
+        prompts: {
+          invalidate: (owner, name) => { fw._invalidateCalls = (fw._invalidateCalls || 0) + 1; },
+        },
+        pluginManager: { get: () => null },
+        _sessionContexts: new Map(),
+      };
+      fw._invalidateCalls = 0;
+      const p = new PlannerPlugin({ dir: tempDir });
+      p.install(fw);
+      p.start(fw);
+      return p;
+    }
+
+    it('无活跃计划时返回空字符串（不污染 system prompt）', () => {
+      const p = makePluginWithPrompts(tempDir);
+      expect(p._buildPlanStatusReminder()).toBe('');
+    });
+
+    it('当前 session 有 in_progress 计划时返回包含 planId 的摘要', async () => {
+      const p = makePluginWithPrompts(tempDir, 'sess_42');
+      await p._createPlan({
+        title: '天气修复', task: '',
+        sessionId: 'sess_42',
+        steps: [{ name: '读配置' }, { name: '编辑' }],
+      });
+      const reminder = p._buildPlanStatusReminder();
+      expect(reminder).toContain('当前活跃计划');
+      expect(reminder).toContain('天气修复');
+      expect(reminder).toContain('0/2');
+      expect(reminder).toContain('planId');
+      // 用 markdown bold 格式断言
+      expect(reminder).toContain('**当前步骤**: Step 1 — **读配置**');
+    });
+
+    it('执行一步后自动反映新进度', async () => {
+      const p = makePluginWithPrompts(tempDir, 'sess_42');
+      const r = await p._createPlan({
+        title: 't', task: '',
+        sessionId: 'sess_42',
+        steps: [{ name: '读' }, { name: '改' }],
+      });
+      await p._executeStep({
+        planId: r.planId, stepIndex: 0, status: 'completed',
+        tool: 'read', durationMs: 100,
+      });
+      const reminder = p._buildPlanStatusReminder();
+      // 调试用：打印完整 reminder
+      // console.log('REMINDER:\n' + reminder);
+      expect(reminder).toContain('1/2');
+      expect(reminder).toContain('✅ 1 完成');
+      expect(reminder).toContain('**上一步**: Step 1 ✅ 完成 (100ms)');
+      expect(reminder).toContain('**当前步骤**: Step 2 — **改**');
+    });
+
+    it('其他 session 的计划不显示（按 session 隔离）', async () => {
+      const p1 = makePluginWithPrompts(tempDir, 'sess_42');
+      const p2 = makePluginWithPrompts(tempDir, 'sess_99');
+      // 用 p1（session sess_42）创建计划
+      await p1._createPlan({
+        title: 'sess_42 的计划', task: '',
+        sessionId: 'sess_42',
+        steps: [{ name: 'x' }],
+      });
+      // 改用 p2（session sess_99）查 → 应该看不到
+      const reminder = p2._buildPlanStatusReminder();
+      expect(reminder).toBe('');
+    });
+
+    it('plan_create / execute_step / complete / fail / delete 都会 invalidate 缓存', async () => {
+      const p = makePluginWithPrompts(tempDir, 'sess_42');
+      const baseCalls = p._framework._invalidateCalls;
+
+      await p._createPlan({ title: 't', task: '', sessionId: 'sess_42', steps: [{ name: 'x' }] });
+      expect(p._framework._invalidateCalls).toBeGreaterThan(baseCalls);
+
+      // 取最新 planId 并继续操作
+      const plans = p._store.list({ status: 'in_progress' });
+      const planId = plans[0].planId;
+
+      await p._executeStep({ planId, stepIndex: 0, status: 'completed' });
+      await p._completePlan({ planId });
+      await p._failPlan({ planId, reason: 'test' });  // status 变 failed
+      await p._deletePlan({ planId });
+
+      // 每次操作都应触发至少一次 invalidate
+      expect(p._framework._invalidateCalls).toBeGreaterThanOrEqual(baseCalls + 5);
+    });
+
+    it('当 sessionId 为 null（CLI 全局调用）时不报错', () => {
+      const p = makePluginWithPrompts(tempDir, null);
+      expect(p._buildPlanStatusReminder()).toBe('');
+    });
+
+    it('上一步失败时显示错误信息（便于 LLM 决定重试）', async () => {
+      const p = makePluginWithPrompts(tempDir, 'sess_42');
+      const r = await p._createPlan({
+        title: 't', task: '',
+        sessionId: 'sess_42',
+        steps: [{ name: 'edit file' }, { name: 'next' }],
+      });
+      await p._executeStep({
+        planId: r.planId, stepIndex: 0, status: 'failed',
+        tool: 'edit', error: '权限被拒',
+      });
+      const reminder = p._buildPlanStatusReminder();
+      expect(reminder).toContain('❌ 1 失败');
+      expect(reminder).toContain('**上一步**: Step 1 ❌ 失败: 权限被拒');
+      // 失败时不会自动推进到下一步（让 LLM 决定重试/跳过/中止）
+      expect(reminder).toContain('**当前步骤**: 全部已执行');
+    });
+
+    it('多个 in_progress 计划时只显示前 3 个', async () => {
+      const p = makePluginWithPrompts(tempDir, 'sess_42');
+      for (let i = 0; i < 5; i++) {
+        await p._createPlan({
+          title: `计划 ${i}`, task: '',
+          sessionId: 'sess_42',
+          steps: [{ name: 's' }],
+        });
+      }
+      const reminder = p._buildPlanStatusReminder();
+      // 注：5 个计划在同一毫秒内创建，updatedAt 相同，
+      // 排序稳定性受 readdir 顺序影响（Windows 上不稳定）。
+      // 因此只断言"恰好显示 3 个"而不指定是哪 3 个。
+      const sectionCount = (reminder.match(/^### 计划/gm) || []).length;
+      expect(sectionCount).toBe(3);
+      // 至少 3 个 planId 出现
+      const planIdCount = (reminder.match(/\*\*planId\*\*/g) || []).length;
+      expect(planIdCount).toBe(3);
+    });
+  });
+});