minimal-agent 0.12.0 → 0.13.0

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

@@ -67,9 +67,10 @@ describe('任务身份生命周期（L2 completed / L3 new-task 清产物）', (
     writeFileSync(join(tmp, 'PLAN.md'), '# plan');
     await s1.markDone();
     await s1.archive();
-    // 归档后活动目录已改名 .done（E6 后按名隔离）
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'plan'))).toBe(false);
-    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'plan.done'))).toBe(true);
+    // 归档后活动实例被改名 .done（workflow 级父目录保留——里面可能有多个实例）
+    expect(existsSync(join(tmp, '.minimal-agent-workflow', 'plan'))).toBe(true);
+    expect(existsSync(s1.dir + '.done')).toBe(true);
+    expect(existsSync(s1.dir)).toBe(false);
 
     // 第二次：同 goal 重跑 → completed（经 .done 检测），报真实产物
     const s2 = new WorkflowState(tmp, 'plan');
@@ -104,8 +105,9 @@ describe('任务身份生命周期（L2 completed / L3 new-task 清产物）', (
     const s2 = new WorkflowState(tmp, 'plan');
     const r2 = await s2.init('plan', { goal: '完全不相关的目标B' }, STEPS, 1, ['PLAN.md']);
     expect(r2.mode).toBe('new-task');
-    expect(r2.cleanedArtifacts).toContain('PLAN.md');
     expect(existsSync(join(tmp, 'PLAN.md'))).toBe(false);
+    expect(r2.archivedTo).toBeDefined();
+    expect(existsSync(join(tmp, r2.archivedTo as string, 'PLAN.md'))).toBe(true);
   });
 
   it('legacy 状态文件（无 artifacts 字段）+ 同名 workflow 换 goal → new-task 用本次声明清单兜底清理', async () => {
@@ -128,8 +130,9 @@ describe('任务身份生命周期（L2 completed / L3 new-task 清产物）', (
     const r = await s.init('plan', { goal: '全新目标' }, STEPS, 1, ['PLAN.md']);
     expect(r.mode).toBe('new-task');
     // 兜底清理生效：同名 workflow 的声明产物语义稳定，按本次声明清单清掉残留
-    expect(r.cleanedArtifacts).toContain('PLAN.md');
     expect(existsSync(join(tmp, 'PLAN.md'))).toBe(false);
+    expect(r.archivedTo).toBeDefined();
+    expect(existsSync(join(tmp, r.archivedTo as string, 'PLAN.md'))).toBe(true);
   });
 
   it('/new 后孤儿产物：无任何状态但声明产物已存在 → fresh 启动时清理（全新任务从干净状态开始）', async () => {
@@ -141,8 +144,59 @@ describe('任务身份生命周期（L2 completed / L3 new-task 清产物）', (
     const r = await s.init('plan', { goal: '目标A' }, STEPS, 1, ['PLAN.md']);
     expect(r.mode).toBe('fresh');
     expect(existsSync(join(tmp, 'PLAN.md'))).toBe(false);
-    // 可见化：runner 据此报「已清理旧产物」warning
-    expect(r.cleanedArtifacts).toEqual(['PLAN.md']);
+    expect(r.archivedTo).toBeDefined();
+    expect(existsSync(join(tmp, r.archivedTo as string, 'PLAN.md'))).toBe(true);
+  });
+
+  it('A4：归档保留相对路径结构，只归档声明产物、不碰未声明文件', async () => {
+    const { mkdirSync } = await import('node:fs');
+    mkdirSync(join(tmp, 'out'), { recursive: true });
+    const s1 = new WorkflowState(tmp, 'plan');
+    await s1.init('plan', { goal: '目标A' }, STEPS, 1, ['out/PLAN.md']);
+    writeFileSync(join(tmp, 'out', 'PLAN.md'), '# A');
+    writeFileSync(join(tmp, 'out', 'USER-OWN.md'), '# 用户自己的文件');
+
+    const s2 = new WorkflowState(tmp, 'plan');
+    const r2 = await s2.init('plan', { goal: '目标B' }, STEPS, 1, ['out/PLAN.md']);
+    expect(r2.mode).toBe('new-task');
+    expect(existsSync(join(tmp, 'out', 'PLAN.md'))).toBe(false);
+    expect(existsSync(join(tmp, 'out', 'USER-OWN.md'))).toBe(true);
+    expect(existsSync(join(tmp, r2.archivedTo as string, 'out', 'PLAN.md'))).toBe(true);
+  });
+
+  it('B8：声明产物支持 glob（out/*.md），new-task 清理时展开为实际文件归档', async () => {
+    const { mkdirSync } = await import('node:fs');
+    mkdirSync(join(tmp, 'out'), { recursive: true });
+    const s1 = new WorkflowState(tmp, 'research');
+    await s1.init('research', { goal: '目标A' }, STEPS, 1, ['out/deep-dive-*.md']);
+    writeFileSync(join(tmp, 'out', 'deep-dive-a.md'), '# A');
+    writeFileSync(join(tmp, 'out', 'deep-dive-b.md'), '# B');
+    writeFileSync(join(tmp, 'out', 'notes.txt'), '# 不匹配 md');
+
+    const s2 = new WorkflowState(tmp, 'research');
+    const r2 = await s2.init('research', { goal: '目标B' }, STEPS, 1, ['out/deep-dive-*.md']);
+    expect(r2.mode).toBe('new-task');
+    expect(existsSync(join(tmp, 'out', 'deep-dive-a.md'))).toBe(false);
+    expect(existsSync(join(tmp, 'out', 'deep-dive-b.md'))).toBe(false);
+    expect(existsSync(join(tmp, 'out', 'notes.txt'))).toBe(true);
+    const trash = join(tmp, r2.archivedTo as string);
+    expect(existsSync(join(trash, 'out', 'deep-dive-a.md'))).toBe(true);
+    expect(existsSync(join(trash, 'out', 'deep-dive-b.md'))).toBe(true);
+  });
+
+  it('B8：越界 glob（../x*）不展开不清理（fail-closed）', async () => {
+    writeFileSync(join(tmp, 'PLAN.md'), '# inside');
+    const outside = mkdtempSync(join(tmpdir(), 'wf-outside-'));
+    try {
+      writeFileSync(join(outside, 'secret.md'), '# outside');
+      const s = new WorkflowState(tmp, 'plan');
+      const r = await s.init('plan', { goal: '目标A' }, STEPS, 1, ['../x*.md', 'PLAN.md']);
+      expect(r.mode).toBe('fresh');
+      expect(existsSync(join(outside, 'secret.md'))).toBe(true);
+      expect(existsSync(join(tmp, 'PLAN.md'))).toBe(false);
+    } finally {
+      rmSync(outside, { recursive: true, force: true });
+    }
   });
 
   it('resume 恢复点用最后完成步的【索引】而非 checkpoint 计数（when 跳过步不再被重复执行）', async () => {

package/plugins/workflow-runner/test/webppt.load.test.ts

@@ -70,11 +70,11 @@ describe('workflows/webppt.yaml', () => {
       expect(String(s.title)).toContain('/11');
     }
 
-    // 收尾报告 echo；artifacts 只列最终交付物、不在被 rm 的 ./build 下
+    // 收尾报告 echo；artifacts 只列最终交付物、不在被 rm 的 out/webppt/${session}/build 下
     expect(def.steps.find((s) => s.id === 'final_report')?.type).toBe('echo');
     const declared = def.artifacts ?? [];
-    expect(declared).toContain('./out/deck.pptx');
-    for (const a of declared) expect(a.startsWith('./build')).toBe(false);
+    expect(declared).toContain('out/webppt/${session}/deck.pptx');
+    for (const a of declared) expect(a.startsWith('out/webppt/${session}/build')).toBe(false);
   });
 
   it('需求分析步：style 为空时必问视觉样式（VI 选项 + 自定义输入），AskUserQuestion 可用', async () => {
@@ -199,7 +199,7 @@ describe('workflows/webppt.yaml', () => {
     // 配图分流闸门：image_plan_lint 的 --outline 直接吃 design.json
     const gate = def.steps.find((s) => s.id === 'stage_img_route_gate');
     expect(String(gate?.agent)).toContain('image_plan_lint.py');
-    expect(String(gate?.agent)).toContain('--outline ./build/design.json');
+    expect(String(gate?.agent)).toContain('--outline out/webppt/${session}/build/design.json');
     expect(String(gate?.done_when)).toContain('img_route_ok');
     // 顺序：build_loop → img_route_gate → gen_images
     expect(ids.indexOf('stage_img_route_gate')).toBeGreaterThan(ids.indexOf('stage_build_loop'));

package/plugins/workflow-runner/test/word.load.test.ts

@@ -3,7 +3,7 @@
  * ------------------------------------------------------------
  * 锁定 workflows/word.yaml（素材驱动知乎深度长文 Word 工作流）的
  * 「可解析 + 关键骨架」：
- *   - name=word，最终产物是 ./out/article.docx
+ *   - name=word，最终产物是 out/word/${session}/article.docx
  *   - inputs 支持 topic(greedy) / source / out / image_intensity / quality / debug_keep_build
  *   - Markdown-first：material → outline → article.md → image_map/img_plan → docx skill → OPC
  *   - 客户图必须使用；需要解释型视觉时积极文生图，提示词必须结合上下文
@@ -32,8 +32,8 @@ describe('workflows/word.yaml（素材驱动·知乎深度长文 Word）', () =>
     expect(def.description).toContain('知乎深度文章');
 
     const declared = def.artifacts ?? [];
-    expect(declared).toContain('./out/article.docx');
-    for (const a of declared) expect(a.startsWith('./build')).toBe(false);
+    expect(declared).toContain('out/word/${session}/article.docx');
+    for (const a of declared) expect(a.startsWith('out/word/${session}/build')).toBe(false);
 
     const inputNames = (def.inputs ?? []).map((i) => i.name);
     expect(inputNames).toEqual(
@@ -49,7 +49,7 @@ describe('workflows/word.yaml（素材驱动·知乎深度长文 Word）', () =>
     expect(inputNames[0]).toBe('topic');
     expect((def.inputs ?? []).find((i) => i.name === 'topic')?.greedy).toBe(true);
     expect((def.inputs ?? []).find((i) => i.name === 'out')?.default).toBe(
-      './out/article.docx',
+      'out/word/${session}/article.docx',
     );
   });
 
@@ -163,11 +163,11 @@ describe('workflows/word.yaml（素材驱动·知乎深度长文 Word）', () =>
     const extract = def.steps.find((s) => s.id === 'stage_extract');
     const command = String(extract?.args?.command ?? '');
 
-    expect(command).toContain('./build/source.md');
-    expect(command).toContain('rm -rf ./build/assets');
-    expect(command).toContain('mkdir -p ./build/assets');
-    expect(command).toContain('./build/word_topic_image_gate.json');
-    expect(command).toContain('./build/word_topic_image_gate.md');
+    expect(command).toContain('out/word/${session}/build/source.md');
+    expect(command).toContain('rm -rf out/word/${session}/build/assets');
+    expect(command).toContain('mkdir -p out/word/${session}/build/assets');
+    expect(command).toContain('out/word/${session}/build/word_topic_image_gate.json');
+    expect(command).toContain('out/word/${session}/build/word_topic_image_gate.md');
   });
 
   it('生成配图失败时会在导出前硬失败，不会把渐变占位图交付进 Word', async () => {

package/skills/skill-creator/scripts/run_eval.py

@@ -20,14 +20,15 @@ from scripts.utils import parse_skill_md
 
 
 def find_project_root() -> Path:
-    """Find the project root by walking up from cwd looking for .claude/.
+    """Find the project root by walking up from cwd looking for .kakadeai/
+    (this repo's project-config dir) or .claude/ (upstream convention).
 
     Mimics how Claude Code discovers its project root, so the command file
     we create ends up where claude -p will look for it.
     """
     current = Path.cwd()
     for parent in [current, *current.parents]:
-        if (parent / ".claude").is_dir():
+        if (parent / ".kakadeai").is_dir() or (parent / ".claude").is_dir():
             return parent
     return current
 

package/src/cli/print.js

@@ -108,8 +108,16 @@ export function extractImageOptions(args) {
  *   stop_reason = end_turn | max_turns | stalled | error | interrupted | config_error
  *   num_turns   = assistant_message 事件计数
  *   error       = 失败文案（成功时 null）
+ *   warnings    = 本轮所有非致命警告（与 stderr 同源；宿主要结构化的那一份）
  *   session_file（可选）= 当前对话落盘路径；拿得到才填，拿不到省略该键
  *
+ *   completionStatus = 本层从 stop_reason + deliverables 重算：跑完了没、产物验没验
+ *   delivery_status（可选）= 内核 turn_done 的交付判定，**回答的是另一个问题**：
+ *     completed / delivery_incomplete / delivery_unverified / claims_unverified。
+ *     两者并列而非替代 —— `ok:true` 配 `delivery_status:'claims_unverified'` 是
+ *     完全合法的一行：Agent 确实正常收尾了，但它宣称的「测试已通过」没有证据支撑。
+ *     判断「任务是否真做成」的宿主应当读它，而不是只看 ok。
+ *
  * 导出供单测断言。
  */
 export function emitJsonResult(result, sessionFile) {
@@ -136,6 +144,7 @@ export function emitJsonResult(result, sessionFile) {
         num_turns: result.numTurns,
         error: result.error,
         completionStatus,
+        ...(result.deliveryStatus ? { delivery_status: result.deliveryStatus } : {}),
         deliverables,
         verification: allVerified ? 'passed' : deliverables.length > 0 ? 'not_run' : 'none',
         warnings,
@@ -399,11 +408,19 @@ export function handleEvent(event, result, verbose, outputFormat = 'text') {
             // 通用非致命警告（如 workflow 多余参数、pause 被自动跳过等）始终走 stderr，
             // 不受 verbose 控制 —— 这是用户必须看到的信号，避免静默丢弃语义被忽略。
             process.stderr.write(`${event.message}\n`);
+            // 同时收进结局契约：stderr 是给人看的，spawn 它的宿主要的是结构化的一条。
+            // （此前 PrintResult.warnings 声明了、读了、也输出了，就是没有任何地方写它 ——
+            //  json 那行的 warnings 恒为空数组。）
+            (result.warnings ??= []).push(event.message);
             return {};
         case 'turn_done':
             // text 模式：非 verbose 时这里一次性把累积答案打到 stdout（旧行为，逐字节不变）。
             // json 模式：只记 stopReason='end_turn'，stdout 保持静默。
             result.stopReason = 'end_turn';
+            // 内核的交付判定必须过进程边界：模型谎称「已验证」时，若不记这一笔，
+            // 宿主收到的 JSON 与一切正常逐字节相同，唯一线索只剩 stderr 上一行中文。
+            if (event.completionStatus)
+                result.deliveryStatus = event.completionStatus;
             if (!isJson && !verbose)
                 console.log(result.buffer);
             return {};

package/src/cli/print.ts

@@ -98,6 +98,15 @@ export interface PrintResult {
   deliverables?: DeliverableManifest['files'];
   warnings?: string[];
   harnessDiagnostics?: HarnessDiagnostics;
+  /**
+   * 内核 `turn_done` 给出的交付判定（loop.ts 的四态词表）。
+   *
+   * 与下面 json 里那个从 stopReason+deliverables 重算的 `completionStatus` **不是**
+   * 一回事：那个只回答「跑完了没、产物验没验」，这个回答「模型宣称的事到底做没做」。
+   * 尤其 `claims_unverified` —— 模型说「测试已全部通过」但本轮证据台账里没有一条
+   * 成功的验证记录 —— 是重不重要全看它能不能过进程边界。
+   */
+  deliveryStatus?: string;
 }
 
 /** handleEvent 返回的结构 */
@@ -191,8 +200,16 @@ export function extractImageOptions(args: string[]): {
  *   stop_reason = end_turn | max_turns | stalled | error | interrupted | config_error
  *   num_turns   = assistant_message 事件计数
  *   error       = 失败文案（成功时 null）
+ *   warnings    = 本轮所有非致命警告（与 stderr 同源；宿主要结构化的那一份）
  *   session_file（可选）= 当前对话落盘路径；拿得到才填，拿不到省略该键
  *
+ *   completionStatus = 本层从 stop_reason + deliverables 重算：跑完了没、产物验没验
+ *   delivery_status（可选）= 内核 turn_done 的交付判定，**回答的是另一个问题**：
+ *     completed / delivery_incomplete / delivery_unverified / claims_unverified。
+ *     两者并列而非替代 —— `ok:true` 配 `delivery_status:'claims_unverified'` 是
+ *     完全合法的一行：Agent 确实正常收尾了，但它宣称的「测试已通过」没有证据支撑。
+ *     判断「任务是否真做成」的宿主应当读它，而不是只看 ok。
+ *
  * 导出供单测断言。
  */
 export function emitJsonResult(result: PrintResult, sessionFile?: string): void {
@@ -220,6 +237,7 @@ export function emitJsonResult(result: PrintResult, sessionFile?: string): void
       num_turns: result.numTurns,
       error: result.error,
       completionStatus,
+      ...(result.deliveryStatus ? { delivery_status: result.deliveryStatus } : {}),
       deliverables,
       verification: allVerified ? 'passed' : deliverables.length > 0 ? 'not_run' : 'none',
       warnings,
@@ -509,12 +527,19 @@ export function handleEvent(
       // 通用非致命警告（如 workflow 多余参数、pause 被自动跳过等）始终走 stderr，
       // 不受 verbose 控制 —— 这是用户必须看到的信号，避免静默丢弃语义被忽略。
       process.stderr.write(`${event.message}\n`);
+      // 同时收进结局契约：stderr 是给人看的，spawn 它的宿主要的是结构化的一条。
+      // （此前 PrintResult.warnings 声明了、读了、也输出了，就是没有任何地方写它 ——
+      //  json 那行的 warnings 恒为空数组。）
+      (result.warnings ??= []).push(event.message);
       return {};
 
     case 'turn_done':
       // text 模式：非 verbose 时这里一次性把累积答案打到 stdout（旧行为，逐字节不变）。
       // json 模式：只记 stopReason='end_turn'，stdout 保持静默。
       result.stopReason = 'end_turn';
+      // 内核的交付判定必须过进程边界：模型谎称「已验证」时，若不记这一笔，
+      // 宿主收到的 JSON 与一切正常逐字节相同，唯一线索只剩 stderr 上一行中文。
+      if (event.completionStatus) result.deliveryStatus = event.completionStatus;
       if (!isJson && !verbose) console.log(result.buffer);
       return {};
 

package/src/config/configService.js

@@ -373,6 +373,30 @@ export class ConfigService {
             return null;
         return { ...advisor, provider: resolveProvider(entry), supportsVision: entry.supportsVision !== false };
     }
+    /**
+     * 同步版 advisor 可用性探测——仅用于 resolveAvailability 这类工具列表探测场景。
+     * 读当前内存快照（可能略滞后于磁盘最新值），但调用频率高、对实时性要求不高，
+     * 下一轮 LLM 请求前 configService.reload() 会刷新。
+     *
+     * 为什么不用 advisor() 的 fresh reload：
+     * resolveAvailability 是在主循环构造工具集时同步调用的，不能 await；
+     * 而且每次工具集构造都读盘的话开销太大（主循环每轮都可能构造一次）。
+     */
+    advisorAvailabilitySync() {
+        const config = this.snapshot.config;
+        const advisor = config?.advisor;
+        if (!advisor?.modelId)
+            return { enabled: false, mode: 'auto', modelId: null, configured: false };
+        const entry = config?.models?.find((m) => m.id === advisor.modelId);
+        if (!entry?.apiKey)
+            return { enabled: false, mode: 'auto', modelId: null, configured: false };
+        return {
+            enabled: advisor.enabled !== false,
+            mode: advisor.mode === 'manual' ? 'manual' : 'auto',
+            modelId: advisor.modelId,
+            configured: true,
+        };
+    }
     async subagents() {
         return (await this.reload()).config?.subagents ?? DEFAULT_SUBAGENTS_CONFIG;
     }

package/src/config/configService.ts

@@ -431,6 +431,29 @@ export class ConfigService {
     return { ...advisor, provider: resolveProvider(entry), supportsVision: entry.supportsVision !== false };
   }
 
+  /**
+   * 同步版 advisor 可用性探测——仅用于 resolveAvailability 这类工具列表探测场景。
+   * 读当前内存快照（可能略滞后于磁盘最新值），但调用频率高、对实时性要求不高，
+   * 下一轮 LLM 请求前 configService.reload() 会刷新。
+   *
+   * 为什么不用 advisor() 的 fresh reload：
+   * resolveAvailability 是在主循环构造工具集时同步调用的，不能 await；
+   * 而且每次工具集构造都读盘的话开销太大（主循环每轮都可能构造一次）。
+   */
+  advisorAvailabilitySync(): { enabled: boolean; mode: 'auto' | 'manual'; modelId: string | null; configured: boolean } {
+    const config = this.snapshot.config;
+    const advisor = config?.advisor;
+    if (!advisor?.modelId) return { enabled: false, mode: 'auto', modelId: null, configured: false };
+    const entry = config?.models?.find((m) => m.id === advisor.modelId);
+    if (!entry?.apiKey) return { enabled: false, mode: 'auto', modelId: null, configured: false };
+    return {
+      enabled: advisor.enabled !== false,
+      mode: advisor.mode === 'manual' ? 'manual' : 'auto',
+      modelId: advisor.modelId,
+      configured: true,
+    };
+  }
+
   async subagents(): Promise<SubagentsConfig> {
     return (await this.reload()).config?.subagents ?? DEFAULT_SUBAGENTS_CONFIG;
   }

package/src/infra/verification.js

@@ -16,7 +16,13 @@
  *  设计原则：
  *    - 纯工具函数，无全局状态，无副作用（除了 shell 子进程）
  *    - 不依赖任何插件代码，可被 src/ 和 plugins/ 同时导入
- *    - 工作目录隔离：所有相对路径以 getWorkingDir() 为锚
+ *    - 工作目录隔离：相对路径以调用方给的 cwd 为锚，缺省 getWorkingDir()
+ *
+ *  ⚠️ cwd 参数不是可有可无的修饰：**验收必须和写入锚在同一个目录**。
+ *  会话进入 session worktree 后（EnterWorktree），写文件的工具跟着 worktree 走
+ *  （loop.ts 按 sessionState.activeWorktree 重定向 cwd），验收若仍锚原 workspace，
+ *  就会在空目录里找产物 —— file_exists 恒 false，工作流被判失败并反复重试，
+ *  而产物其实好好躺在 worktree 里。调用方拿得到有效 cwd 时务必传进来。
  * ============================================================
  */
 import { existsSync, readFileSync } from 'node:fs';
@@ -92,12 +98,13 @@ function isAbsolutePath(file) {
         /^[A-Za-z]:[\\/]/.test(file) // C:\ 或 C:/
     );
 }
-function runShell(command, timeout) {
+function runShell(command, timeout, cwd) {
     return new Promise((resolve) => {
         const isWin = process.platform === 'win32';
+        const opts = { timeout, cwd, env: sanitizeCredentialEnv() };
         const child = isWin
-            ? spawn('cmd', ['/c', command], { timeout, env: sanitizeCredentialEnv() })
-            : spawn('bash', ['-c', command], { timeout, env: sanitizeCredentialEnv() });
+            ? spawn('cmd', ['/c', command], opts)
+            : spawn('bash', ['-c', command], opts);
         let stdout = '';
         let stderr = '';
         child.stdout.on('data', (d) => {
@@ -114,8 +121,8 @@ function runShell(command, timeout) {
         });
     });
 }
-export async function verifyShell(command, timeout) {
-    const r = await runShell(command, timeout);
+export async function verifyShell(command, timeout, cwd = getWorkingDir()) {
+    const r = await runShell(command, timeout, cwd);
     if (r.errored) {
         return {
             check: { type: 'shell', command },
@@ -129,9 +136,9 @@ export async function verifyShell(command, timeout) {
         output: r.stdout.trim() || r.stderr.trim() || `exit code ${r.exitCode}`,
     };
 }
-export function verifyFileExists(file) {
-    // 相对路径以 workingDir 为锚（绝对路径识别含 UNC）
-    const resolved = isAbsolutePath(file) ? file : `${getWorkingDir()}/${file}`;
+export function verifyFileExists(file, cwd = getWorkingDir()) {
+    // 相对路径以调用方给的 cwd 为锚（绝对路径识别含 UNC）
+    const resolved = isAbsolutePath(file) ? file : `${cwd}/${file}`;
     const exists = existsSync(resolved);
     return {
         check: { type: 'file_exists', file },
@@ -139,8 +146,8 @@ export function verifyFileExists(file) {
         output: exists ? '文件存在' : `文件不存在: ${resolved}`,
     };
 }
-export function verifyFileContains(file, pattern) {
-    const resolved = isAbsolutePath(file) ? file : `${getWorkingDir()}/${file}`;
+export function verifyFileContains(file, pattern, cwd = getWorkingDir()) {
+    const resolved = isAbsolutePath(file) ? file : `${cwd}/${file}`;
     try {
         const content = readFileSync(resolved, 'utf8');
         const regex = new RegExp(pattern);
@@ -159,11 +166,11 @@ export function verifyFileContains(file, pattern) {
         };
     }
 }
-async function verifyTestCount(minCount) {
+async function verifyTestCount(minCount, cwd = getWorkingDir()) {
     // 跨运行时：开发用 bun → bun test；npm 全局安装用 Node → npm test --silent
     // 用 process.versions.bun 探测比 typeof Bun !== 'undefined' 更稳（不依赖全局类型）
     const cmd = process.versions.bun ? 'bun test' : 'npm test --silent';
-    const r = await runShell(cmd, 60_000);
+    const r = await runShell(cmd, 60_000, cwd);
     const combined = `${r.stdout}\n${r.stderr}`;
     if (r.errored) {
         return {
@@ -185,7 +192,7 @@ async function verifyTestCount(minCount) {
  * 执行一组检查，返回聚合结果。
  * 全部通过 → passed=true；任一失败 → passed=false + summary 列出失败项。
  */
-export async function runVerification(checks) {
+export async function runVerification(checks, cwd = getWorkingDir()) {
     if (checks.length === 0) {
         return { passed: true, details: [], summary: '无验证项' };
     }
@@ -194,16 +201,16 @@ export async function runVerification(checks) {
         let result;
         switch (check.type) {
             case 'shell':
-                result = await verifyShell(check.command ?? '', check.timeout ?? 30_000);
+                result = await verifyShell(check.command ?? '', check.timeout ?? 30_000, cwd);
                 break;
             case 'file_exists':
-                result = verifyFileExists(check.file ?? '');
+                result = verifyFileExists(check.file ?? '', cwd);
                 break;
             case 'file_contains':
-                result = verifyFileContains(check.file ?? '', check.pattern ?? '');
+                result = verifyFileContains(check.file ?? '', check.pattern ?? '', cwd);
                 break;
             case 'test_count':
-                result = await verifyTestCount(check.minCount ?? 0);
+                result = await verifyTestCount(check.minCount ?? 0, cwd);
                 break;
             default:
                 result = {

package/src/infra/verification.ts

@@ -16,7 +16,13 @@
  *  设计原则：
  *    - 纯工具函数，无全局状态，无副作用（除了 shell 子进程）
  *    - 不依赖任何插件代码，可被 src/ 和 plugins/ 同时导入
- *    - 工作目录隔离：所有相对路径以 getWorkingDir() 为锚
+ *    - 工作目录隔离：相对路径以调用方给的 cwd 为锚，缺省 getWorkingDir()
+ *
+ *  ⚠️ cwd 参数不是可有可无的修饰：**验收必须和写入锚在同一个目录**。
+ *  会话进入 session worktree 后（EnterWorktree），写文件的工具跟着 worktree 走
+ *  （loop.ts 按 sessionState.activeWorktree 重定向 cwd），验收若仍锚原 workspace，
+ *  就会在空目录里找产物 —— file_exists 恒 false，工作流被判失败并反复重试，
+ *  而产物其实好好躺在 worktree 里。调用方拿得到有效 cwd 时务必传进来。
  * ============================================================
  */
 
@@ -128,12 +134,17 @@ interface ShellRunResult {
   errored: boolean;
 }
 
-function runShell(command: string, timeout: number): Promise<ShellRunResult> {
+function runShell(
+  command: string,
+  timeout: number,
+  cwd: string,
+): Promise<ShellRunResult> {
   return new Promise((resolve) => {
     const isWin = process.platform === 'win32';
+    const opts = { timeout, cwd, env: sanitizeCredentialEnv() };
     const child = isWin
-      ? spawn('cmd', ['/c', command], { timeout, env: sanitizeCredentialEnv() })
-      : spawn('bash', ['-c', command], { timeout, env: sanitizeCredentialEnv() });
+      ? spawn('cmd', ['/c', command], opts)
+      : spawn('bash', ['-c', command], opts);
 
     let stdout = '';
     let stderr = '';
@@ -155,8 +166,12 @@ function runShell(command: string, timeout: number): Promise<ShellRunResult> {
   });
 }
 
-export async function verifyShell(command: string, timeout: number): Promise<CheckResult> {
-  const r = await runShell(command, timeout);
+export async function verifyShell(
+  command: string,
+  timeout: number,
+  cwd: string = getWorkingDir(),
+): Promise<CheckResult> {
+  const r = await runShell(command, timeout, cwd);
   if (r.errored) {
     return {
       check: { type: 'shell', command },
@@ -171,9 +186,12 @@ export async function verifyShell(command: string, timeout: number): Promise<Che
   };
 }
 
-export function verifyFileExists(file: string): CheckResult {
-  // 相对路径以 workingDir 为锚（绝对路径识别含 UNC）
-  const resolved = isAbsolutePath(file) ? file : `${getWorkingDir()}/${file}`;
+export function verifyFileExists(
+  file: string,
+  cwd: string = getWorkingDir(),
+): CheckResult {
+  // 相对路径以调用方给的 cwd 为锚（绝对路径识别含 UNC）
+  const resolved = isAbsolutePath(file) ? file : `${cwd}/${file}`;
   const exists = existsSync(resolved);
   return {
     check: { type: 'file_exists', file },
@@ -182,8 +200,12 @@ export function verifyFileExists(file: string): CheckResult {
   };
 }
 
-export function verifyFileContains(file: string, pattern: string): CheckResult {
-  const resolved = isAbsolutePath(file) ? file : `${getWorkingDir()}/${file}`;
+export function verifyFileContains(
+  file: string,
+  pattern: string,
+  cwd: string = getWorkingDir(),
+): CheckResult {
+  const resolved = isAbsolutePath(file) ? file : `${cwd}/${file}`;
   try {
     const content = readFileSync(resolved, 'utf8');
     const regex = new RegExp(pattern);
@@ -203,11 +225,14 @@ export function verifyFileContains(file: string, pattern: string): CheckResult {
   }
 }
 
-async function verifyTestCount(minCount: number): Promise<CheckResult> {
+async function verifyTestCount(
+  minCount: number,
+  cwd: string = getWorkingDir(),
+): Promise<CheckResult> {
   // 跨运行时：开发用 bun → bun test；npm 全局安装用 Node → npm test --silent
   // 用 process.versions.bun 探测比 typeof Bun !== 'undefined' 更稳（不依赖全局类型）
   const cmd = process.versions.bun ? 'bun test' : 'npm test --silent';
-  const r = await runShell(cmd, 60_000);
+  const r = await runShell(cmd, 60_000, cwd);
   const combined = `${r.stdout}\n${r.stderr}`;
   if (r.errored) {
     return {
@@ -232,7 +257,10 @@ async function verifyTestCount(minCount: number): Promise<CheckResult> {
  * 执行一组检查，返回聚合结果。
  * 全部通过 → passed=true；任一失败 → passed=false + summary 列出失败项。
  */
-export async function runVerification(checks: Check[]): Promise<VerifyResult> {
+export async function runVerification(
+  checks: Check[],
+  cwd: string = getWorkingDir(),
+): Promise<VerifyResult> {
   if (checks.length === 0) {
     return { passed: true, details: [], summary: '无验证项' };
   }
@@ -244,16 +272,20 @@ export async function runVerification(checks: Check[]): Promise<VerifyResult> {
 
     switch (check.type) {
       case 'shell':
-        result = await verifyShell(check.command ?? '', check.timeout ?? 30_000);
+        result = await verifyShell(
+          check.command ?? '',
+          check.timeout ?? 30_000,
+          cwd,
+        );
         break;
       case 'file_exists':
-        result = verifyFileExists(check.file ?? '');
+        result = verifyFileExists(check.file ?? '', cwd);
         break;
       case 'file_contains':
-        result = verifyFileContains(check.file ?? '', check.pattern ?? '');
+        result = verifyFileContains(check.file ?? '', check.pattern ?? '', cwd);
         break;
       case 'test_count':
-        result = await verifyTestCount(check.minCount ?? 0);
+        result = await verifyTestCount(check.minCount ?? 0, cwd);
         break;
       default:
         result = {

package/src/plugins/pluginRunner.js

@@ -9,12 +9,12 @@
  *    2) / 输入 → discoverPlugins → resolveCommand
  *       a) 命中插件且其 plugin.ts 暴露 runCommand → 让 plugin.ts 接管
  *       b) 命中插件但只有声明式 commands/*.md → 把 prompt 拼好喂给 runQuery
- *       c) 未命中 → 静默透传 runQuery（/ 只是激活前缀，不是严格命令系统；
- *          未知的 /xxx 当普通用户输入处理，不报错）
+ *       c) 未命中 -> warning 提示未知命令后透传 runQuery（/ 只是激活前缀，
+ *          不是严格命令系统；未知的 /xxx 当普通用户输入处理，不报错）
  * ============================================================
  */
 import { runQuery } from '../loop.js';
-import { buildCommandInput, discoverPlugins, resolveCommand, } from './commandRouter.js';
+import { buildCommandInput, discoverPlugins, listAvailableCommands, resolveCommand, } from './commandRouter.js';
 import { loadPluginApi } from './pluginLoader.js';
 export async function* runWithPlugins(userInput, options) {
     const { provider, history, signal } = options;
@@ -56,10 +56,21 @@ export async function* runWithPlugins(userInput, options) {
     await discoverPlugins();
     const matched = resolveCommand(userInput);
     if (!matched) {
-        // 未命中任何插件命令 → 静默透传 runQuery。
-        // / 只是激活前缀（类似 Claude Code 的 / 模式），不是严格命令系统。
-        // 用户可能输入 /init、/help、/任何东西 —— 不匹配就当普通对话处理，
-        // 让 LLM 自行理解意图。不报错、不提示、不打断用户体验。
+        // 未命中任何插件命令 -> 提示后透传 runQuery。
+        // / 只是激活前缀（类似 Claude Code 的 / 模式），不是严格命令系统：
+        // 不匹配仍当普通对话处理，让 LLM 自行理解意图。但 -p 等无人值守场景里
+        // 拼错的 /reseach 会被静默当文本烧一轮 LLM（实战：用户以为在跑工作流，
+        // 实际什么都没发生）--先 warning 列出已注册命令，零成本纠正拼写。
+        const trimmedUnknown = userInput.trimStart();
+        const spaceUnknown = trimmedUnknown.indexOf(' ', 1);
+        const unknownCmd = (spaceUnknown >= 0 ? trimmedUnknown.slice(1, spaceUnknown) : trimmedUnknown.slice(1)).trim();
+        if (unknownCmd) {
+            const available = listAvailableCommands().map((c) => c.command);
+            yield {
+                type: 'warning',
+                message: `未知命令 /${unknownCmd}（已注册：${available.length ? available.join('、') : '无'}），已按普通对话处理。`,
+            };
+        }
         yield* runQuery(userInput, {
             provider,
             history,