minimal-agent 0.12.0 → 0.14.0

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

@@ -0,0 +1,317 @@
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import { GoalRuntime, GoalStore } from '../../../src/goal/index.js';
+import { prepareGoalCommand } from '../../../src/goal/workflowController.js';
+
+async function harness() {
+  const root = await mkdtemp(join(tmpdir(), 'goal-controller-'));
+  const runtime = new GoalRuntime({ store: new GoalStore({ stateRoot: root }) });
+  const options = {
+    cwd: root,
+    runtime,
+    runtimeContext: {
+      workspaceId: 'workspace-1', sessionId: 'session-1', cwd: root,
+      surface: 'workflow' as const, profile: 'main' as const,
+      owner: 'local-owner' as const, memoryAccess: 'read-only' as const,
+      interactiveAsk: false,
+    },
+  };
+  return { runtime, options };
+}
+
+describe('/workflow goal controller', () => {
+  test('creates stable Goal/Attempt and rejects an implicit objective replacement', async () => {
+    const { options } = await harness();
+    const first = await prepareGoalCommand({
+      objective: '实现功能', checks: 'shell:bun test',
+      group_id: 'group-1', task_id: 'task-1',
+    }, options);
+    expect(first.handled).toBe(false);
+    expect(first.execution?.correlations?.taskId).toBe('task-1');
+    const conflict = await prepareGoalCommand({ objective: '换一个目标' }, options);
+    expect(conflict.handled).toBe(true);
+    expect(conflict.events[0]).toMatchObject({ type: 'error' });
+  });
+
+  test('confirmed workflow contract is versioned and verification stops at human acceptance', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand({ objective: '交付功能' }, options);
+    await prepared.bridge?.updateContract({
+      objective: '交付功能', deliverables: ['代码', '说明'], acceptanceCriteria: ['测试通过'],
+    });
+    const ready = await prepared.bridge?.finish({
+      status: 'verified', artifacts: ['out/result.md'], evidence: ['tests pass'],
+    }) as import('../../../src/goal/types.js').Goal | undefined;
+    expect(ready?.status).toBe('ready_for_acceptance');
+    expect(ready?.currentContractVersion).toBe(2);
+    const status = await prepareGoalCommand({ action: 'status' }, options);
+    expect(status.events[0]).toMatchObject({ type: 'text' });
+    const accepted = await prepareGoalCommand({ action: 'accept' }, options);
+    expect(accepted.events[0]).toMatchObject({ type: 'text' });
+    expect((await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' }))?.status)
+      .toBe('accepted');
+  });
+
+  test('pause/resume reuses the stopped Attempt journal identity', async () => {
+    const { options } = await harness();
+    const first = await prepareGoalCommand({ objective: '长任务' }, options);
+    await first.bridge?.finish({ status: 'stopped', blocker: '用户暂停' });
+    const resumed = await prepareGoalCommand({ action: 'resume' }, options);
+    expect(resumed.handled).toBe(false);
+    expect(resumed.execution?.runId).toBe(first.execution?.runId);
+  });
+});
+
+/**
+ * ── 资源记账（A2）─────────────────────────────────────────────────────
+ *
+ * `recordUsage` 此前**全仓零调用点**：方法定义在 GoalRuntime 上，
+ * `GoalResourceUsage` / `budget_limited` / `usage_limited` 全是有形状无执行器，
+ * 连桌面端 App.tsx 都已经在渲染两个永远不会发生的状态。这里把通路锁死。
+ */
+describe('goal bridge —— 资源记账', () => {
+  test('★ recordUsage 累计进 goal.usage，并回报最新契约的上限', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '记账测试', checks: 'shell:exit 0' },
+      options,
+    );
+    expect(prepared.bridge?.recordUsage).toBeDefined();
+
+    const first = await prepared.bridge!.recordUsage!({ inputTokens: 100, outputTokens: 20 });
+    expect(first.inputTokens).toBe(100);
+    expect(first.outputTokens).toBe(20);
+    // 没设预算时上限是 null（不是 0 —— 0 会被判成「一开始就超了」）。
+    expect(first.limit).toBeNull();
+
+    const second = await prepared.bridge!.recordUsage!({ inputTokens: 50, outputTokens: 5 });
+    expect(second.inputTokens).toBe(150);
+    expect(second.outputTokens).toBe(25);
+  });
+
+  test('★ 用量落进事件流，跨进程读回来还在（不是进程内计数）', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '持久化测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.recordUsage!({ inputTokens: 777, outputTokens: 88 });
+
+    // 重新从 store 读（模拟 resume：账本重放不会重新执行 agent 调用，
+    // 已花掉的钱必须从持久层拿回来，否则预算闸永远不触发）。
+    const scope = { workspaceId: 'workspace-1', sessionId: 'session-1' };
+    const reloaded = await runtime.get(scope);
+    expect(reloaded?.usage.inputTokens).toBe(777);
+    expect(reloaded?.usage.outputTokens).toBe(88);
+  });
+
+  test('★ 改预算 = 新契约版本，已消耗量不重置', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '预算改版测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.recordUsage!({ inputTokens: 1_000, outputTokens: 100 });
+
+    const before = await prepared.bridge!.updateContract({
+      objective: '预算改版测试',
+      tokenBudget: 5_000,
+    });
+    const after = await prepared.bridge!.recordUsage!({ inputTokens: 1, outputTokens: 1 });
+
+    expect(before.version).toBeGreaterThan(1);
+    expect(after.limit).toBe(5_000);
+    // 「加预算继续跑」是自然操作 —— 已花的 1000 不该被偷偷清零。
+    expect(after.inputTokens).toBe(1_001);
+  });
+
+  test('★ update 显式改预算时保留其它契约字段', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '保留契约字段', checks: '测试通过', token_budget: 1_000 },
+      options,
+    );
+    await prepared.bridge!.updateContract({
+      objective: '保留契约字段',
+      deliverables: ['交付代码'],
+      scope: '当前工作区',
+      sourceRefs: ['issue-42'],
+      tokenBudget: 1_000,
+    });
+    await prepared.bridge!.finish({ status: 'stopped', blocker: '暂停' });
+
+    const updated = await prepareGoalCommand(
+      { action: 'update', objective: '保留契约字段（修订）', token_budget: 2_000 },
+      options,
+    );
+    expect(updated.handled).toBe(false);
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    const contract = goal ? runtime.currentContract(goal) : null;
+    expect(contract).toMatchObject({
+      objective: '保留契约字段（修订）',
+      deliverables: ['交付代码'],
+      scope: '当前工作区',
+      sourceRefs: ['issue-42'],
+      tokenBudget: 2_000,
+    });
+  });
+});
+
+/**
+ * ── usage_limited（A5）────────────────────────────────────────────────
+ *
+ * 这个状态此前只在 TRANSITIONS 与 types 里声明，**没有任何代码能推到它**，
+ * 而 minimal-desktop/src/App.tsx 已经在渲染它 —— 一个永远不会发生的 UI 分支。
+ */
+describe('goal bridge —— 服务端配额耗尽落 usage_limited', () => {
+  test('★ 配额类失败 → usage_limited（不是笼统的 failed）', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '配额测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.finish({
+      status: 'failed',
+      blocker: '在线模型请求失败：TOKEN_QUOTA_EXHAUSTED Token 额度已用尽',
+    });
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    expect(goal?.status).toBe('usage_limited');
+    // 可恢复：解决授权后能回到 active（TRANSITIONS 允许）。
+    expect(goal?.statusReason).toContain('TOKEN_QUOTA_EXHAUSTED');
+  });
+
+  test('★ 普通失败不该被误判成配额问题', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '普通失败测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.finish({
+      status: 'failed',
+      blocker: '脚本第 12 行抛错：文件不存在',
+    });
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    // 普通失败让 Goal 留在 active（可以再起一次 attempt），不是 usage_limited。
+    expect(goal?.status).not.toBe('usage_limited');
+  });
+});
+
+/**
+ * ── budget_limited 真的可达（A3 收口）──────────────────────────────────
+ *
+ * 复核发现的真实缺口：`budget_limited` 在 TRANSITIONS 和类型里都声明了，
+ * `workflows/goal/workflow.mjs` 也确实会把 `status='budget_limited'` 写进 STATUS.json，
+ * 但脚本随后统一 `throw new Error(...)`，runner 的通用 catch 一律记 `status:'failed'`，
+ * `finishAttempt` 把 failed 派生成 `blocked`——而 TRANSITIONS 里根本没有
+ * `blocked → budget_limited` 这条边。整条链路走一遍，Goal 永远停在 blocked，
+ * `budget_limited` 从声明到落地之间没有任何代码路径。
+ *
+ * 修法：工作流在 Error 上挂 `workflowOutcome` 属性传结构化信息 → runner 原样
+ * 转发成 `finish({..., outcome})` → 这里按
+ * `statusMapping.ts::OUTCOME_TO_ATTEMPT` 精化成 `'stopped'` → `finishAttempt` 派生成
+ * `paused` → 再精化成 `budget_limited`（新增的 `paused → budget_limited` 边）。
+ */
+describe('goal bridge —— 预算耗尽落 budget_limited（不是 blocked，也不是普通 paused）', () => {
+  test('★ 带 outcome:budget_limited 的 stopped → Goal 落 budget_limited', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '预算耗尽测试', checks: 'shell:exit 0' },
+      options,
+    );
+    // 模拟 workflow.mjs 的真实调用形状：runner 把脚本 Error 上的 workflowOutcome
+    // 原样转发给 bridge.finish，status 恒是 runner 自己的通用默认值 'failed'。
+    await prepared.bridge!.finish({
+      status: 'failed',
+      blocker: '💰 token 预算用尽，已停在轮次边界',
+      outcome: 'budget_limited',
+    });
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    expect(goal?.status).toBe('budget_limited');
+    expect(goal?.status).not.toBe('blocked');
+    // 可恢复：TRANSITIONS 允许 budget_limited → active，加预算后能续跑。
+    const resumed = await prepareGoalCommand({ action: 'resume' }, options);
+    expect(resumed.handled).toBe(false);
+  });
+
+  test('用户主动暂停（无 outcome）仍然落 paused，不会被误判成 budget_limited', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '普通暂停测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.finish({ status: 'stopped', blocker: '用户停止，现场已保留' });
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    expect(goal?.status).toBe('paused');
+    expect(goal?.status).not.toBe('budget_limited');
+  });
+
+  test('未知 outcome 值不精化，退回 runner 传入的 status（防御未来新增结局忘了同步）', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '未知结局测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.finish({
+      status: 'failed', blocker: '未知原因', outcome: 'some_future_outcome',
+    });
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    expect(goal?.status).toBe('blocked');
+  });
+});
+
+/**
+ * ── resume 不再静默清空预算（A4 收口）──────────────────────────────────
+ *
+ * 复核发现的真实缺口：workflow.mjs 每次都无条件把
+ * `Number(args.token_budget) > 0 ? Number(args.token_budget) : null` 写进新契约版本。
+ * resume/rework 时如果调用方没有重新传 token_budget（文档说的就是不需要重传），
+ * `args.token_budget` 是 undefined → 新契约的预算被静默写成 null（不限），
+ * 「用尽后加预算续跑」的断点续跑设计对用户完全不可见地失效了。
+ */
+describe('goal 控制器 —— resume 沿用已有预算，不静默清零', () => {
+  test('★ resume 不显式传 token_budget 时，沿用上一版契约的预算', async () => {
+    const { runtime, options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '预算续跑测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.updateContract({ objective: '预算续跑测试', tokenBudget: 42_000 });
+    await prepared.bridge!.finish({
+      status: 'failed', blocker: '预算耗尽', outcome: 'budget_limited',
+    });
+
+    // resume 时不传 token_budget —— 这正是文档描述的用户操作：
+    // 「加预算后用同一目标重跑即可从这里继续」，不改预算就不用重复传参。
+    const resumed = await prepareGoalCommand({ action: 'resume' }, options);
+    expect(resumed.inputs.token_budget).toBe(42_000);
+
+    const goal = await runtime.get({ workspaceId: 'workspace-1', sessionId: 'session-1' });
+    expect(goal?.status).toBe('active');
+  });
+
+  test('resume 显式传新预算时，新值优先于旧契约的预算', async () => {
+    const { options } = await harness();
+    const prepared = await prepareGoalCommand(
+      { objective: '预算改值测试', checks: 'shell:exit 0' },
+      options,
+    );
+    await prepared.bridge!.updateContract({ objective: '预算改值测试', tokenBudget: 1_000 });
+    await prepared.bridge!.finish({
+      status: 'failed', blocker: '预算耗尽', outcome: 'budget_limited',
+    });
+
+    const resumed = await prepareGoalCommand(
+      { action: 'resume', token_budget: 99_000 }, options,
+    );
+    expect(resumed.inputs.token_budget).toBe(99_000);
+  });
+});

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

@@ -0,0 +1,198 @@
+/**
+ * plugins/workflow-runner/test/journalLanes.test.ts —— 并发下账本定位必须确定
+ *
+ * 守的是一条**实测存在过的静默降级**：
+ *
+ * 账本序号原本在拿到并发闸（上限 8）之后才自增，于是扇出超过 8 项时，第 9 项的
+ * 序号取决于前 8 项谁先返回 —— 也就是取决于 LLM 延迟。同一个脚本两次运行的序号
+ * 分配可能完全不同 → 首个失配 → 后面全部实跑，**断点续跑静默失效**。
+ *
+ * ⚠️ **所以这里的扇出规模必须大于并发上限**。N ≤ 8 时所有项同时起跑、顺序恰好稳定，
+ * 用例恒绿，等于没测 —— 这与上一轮 PDF 那条「144 DPI 恰好等于 scale:2，尺寸判据
+ * 撤掉修复照样绿」是同一类假保证。
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { Journal, MAIN_LANE } from '../src/journal.js';
+
+const dirs: string[] = [];
+function tmpJournal(): string {
+  const d = mkdtempSync(join(tmpdir(), 'wf-lane-'));
+  dirs.push(d);
+  return join(d, 'journal.jsonl');
+}
+afterEach(() => {
+  for (const d of dirs.splice(0)) {
+    try {
+      rmSync(d, { recursive: true, force: true, maxRetries: 3 });
+    } catch {
+      /* Windows 偶发 EBUSY */
+    }
+  }
+});
+
+/** 制造「完成顺序与发起顺序不同」的调度：下标越大越快返回。 */
+const reversedDelay = (i: number, n: number) =>
+  new Promise((r) => setTimeout(r, (n - i) * 2));
+
+describe('车道让并发下的定位与调度无关', () => {
+  test('★ 扇出 20 项（> 并发上限 8）乱序完成，第二次仍 100% 重放', async () => {
+    const path = tmpJournal();
+    const N = 20;
+
+    const run1 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run1.load();
+    await Promise.all(
+      Array.from({ length: N }, async (_, i) => {
+        await reversedDelay(i, N);
+        return run1.step('agent', { i }, async () => `r${i}`, `main/p1i${i}`);
+      }),
+    );
+
+    // 第二次：换一种完成顺序（正序），车道定位不该受影响
+    const run2 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run2.load();
+    const results = await Promise.all(
+      Array.from({ length: N }, async (_, i) => {
+        await new Promise((r) => setTimeout(r, i * 2));
+        return run2.step(
+          'agent',
+          { i },
+          async (): Promise<string> => {
+            throw new Error(`第 ${i} 项不该实跑`);
+          },
+          `main/p1i${i}`,
+        );
+      }),
+    );
+
+    expect(results).toEqual(Array.from({ length: N }, (_, i) => `r${i}`));
+    expect(run2.replayedCount).toBe(N);
+  });
+
+  test('★ 对照：同一条车道上并发 20 项 —— 定位就会错乱（这正是不能裸 Promise.all 的原因）', async () => {
+    const path = tmpJournal();
+    const N = 20;
+
+    const run1 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run1.load();
+    await Promise.all(
+      Array.from({ length: N }, async (_, i) => {
+        await reversedDelay(i, N);
+        return run1.step('agent', { i }, async () => `r${i}`, MAIN_LANE);
+      }),
+    );
+
+    const run2 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run2.load();
+    let liveRuns = 0;
+    await Promise.all(
+      Array.from({ length: N }, async (_, i) => {
+        await new Promise((r) => setTimeout(r, i * 2));
+        return run2.step(
+          'agent',
+          { i },
+          async () => {
+            liveRuns++;
+            return `r${i}`;
+          },
+          MAIN_LANE,
+        );
+      }),
+    );
+
+    // 顺序变了 → 序号与内容对不上 → 大量实跑。这条断言故意宽松：
+    // 要证明的是「会退化」，不是退化到某个精确数字。
+    expect(liveRuns).toBeGreaterThan(0);
+    expect(run2.replayedCount).toBeLessThan(N);
+  });
+
+  test('一条车道失配只作废自己，不牵连兄弟车道', async () => {
+    const path = tmpJournal();
+    const run1 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run1.load();
+    for (const i of [0, 1]) {
+      await run1.step('agent', { i, s: 1 }, async () => `a${i}`, `main/p1i${i}`);
+      await run1.step('agent', { i, s: 2 }, async () => `b${i}`, `main/p1i${i}`);
+    }
+
+    const run2 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run2.load();
+    // 第 0 项第一阶段内容变了 → 只有 0 号车道分叉
+    const a0 = await run2.step('agent', { i: 0, s: 99 }, async () => 'NEW', 'main/p1i0');
+    const b0 = await run2.step('agent', { i: 0, s: 2 }, async () => 'LIVE0', 'main/p1i0');
+    const a1 = await run2.step('agent', { i: 1, s: 1 }, async () => 'X', 'main/p1i1');
+    const b1 = await run2.step('agent', { i: 1, s: 2 }, async () => 'X', 'main/p1i1');
+
+    expect(a0).toBe('NEW');
+    expect(b0).toBe('LIVE0'); // 同车道后续作废 → 实跑
+    expect(a1).toBe('a1'); // 兄弟车道不受影响 → 重放
+    expect(b1).toBe('b1');
+    expect(run2.laneDiverged('main/p1i0')).toBe(true);
+    expect(run2.laneDiverged('main/p1i1')).toBe(false);
+  });
+
+  test('★ 主车道保持「首个失配即作废其后」—— 这条安全属性不许丢', async () => {
+    // 反例：run1 产出 plan v1 → 审查得 R2；run2 第一步产出 v2，那句审查的
+    // 指纹一模一样（路径是常量）。若按内容寻址，R2 会被当成对 v2 的审查返回。
+    const path = tmpJournal();
+    const run1 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run1.load();
+    await run1.step('agent', { p: '写计划' }, async () => 'plan v1');
+    await run1.step('agent', { p: '审查 out/plan.md' }, async () => '审查(v1)');
+
+    const run2 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run2.load();
+    await run2.step('agent', { p: '写计划(改了提示词)' }, async () => 'plan v2');
+    const review = await run2.step(
+      'agent',
+      { p: '审查 out/plan.md' }, // 指纹与上次完全相同
+      async () => '审查(v2)',
+    );
+    expect(review).toBe('审查(v2)'); // 必须实跑，不得拿 v1 的审查冒充
+  });
+
+  test('v1 账本不会被 V2 重放', async () => {
+    const path = tmpJournal();
+    const { writeFile, mkdir } = await import('node:fs/promises');
+    const { dirname } = await import('node:path');
+    const { fingerprint } = await import('../src/journal.js');
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(
+      path,
+      [
+        JSON.stringify({ seq: 1, kind: 'tool', fp: fingerprint('tool', { a: 1 }), result: 'old1' }),
+        JSON.stringify({ seq: 2, kind: 'tool', fp: fingerprint('tool', { a: 2 }), result: 'old2' }),
+      ].join('\n') + '\n',
+      'utf8',
+    );
+
+    const j = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await j.load();
+    expect(await j.step('tool', { a: 1 }, async () => 'live1')).toBe('live1');
+    expect(await j.step('tool', { a: 2 }, async () => 'live2')).toBe('live2');
+    expect(j.replayedCount).toBe(0);
+  });
+
+  test('replaying 判据是「有没有实跑过」，并发下也成立', async () => {
+    const path = tmpJournal();
+    const run1 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run1.load();
+    await run1.step('tool', { a: 1 }, async () => 'r1', 'main/p1i0');
+    await run1.step('tool', { a: 2 }, async () => 'r2', 'main/p1i1');
+
+    const run2 = new Journal(path, { bundleHash: 'test', rootRunId: 'test-root' });
+    await run2.load();
+    expect(run2.replaying).toBe(true);
+    // 先命中一次重放（乱序：先跑 1 号车道）
+    await run2.step('tool', { a: 2 }, async () => 'x', 'main/p1i1');
+    expect(run2.replaying).toBe(true);
+    // 一旦有实跑就翻
+    await run2.step('tool', { a: 999 }, async () => 'live');
+    expect(run2.replaying).toBe(false);
+  });
+});

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

@@ -0,0 +1,106 @@
+/**
+ * plugins/workflow-runner/test/listResources.test.ts
+ *   —— 守 `skills/workflow-creator/scripts/list-resources.mjs` 的准确性
+ *
+ * 这个脚本的**全部价值就是准确**：agent 照着它写 `allowedTools`，写错的名字会被
+ * 引擎静默过滤掉。一份不准的清单比没有清单更糟 —— 它会让人理直气壮地写错。
+ *
+ * 第一版就栽在这里：从**变量名**推断工具名（`lspTool` → `Lsp`、
+ * `webFetchTool` → `Webfetch`、`genImageTool` → `GenImage`），三个全错，
+ * 真名是 `LSP` / `WebFetch` / `GenerateImage`。现在改成直接问内核要 `name` 字段。
+ *
+ * 另有两个 Windows 专属的坑（spawn 到 shell 时命令被截断），见脚本里的注释。
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+
+import { ALL_TOOLS } from '../../../src/tools/index.js';
+
+const ROOT = join(import.meta.dir, '..', '..', '..');
+const SCRIPT = join(
+  ROOT,
+  'skills',
+  'workflow-creator',
+  'scripts',
+  'list-resources.mjs',
+);
+
+function runScript(args: string[] = []) {
+  const r = spawnSync('node', [SCRIPT, ...args], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
+  return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+describe('list-resources.mjs', () => {
+  test('跑得起来（node 直接 spawn，不需要 bun 在 PATH 里也不该崩）', () => {
+    const r = runScript(['--plugins']);
+    expect(r.status).toBe(0);
+  });
+
+  test('★ 工具名与 ALL_TOOLS 的真实 name 字段**完全一致**', () => {
+    // 一个字母都不能差 —— 差了就会被 allowedTools 静默过滤。
+    const r = runScript(['--json']);
+    expect(r.status).toBe(0);
+    const data = JSON.parse(r.stdout) as {
+      tools: string[];
+      toolsExact: boolean;
+    };
+    if (!data.toolsExact) {
+      // 拿不到真值时脚本必须**明说降级**而不是给一份猜的清单
+      expect(data.tools).toEqual([]);
+      return;
+    }
+    expect([...data.tools].sort()).toEqual(ALL_TOOLS.map((t) => t.name).sort());
+  });
+
+  test('★ 那三个曾被推断错的名字必须正确', () => {
+    // LSP / WebFetch / GenerateImage —— 变量名分别是 lspTool / webFetchTool / genImageTool，
+    // 按变量名推断会得到 Lsp / Webfetch / GenImage，全错。
+    const r = runScript(['--json']);
+    const data = JSON.parse(r.stdout) as {
+      tools: string[];
+      toolsExact: boolean;
+    };
+    if (!data.toolsExact) return;
+    for (const name of ['LSP', 'WebFetch', 'GenerateImage', 'WebBrowser']) {
+      expect(data.tools).toContain(name);
+    }
+  });
+
+  test('skills 清单非空且带描述（否则 agent 判断不了该用哪个）', () => {
+    const r = runScript(['--json']);
+    const data = JSON.parse(r.stdout) as {
+      skills: { name: string; description: string }[];
+    };
+    expect(data.skills.length).toBeGreaterThan(10);
+    // 至少多数条目要有描述 —— 全空说明 frontmatter 解析坏了
+    const withDesc = data.skills.filter((s) => s.description.length > 0);
+    expect(withDesc.length).toBeGreaterThan(data.skills.length / 2);
+  });
+
+  test('★ 一定要列出 workflow-runner 与 computer_use（最容易被忽略的两个入口）', () => {
+    const r = runScript(['--json']);
+    const data = JSON.parse(r.stdout) as {
+      plugins: { name: string; commands: string[] }[];
+    };
+    const names = data.plugins.map((p) => p.name);
+    expect(names).toContain('workflow-runner');
+    // computer_use 的 plugin.json 里 name 写的是 computer-use（连字符）
+    expect(names.some((n) => n.replace('_', '-') === 'computer-use')).toBe(
+      true,
+    );
+  });
+
+  test('人类可读输出里工具按用途归组，不是一坨字母序', () => {
+    const r = runScript(['--tools']);
+    if (!r.stdout.includes('═══ 工具')) return; // bun 不可用时的降级路径
+    expect(r.stdout).toContain('读写文件');
+    expect(r.stdout).toContain('桌面操控');
+    expect(r.stdout).toContain('ComputerUse');
+  });
+});