minimal-agent 0.11.0 → 0.13.0

package/src/context/contextBundle.js

@@ -8,10 +8,24 @@ export function contextFragment(input) {
         estimatedTokens: input.estimatedTokens ?? countTextTokens(content),
     };
 }
-function clipToTokenBudget(content, budgetTokens) {
+const CLIP_MARKER = '\n[上下文片段因预算截断]';
+/**
+ * 按**渲染后**的 token 数收敛，而不是裸内容。
+ *
+ * ⚠️ 曾经的实现拿裸内容 token 判预算、外层却用 `renderedTokens()`（JSON 转义 + 信封）验收，
+ * 于是 `裸 token ≤ 预算 < 渲染 token` 这个窗口里 clip 会「认为放得下」原样返回，验收再不通过，
+ * 片段就被整段丢进 `omittedIds` —— `clippable` 形同虚设（`clippedIds` 恒空）。
+ * 窗口宽度 = 转义膨胀量，所以 **Windows 上尤其致命**：技能目录里每个 `\` 都要转义成 `\\`，
+ * 27 条技能的窗口从 POSIX 的 ~25 token 涨到 ~92 token，本仓库实测整份 `skills.catalog`
+ * （2643 token）在还剩 1900+ token 预算时被整个扔掉，模型完全看不到任何 Skill。
+ *
+ * 判据必须与验收同口径：这里直接对 `measure(候选内容)` 二分，measure 由调用方传入，
+ * 保证「算的就是最终要花的」。
+ */
+function clipToRenderedBudget(content, budgetTokens, measure) {
     if (budgetTokens <= 0)
         return '';
-    if (countTextTokens(content) <= budgetTokens)
+    if (measure(content) <= budgetTokens)
         return content;
     // Token counter is deliberately dependency-free. Binary search preserves its
     // exact mixed Chinese/ASCII estimate instead of falling back to chars/4.
@@ -19,12 +33,15 @@ function clipToTokenBudget(content, budgetTokens) {
     let high = content.length;
     while (low < high) {
         const mid = Math.ceil((low + high) / 2);
-        if (countTextTokens(content.slice(0, mid)) <= Math.max(1, budgetTokens - 12))
+        const candidate = `${content.slice(0, mid).trimEnd()}${CLIP_MARKER}`;
+        if (measure(candidate) <= budgetTokens)
             low = mid;
         else
             high = mid - 1;
     }
-    return `${content.slice(0, low).trimEnd()}\n[上下文片段因预算截断]`;
+    if (low <= 0)
+        return '';
+    return `${content.slice(0, low).trimEnd()}${CLIP_MARKER}`;
 }
 export function renderContextFragment(fragment) {
     const encoded = JSON.stringify(fragment.content)
@@ -36,6 +53,9 @@ export function renderContextFragment(fragment) {
 function renderedTokens(fragment) {
     return countTextTokens(renderContextFragment(fragment));
 }
+/** 片段之间的分隔符——记账时必须与最终 join 用的是同一个常量。 */
+const FRAGMENT_SEPARATOR = '\n\n';
+const SEPARATOR_TOKENS = countTextTokens(FRAGMENT_SEPARATOR);
 /**
  * Deterministic context budgeting. Required host facts are kept first; optional
  * fragments compete by priority, then original order. No LLM call is involved.
@@ -52,21 +72,26 @@ export function assembleContextBundle(input, budgetTokens = DEFAULT_TRANSIENT_BU
     let remaining = Math.max(0, budgetTokens);
     for (const item of ordered) {
         const fragment = item.fragment;
+        // 片段之间要用 SEPARATOR 拼接，那几个 token 也得记账，否则最终 text 会超出预算
+        // （usedTokens > budgetTokens 会让 loop.ts::transientFor 的余量判断失真）。
+        const separator = included.length > 0 ? SEPARATOR_TOKENS : 0;
+        const budgetForItem = remaining - separator;
         const fullTokens = renderedTokens(fragment);
-        if (fullTokens <= remaining) {
+        if (fullTokens <= budgetForItem) {
             included.push(item);
-            remaining -= fullTokens;
+            remaining -= fullTokens + separator;
             continue;
         }
-        if ((fragment.required || fragment.clippable) && remaining > 24) {
-            const wrapperTokens = renderedTokens({ ...fragment, content: '' });
-            const content = clipToTokenBudget(fragment.content, Math.max(0, remaining - wrapperTokens));
+        if ((fragment.required || fragment.clippable) && budgetForItem > 24) {
+            // 同口径：二分时就按「这段内容渲染进本片段信封后要花多少 token」来量。
+            const content = clipToRenderedBudget(fragment.content, budgetForItem, (candidate) => renderedTokens({ ...fragment, content: candidate }));
             const clipped = contextFragment({ ...fragment, content });
             const clippedTokens = renderedTokens(clipped);
-            if (clipped.content && clippedTokens <= remaining) {
+            if (clipped.content && clippedTokens <= budgetForItem) {
                 included.push({ fragment: clipped, index: item.index });
-                clippedIds.push(fragment.id);
-                remaining -= clippedTokens;
+                if (clipped.content !== fragment.content)
+                    clippedIds.push(fragment.id);
+                remaining -= clippedTokens + separator;
                 continue;
             }
         }
@@ -75,7 +100,7 @@ export function assembleContextBundle(input, budgetTokens = DEFAULT_TRANSIENT_BU
     // Rendering follows semantic input order, not selection priority.
     included.sort((a, b) => a.index - b.index);
     const selected = included.map((item) => item.fragment);
-    const text = selected.map(renderContextFragment).join('\n\n');
+    const text = selected.map(renderContextFragment).join(FRAGMENT_SEPARATOR);
     const usedTokens = countTextTokens(text);
     return {
         fragments: selected,

package/src/context/contextBundle.ts

@@ -8,6 +8,7 @@ export type ContextFragmentKind =
   | 'project'
   | 'skill'
   | 'plugin'
+  | 'task'
   | 'diagnostic';
 
 export type ContextAuthority = 'host' | 'constraint' | 'user-evidence' | 'untrusted-data';
@@ -50,19 +51,40 @@ export function contextFragment(
   };
 }
 
-function clipToTokenBudget(content: string, budgetTokens: number): string {
+const CLIP_MARKER = '\n[上下文片段因预算截断]';
+
+/**
+ * 按**渲染后**的 token 数收敛，而不是裸内容。
+ *
+ * ⚠️ 曾经的实现拿裸内容 token 判预算、外层却用 `renderedTokens()`（JSON 转义 + 信封）验收，
+ * 于是 `裸 token ≤ 预算 < 渲染 token` 这个窗口里 clip 会「认为放得下」原样返回，验收再不通过，
+ * 片段就被整段丢进 `omittedIds` —— `clippable` 形同虚设（`clippedIds` 恒空）。
+ * 窗口宽度 = 转义膨胀量，所以 **Windows 上尤其致命**：技能目录里每个 `\` 都要转义成 `\\`，
+ * 27 条技能的窗口从 POSIX 的 ~25 token 涨到 ~92 token，本仓库实测整份 `skills.catalog`
+ * （2643 token）在还剩 1900+ token 预算时被整个扔掉，模型完全看不到任何 Skill。
+ *
+ * 判据必须与验收同口径：这里直接对 `measure(候选内容)` 二分，measure 由调用方传入，
+ * 保证「算的就是最终要花的」。
+ */
+function clipToRenderedBudget(
+  content: string,
+  budgetTokens: number,
+  measure: (candidate: string) => number,
+): string {
   if (budgetTokens <= 0) return '';
-  if (countTextTokens(content) <= budgetTokens) return content;
+  if (measure(content) <= budgetTokens) return content;
   // Token counter is deliberately dependency-free. Binary search preserves its
   // exact mixed Chinese/ASCII estimate instead of falling back to chars/4.
   let low = 0;
   let high = content.length;
   while (low < high) {
     const mid = Math.ceil((low + high) / 2);
-    if (countTextTokens(content.slice(0, mid)) <= Math.max(1, budgetTokens - 12)) low = mid;
+    const candidate = `${content.slice(0, mid).trimEnd()}${CLIP_MARKER}`;
+    if (measure(candidate) <= budgetTokens) low = mid;
     else high = mid - 1;
   }
-  return `${content.slice(0, low).trimEnd()}\n[上下文片段因预算截断]`;
+  if (low <= 0) return '';
+  return `${content.slice(0, low).trimEnd()}${CLIP_MARKER}`;
 }
 
 export function renderContextFragment(fragment: ContextFragment): string {
@@ -77,6 +99,10 @@ function renderedTokens(fragment: ContextFragment): number {
   return countTextTokens(renderContextFragment(fragment));
 }
 
+/** 片段之间的分隔符——记账时必须与最终 join 用的是同一个常量。 */
+const FRAGMENT_SEPARATOR = '\n\n';
+const SEPARATOR_TOKENS = countTextTokens(FRAGMENT_SEPARATOR);
+
 /**
  * Deterministic context budgeting. Required host facts are kept first; optional
  * fragments compete by priority, then original order. No LLM call is involved.
@@ -98,21 +124,29 @@ export function assembleContextBundle(
 
   for (const item of ordered) {
     const fragment = item.fragment;
+    // 片段之间要用 SEPARATOR 拼接，那几个 token 也得记账，否则最终 text 会超出预算
+    // （usedTokens > budgetTokens 会让 loop.ts::transientFor 的余量判断失真）。
+    const separator = included.length > 0 ? SEPARATOR_TOKENS : 0;
+    const budgetForItem = remaining - separator;
     const fullTokens = renderedTokens(fragment);
-    if (fullTokens <= remaining) {
+    if (fullTokens <= budgetForItem) {
       included.push(item);
-      remaining -= fullTokens;
+      remaining -= fullTokens + separator;
       continue;
     }
-    if ((fragment.required || fragment.clippable) && remaining > 24) {
-      const wrapperTokens = renderedTokens({ ...fragment, content: '' });
-      const content = clipToTokenBudget(fragment.content, Math.max(0, remaining - wrapperTokens));
+    if ((fragment.required || fragment.clippable) && budgetForItem > 24) {
+      // 同口径：二分时就按「这段内容渲染进本片段信封后要花多少 token」来量。
+      const content = clipToRenderedBudget(
+        fragment.content,
+        budgetForItem,
+        (candidate) => renderedTokens({ ...fragment, content: candidate }),
+      );
       const clipped = contextFragment({ ...fragment, content });
       const clippedTokens = renderedTokens(clipped);
-      if (clipped.content && clippedTokens <= remaining) {
+      if (clipped.content && clippedTokens <= budgetForItem) {
         included.push({ fragment: clipped, index: item.index });
-        clippedIds.push(fragment.id);
-        remaining -= clippedTokens;
+        if (clipped.content !== fragment.content) clippedIds.push(fragment.id);
+        remaining -= clippedTokens + separator;
         continue;
       }
     }
@@ -122,7 +156,7 @@ export function assembleContextBundle(
   // Rendering follows semantic input order, not selection priority.
   included.sort((a, b) => a.index - b.index);
   const selected = included.map((item) => item.fragment);
-  const text = selected.map(renderContextFragment).join('\n\n');
+  const text = selected.map(renderContextFragment).join(FRAGMENT_SEPARATOR);
   const usedTokens = countTextTokens(text);
   return {
     fragments: selected,

package/src/harness/stallGuard.js

@@ -5,33 +5,48 @@ function hash(value) {
 /** Run-local deterministic guard. It never persists arguments or result text. */
 export class StallGuard {
     #lastFailure = '';
+    #lastFailureCall = '';
     #failureCount = 0;
     #lastBatch = '';
     #batchCount = 0;
+    shouldReject(call) {
+        return (this.#failureCount >= 2 &&
+            this.#lastFailureCall ===
+                hash(`${call.function.name}\0${call.function.arguments}`));
+    }
     observe(calls, results, assistantText) {
         for (let index = 0; index < calls.length; index += 1) {
             const call = calls[index];
             const result = results[index];
             if (result.ok) {
                 this.#lastFailure = '';
+                this.#lastFailureCall = '';
                 this.#failureCount = 0;
                 continue;
             }
-            const signature = hash(`${call.function.name}\0${call.function.arguments}\0${result.error}`);
+            const callSignature = hash(`${call.function.name}\0${call.function.arguments}`);
+            const signature = hash(`${callSignature}\0${result.error}`);
             if (signature === this.#lastFailure)
                 this.#failureCount += 1;
             else {
                 this.#lastFailure = signature;
+                this.#lastFailureCall = callSignature;
                 this.#failureCount = 1;
             }
             if (this.#failureCount >= 3) {
-                return { stalled: true, reason: 'repeated_failure', signature: signature.slice(0, 16) };
+                return {
+                    stalled: true,
+                    reason: 'repeated_failure',
+                    signature: signature.slice(0, 16),
+                };
             }
         }
-        const batch = hash(calls.map((call, index) => {
+        const batch = hash(calls
+            .map((call, index) => {
             const result = results[index];
             return `${call.function.name}\0${call.function.arguments}\0${result.ok ? result.content : result.error}`;
-        }).join('\x01'));
+        })
+            .join('\x01'));
         if (assistantText.trim().length === 0 && batch === this.#lastBatch)
             this.#batchCount += 1;
         else {

package/src/harness/stallGuard.ts

@@ -14,10 +14,19 @@ export interface StallObservation {
 /** Run-local deterministic guard. It never persists arguments or result text. */
 export class StallGuard {
   #lastFailure = '';
+  #lastFailureCall = '';
   #failureCount = 0;
   #lastBatch = '';
   #batchCount = 0;
 
+  shouldReject(call: ToolCall): boolean {
+    return (
+      this.#failureCount >= 2 &&
+      this.#lastFailureCall ===
+        hash(`${call.function.name}\0${call.function.arguments}`)
+    );
+  }
+
   observe(
     calls: readonly ToolCall[],
     results: readonly ToolResult[],
@@ -28,25 +37,39 @@ export class StallGuard {
       const result = results[index]!;
       if (result.ok) {
         this.#lastFailure = '';
+        this.#lastFailureCall = '';
         this.#failureCount = 0;
         continue;
       }
-      const signature = hash(`${call.function.name}\0${call.function.arguments}\0${result.error}`);
+      const callSignature = hash(
+        `${call.function.name}\0${call.function.arguments}`,
+      );
+      const signature = hash(`${callSignature}\0${result.error}`);
       if (signature === this.#lastFailure) this.#failureCount += 1;
       else {
         this.#lastFailure = signature;
+        this.#lastFailureCall = callSignature;
         this.#failureCount = 1;
       }
       if (this.#failureCount >= 3) {
-        return { stalled: true, reason: 'repeated_failure', signature: signature.slice(0, 16) };
+        return {
+          stalled: true,
+          reason: 'repeated_failure',
+          signature: signature.slice(0, 16),
+        };
       }
     }
 
-    const batch = hash(calls.map((call, index) => {
-      const result = results[index]!;
-      return `${call.function.name}\0${call.function.arguments}\0${result.ok ? result.content : result.error}`;
-    }).join('\x01'));
-    if (assistantText.trim().length === 0 && batch === this.#lastBatch) this.#batchCount += 1;
+    const batch = hash(
+      calls
+        .map((call, index) => {
+          const result = results[index]!;
+          return `${call.function.name}\0${call.function.arguments}\0${result.ok ? result.content : result.error}`;
+        })
+        .join('\x01'),
+    );
+    if (assistantText.trim().length === 0 && batch === this.#lastBatch)
+      this.#batchCount += 1;
     else {
       this.#lastBatch = batch;
       this.#batchCount = assistantText.trim().length === 0 ? 1 : 0;

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 = {