gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -0,0 +1,117 @@
+// tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
+//
+// Each of the 4 DB tools must register under its canonical gsd_concept_action name
+// AND under the old gsd_action_concept name as a backward-compatible alias.
+// The alias must share the exact same execute function reference as the canonical tool.
+
+import { createTestContext } from './test-helpers.ts';
+import { registerDbTools } from '../bootstrap/db-tools.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Mock PI ──────────────────────────────────────────────────────────────────
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+// ─── Rename map ───────────────────────────────────────────────────────────────
+
+const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
+  { canonical: "gsd_decision_save", alias: "gsd_save_decision" },
+  { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
+  { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
+  { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
+];
+
+// ─── Registration count ──────────────────────────────────────────────────────
+
+console.log('\n── Tool naming: registration count ──');
+
+const pi = makeMockPi();
+registerDbTools(pi);
+
+assertEq(pi.tools.length, 8, 'Should register exactly 8 tools (4 canonical + 4 aliases)');
+
+// ─── Both names exist for each pair ──────────────────────────────────────────
+
+console.log('\n── Tool naming: canonical and alias names exist ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  assertTrue(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
+  assertTrue(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
+}
+
+// ─── Execute function identity ───────────────────────────────────────────────
+
+console.log('\n── Tool naming: execute function identity (===) ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (canonicalTool && aliasTool) {
+    assertTrue(
+      canonicalTool.execute === aliasTool.execute,
+      `"${canonical}" and "${alias}" should share the same execute function reference`,
+    );
+  }
+}
+
+// ─── Alias descriptions include "(alias for ...)" ───────────────────────────
+
+console.log('\n── Tool naming: alias descriptions ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (aliasTool) {
+    assertTrue(
+      aliasTool.description.includes(`alias for ${canonical}`),
+      `Alias "${alias}" description should include "alias for ${canonical}"`,
+    );
+  }
+}
+
+// ─── Canonical tools have proper promptGuidelines ────────────────────────────
+
+console.log('\n── Tool naming: canonical promptGuidelines use canonical name ──');
+
+for (const { canonical } of RENAME_MAP) {
+  const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
+
+  if (canonicalTool) {
+    const guidelinesText = canonicalTool.promptGuidelines.join(' ');
+    assertTrue(
+      guidelinesText.includes(canonical),
+      `Canonical tool "${canonical}" promptGuidelines should reference its own name`,
+    );
+  }
+}
+
+// ─── Alias promptGuidelines direct to canonical ──────────────────────────────
+
+console.log('\n── Tool naming: alias promptGuidelines redirect to canonical ──');
+
+for (const { canonical, alias } of RENAME_MAP) {
+  const aliasTool = pi.tools.find((t: any) => t.name === alias);
+
+  if (aliasTool) {
+    const guidelinesText = aliasTool.promptGuidelines.join(' ');
+    assertTrue(
+      guidelinesText.includes(`Alias for ${canonical}`),
+      `Alias "${alias}" promptGuidelines should say "Alias for ${canonical}"`,
+    );
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -15,6 +15,7 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const hooksPath = join(__dirname, "..", "post-unit-hooks.ts");
+const registryPath = join(__dirname, "..", "rule-registry.ts");
 const autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
 
 // After decomposition, triage/dispatch logic lives in auto-post-unit.ts
@@ -25,7 +26,11 @@ const autoSrc = [
   postUnitSrc,
   readFileSync(join(__dirname, "..", "auto-start.ts"), "utf-8"),
 ].join("\n");
-const hooksSrc = readFileSync(hooksPath, "utf-8");
+// Hook exclusion logic lives in the rule-registry (facade delegates there)
+const hooksSrc = [
+  readFileSync(hooksPath, "utf-8"),
+  readFileSync(registryPath, "utf-8"),
+].join("\n");
 const autoPromptsSrc = (() => { try { return readFileSync(autoPromptsPath, "utf-8"); } catch { return autoSrc; } })();
 
 // ─── Hook exclusion ──────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/verification-gate.test.ts

@@ -15,7 +15,7 @@
  *  11. Dependency audit — git diff detection, npm audit parsing, graceful failures
  */
 
-import test from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -37,37 +37,30 @@ function makeTempDir(prefix: string): string {
 
 // ─── Discovery Tests ─────────────────────────────────────────────────────────
 
-test("verification-gate: discoverCommands from preference commands", () => {
-  const tmp = makeTempDir("vg-pref");
-  try {
+describe("verification-gate: discovery", () => {
+  let tmp: string;
+  beforeEach(() => { tmp = makeTempDir("vg-discovery"); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("discoverCommands from preference commands", () => {
     const result = discoverCommands({
       preferenceCommands: ["npm run lint", "npm run test"],
       cwd: tmp,
     });
     assert.deepStrictEqual(result.commands, ["npm run lint", "npm run test"]);
     assert.equal(result.source, "preference");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: discoverCommands from task plan verify field", () => {
-  const tmp = makeTempDir("vg-taskplan");
-  try {
+  test("discoverCommands from task plan verify field", () => {
     const result = discoverCommands({
       taskPlanVerify: "npm run lint && npm run test",
       cwd: tmp,
     });
     assert.deepStrictEqual(result.commands, ["npm run lint", "npm run test"]);
     assert.equal(result.source, "task-plan");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: discoverCommands from package.json scripts", () => {
-  const tmp = makeTempDir("vg-pkg");
-  try {
+  test("discoverCommands from package.json scripts", () => {
     writeFileSync(
       join(tmp, "package.json"),
       JSON.stringify({
@@ -86,14 +79,9 @@ test("verification-gate: discoverCommands from package.json scripts", () => {
       "npm run test",
     ]);
     assert.equal(result.source, "package-json");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: first-non-empty-wins — preference beats task plan and package.json", () => {
-  const tmp = makeTempDir("vg-precedence");
-  try {
+  test("first-non-empty-wins — preference beats task plan and package.json", () => {
     writeFileSync(
       join(tmp, "package.json"),
       JSON.stringify({ scripts: { lint: "eslint ." } }),
@@ -105,14 +93,9 @@ test("verification-gate: first-non-empty-wins — preference beats task plan and
     });
     assert.deepStrictEqual(result.commands, ["custom-check"]);
     assert.equal(result.source, "preference");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: task plan verify beats package.json", () => {
-  const tmp = makeTempDir("vg-tp-beats-pkg");
-  try {
+  test("task plan verify beats package.json", () => {
     writeFileSync(
       join(tmp, "package.json"),
       JSON.stringify({ scripts: { lint: "eslint ." } }),
@@ -123,25 +106,15 @@ test("verification-gate: task plan verify beats package.json", () => {
     });
     assert.deepStrictEqual(result.commands, ["custom-verify"]);
     assert.equal(result.source, "task-plan");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: missing package.json → 0 checks, source none", () => {
-  const tmp = makeTempDir("vg-no-pkg");
-  try {
+  test("missing package.json → 0 checks, source none", () => {
     const result = discoverCommands({ cwd: tmp });
     assert.deepStrictEqual(result.commands, []);
     assert.equal(result.source, "none");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: package.json with no matching scripts → 0 checks", () => {
-  const tmp = makeTempDir("vg-no-scripts");
-  try {
+  test("package.json with no matching scripts → 0 checks", () => {
     writeFileSync(
       join(tmp, "package.json"),
       JSON.stringify({ scripts: { build: "tsc", start: "node index.js" } }),
@@ -149,14 +122,9 @@ test("verification-gate: package.json with no matching scripts → 0 checks", ()
     const result = discoverCommands({ cwd: tmp });
     assert.deepStrictEqual(result.commands, []);
     assert.equal(result.source, "none");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: empty preference array falls through to task plan", () => {
-  const tmp = makeTempDir("vg-empty-pref");
-  try {
+  test("empty preference array falls through to task plan", () => {
     const result = discoverCommands({
       preferenceCommands: [],
       taskPlanVerify: "echo ok",
@@ -164,16 +132,99 @@ test("verification-gate: empty preference array falls through to task plan", ()
     });
     assert.deepStrictEqual(result.commands, ["echo ok"]);
     assert.equal(result.source, "task-plan");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  });
+
+  test("package.json with only test script → returns only npm run test", () => {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({
+        scripts: {
+          test: "vitest",
+          build: "tsc",
+          start: "node index.js",
+        },
+      }),
+    );
+    const result = discoverCommands({ cwd: tmp });
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+    assert.equal(result.source, "package-json");
+  });
+
+  test("taskPlanVerify with single command (no &&)", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "npm test",
+      cwd: tmp,
+    });
+    assert.deepStrictEqual(result.commands, ["npm test"]);
+    assert.equal(result.source, "task-plan");
+  });
+
+  test("whitespace-only preference commands fall through", () => {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { lint: "eslint ." } }),
+    );
+    const result = discoverCommands({
+      preferenceCommands: ["  ", ""],
+      cwd: tmp,
+    });
+    // Whitespace-only strings are trimmed to empty and filtered out
+    assert.equal(result.source, "package-json");
+    assert.deepStrictEqual(result.commands, ["npm run lint"]);
+  });
+
+  test("prose taskPlanVerify is rejected, falls through to package.json", () => {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { test: "vitest" } }),
+    );
+    const result = discoverCommands({
+      taskPlanVerify: "Document exists, contains all 5 scale names, all 14 semantic tokens",
+      cwd: tmp,
+    });
+    // Prose should be rejected, so it falls through to package.json
+    assert.equal(result.source, "package-json");
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+  });
+
+  test("prose taskPlanVerify with no package.json → source none", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "Verify the output matches expected format and all fields are present",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("valid command in taskPlanVerify still works", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "npm run lint && npm run test",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "task-plan");
+    assert.deepStrictEqual(result.commands, ["npm run lint", "npm run test"]);
+  });
+
+  test("mixed prose and commands in taskPlanVerify — only commands kept", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "Check that everything works && npm run test",
+      cwd: tmp,
+    });
+    // "Check that everything works" is prose (starts with capital, 4+ words)
+    // "npm run test" is a valid command
+    assert.equal(result.source, "task-plan");
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+  });
 });
 
 // ─── Execution Tests ─────────────────────────────────────────────────────────
 
-test("verification-gate: all commands pass → gate passes", () => {
-  const tmp = makeTempDir("vg-pass");
-  try {
+describe("verification-gate: execution", () => {
+  let tmp: string;
+  beforeEach(() => { tmp = makeTempDir("vg-exec"); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("all commands pass → gate passes", () => {
     const result = runVerificationGate({
       basePath: tmp,
       unitId: "T01",
@@ -188,14 +239,9 @@ test("verification-gate: all commands pass → gate passes", () => {
     assert.ok(result.checks[0].stdout.includes("hello"));
     assert.ok(result.checks[1].stdout.includes("world"));
     assert.equal(typeof result.timestamp, "number");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: one command fails → gate fails with exit code + stderr", () => {
-  const tmp = makeTempDir("vg-fail");
-  try {
+  test("one command fails → gate fails with exit code + stderr", () => {
     const result = runVerificationGate({
       basePath: tmp,
       unitId: "T01",
@@ -207,14 +253,9 @@ test("verification-gate: one command fails → gate fails with exit code + stder
     assert.equal(result.checks[0].exitCode, 0);
     assert.equal(result.checks[1].exitCode, 1);
     assert.ok(result.checks[1].stderr.includes("err"));
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: no commands discovered → gate passes with 0 checks", () => {
-  const tmp = makeTempDir("vg-empty");
-  try {
+  test("no commands discovered → gate passes with 0 checks", () => {
     const result = runVerificationGate({
       basePath: tmp,
       unitId: "T01",
@@ -223,14 +264,9 @@ test("verification-gate: no commands discovered → gate passes with 0 checks",
     assert.equal(result.passed, true);
     assert.equal(result.checks.length, 0);
     assert.equal(result.discoverySource, "none");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: command not found → exit code 127", () => {
-  const tmp = makeTempDir("vg-notfound");
-  try {
+  test("command not found → exit code 127", () => {
     const result = runVerificationGate({
       basePath: tmp,
       unitId: "T01",
@@ -241,14 +277,9 @@ test("verification-gate: command not found → exit code 127", () => {
     assert.equal(result.checks.length, 1);
     assert.ok(result.checks[0].exitCode !== 0, "should have non-zero exit code");
     assert.ok(result.checks[0].durationMs >= 0);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: no DEP0190 deprecation warning when running commands", () => {
-  const tmp = makeTempDir("vg-dep0190");
-  try {
+  test("no DEP0190 deprecation warning when running commands", () => {
     // Run a subprocess with --throw-deprecation so any DeprecationWarning
     // becomes a thrown error (non-zero exit). The fix passes the command
     // string to sh -c explicitly instead of using spawnSync(cmd, {shell:true}).
@@ -282,14 +313,9 @@ test("verification-gate: no DEP0190 deprecation warning when running commands",
       0,
       `Expected exit 0 (no deprecation) but got ${child.status}. stderr: ${child.stderr}`,
     );
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-test("verification-gate: each check has durationMs", () => {
-  const tmp = makeTempDir("vg-duration");
-  try {
+  test("each check has durationMs", () => {
     const result = runVerificationGate({
       basePath: tmp,
       unitId: "T01",
@@ -299,9 +325,42 @@ test("verification-gate: each check has durationMs", () => {
     assert.equal(result.checks.length, 1);
     assert.equal(typeof result.checks[0].durationMs, "number");
     assert.ok(result.checks[0].durationMs >= 0);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  });
+
+  test("one command fails — remaining commands still run (non-short-circuit)", () => {
+    // First fails, second and third should still execute
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T02",
+      cwd: tmp,
+      preferenceCommands: [
+        "sh -c 'exit 1'",
+        "echo second",
+        "echo third",
+      ],
+    });
+    assert.equal(result.passed, false);
+    assert.equal(result.checks.length, 3, "all 3 commands should run");
+    assert.equal(result.checks[0].exitCode, 1, "first command fails");
+    assert.equal(result.checks[1].exitCode, 0, "second command runs and passes");
+    assert.ok(result.checks[1].stdout.includes("second"));
+    assert.equal(result.checks[2].exitCode, 0, "third command runs and passes");
+    assert.ok(result.checks[2].stdout.includes("third"));
+  });
+
+  test("gate execution uses cwd for spawnSync", () => {
+    // pwd should report the temp dir
+    const result = runVerificationGate({
+      basePath: tmp,
+      unitId: "T02",
+      cwd: tmp,
+      preferenceCommands: ["pwd"],
+    });
+    assert.equal(result.passed, true);
+    assert.equal(result.checks.length, 1);
+    // The stdout should contain the tmp dir path (resolving symlinks)
+    assert.ok(result.checks[0].stdout.trim().length > 0, "pwd should produce output");
+  });
 });
 
 // ─── Preference Validation Tests ─────────────────────────────────────────────
@@ -361,62 +420,6 @@ test("verification-gate: validatePreferences floors verification_max_retries", (
   assert.equal(result.errors.length, 0);
 });
 
-// ─── Additional Discovery Tests (T02) ───────────────────────────────────────
-
-test("verification-gate: package.json with only test script → returns only npm run test", () => {
-  const tmp = makeTempDir("vg-only-test");
-  try {
-    writeFileSync(
-      join(tmp, "package.json"),
-      JSON.stringify({
-        scripts: {
-          test: "vitest",
-          build: "tsc",
-          start: "node index.js",
-        },
-      }),
-    );
-    const result = discoverCommands({ cwd: tmp });
-    assert.deepStrictEqual(result.commands, ["npm run test"]);
-    assert.equal(result.source, "package-json");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: taskPlanVerify with single command (no &&)", () => {
-  const tmp = makeTempDir("vg-tp-single");
-  try {
-    const result = discoverCommands({
-      taskPlanVerify: "npm test",
-      cwd: tmp,
-    });
-    assert.deepStrictEqual(result.commands, ["npm test"]);
-    assert.equal(result.source, "task-plan");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: whitespace-only preference commands fall through", () => {
-  const tmp = makeTempDir("vg-ws-pref");
-  try {
-    writeFileSync(
-      join(tmp, "package.json"),
-      JSON.stringify({ scripts: { lint: "eslint ." } }),
-    );
-    const result = discoverCommands({
-      preferenceCommands: ["  ", ""],
-      cwd: tmp,
-    });
-    // Whitespace-only strings are trimmed to empty and filtered out
-    assert.equal(result.source, "package-json");
-    assert.deepStrictEqual(result.commands, ["npm run lint"]);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
 // ─── isLikelyCommand Tests (issue #1066) ────────────────────────────────────
 
 test("isLikelyCommand: known command prefixes are accepted", () => {
@@ -468,116 +471,6 @@ test("isLikelyCommand: short lowercase tokens without flags are accepted (could
   assert.equal(isLikelyCommand("mycheck"), true);
 });
 
-test("verification-gate: prose taskPlanVerify is rejected, falls through to package.json", () => {
-  const tmp = makeTempDir("vg-prose-reject");
-  try {
-    writeFileSync(
-      join(tmp, "package.json"),
-      JSON.stringify({ scripts: { test: "vitest" } }),
-    );
-    const result = discoverCommands({
-      taskPlanVerify: "Document exists, contains all 5 scale names, all 14 semantic tokens",
-      cwd: tmp,
-    });
-    // Prose should be rejected, so it falls through to package.json
-    assert.equal(result.source, "package-json");
-    assert.deepStrictEqual(result.commands, ["npm run test"]);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: prose taskPlanVerify with no package.json → source none", () => {
-  const tmp = makeTempDir("vg-prose-none");
-  try {
-    const result = discoverCommands({
-      taskPlanVerify: "Verify the output matches expected format and all fields are present",
-      cwd: tmp,
-    });
-    assert.equal(result.source, "none");
-    assert.deepStrictEqual(result.commands, []);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: valid command in taskPlanVerify still works", () => {
-  const tmp = makeTempDir("vg-valid-cmd");
-  try {
-    const result = discoverCommands({
-      taskPlanVerify: "npm run lint && npm run test",
-      cwd: tmp,
-    });
-    assert.equal(result.source, "task-plan");
-    assert.deepStrictEqual(result.commands, ["npm run lint", "npm run test"]);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: mixed prose and commands in taskPlanVerify — only commands kept", () => {
-  const tmp = makeTempDir("vg-mixed");
-  try {
-    const result = discoverCommands({
-      taskPlanVerify: "Check that everything works && npm run test",
-      cwd: tmp,
-    });
-    // "Check that everything works" is prose (starts with capital, 4+ words)
-    // "npm run test" is a valid command
-    assert.equal(result.source, "task-plan");
-    assert.deepStrictEqual(result.commands, ["npm run test"]);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-// ─── Additional Execution Tests (T02) ───────────────────────────────────────
-
-test("verification-gate: one command fails — remaining commands still run (non-short-circuit)", () => {
-  const tmp = makeTempDir("vg-no-short-circuit");
-  try {
-    // First fails, second and third should still execute
-    const result = runVerificationGate({
-      basePath: tmp,
-      unitId: "T02",
-      cwd: tmp,
-      preferenceCommands: [
-        "sh -c 'exit 1'",
-        "echo second",
-        "echo third",
-      ],
-    });
-    assert.equal(result.passed, false);
-    assert.equal(result.checks.length, 3, "all 3 commands should run");
-    assert.equal(result.checks[0].exitCode, 1, "first command fails");
-    assert.equal(result.checks[1].exitCode, 0, "second command runs and passes");
-    assert.ok(result.checks[1].stdout.includes("second"));
-    assert.equal(result.checks[2].exitCode, 0, "third command runs and passes");
-    assert.ok(result.checks[2].stdout.includes("third"));
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-test("verification-gate: gate execution uses cwd for spawnSync", () => {
-  const tmp = makeTempDir("vg-cwd");
-  try {
-    // pwd should report the temp dir
-    const result = runVerificationGate({
-      basePath: tmp,
-      unitId: "T02",
-      cwd: tmp,
-      preferenceCommands: ["pwd"],
-    });
-    assert.equal(result.passed, true);
-    assert.equal(result.checks.length, 1);
-    // The stdout should contain the tmp dir path (resolving symlinks)
-    assert.ok(result.checks[0].stdout.trim().length > 0, "pwd should produce output");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
 // ─── Additional Preference Validation Tests (T02) ──────────────────────────
 
 test("verification-gate: verification_commands produces no unknown-key warnings", () => {