gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/pr-evidence-equivalence.test.ts

@@ -0,0 +1,102 @@
+// Project/App: GSD-2
+// File Purpose: Golden-fixture equivalence tests pinning PR-body output for buildPrEvidence and formatSwarmLanePRBody.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import { buildPrEvidence, type PrEvidenceInput } from "../pr-evidence.ts";
+import {
+  formatSwarmLanePRBody,
+  type SwarmLanePRData,
+} from "../../github-sync/templates.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = join(__dirname, "fixtures", "pr-body");
+
+const UPDATE = process.env.UPDATE_GOLDENS === "1";
+
+function compareGolden(name: string, actual: string): void {
+  const path = join(FIXTURES_DIR, name);
+  if (UPDATE) {
+    writeFileSync(path, actual, "utf8");
+    return;
+  }
+  const expected = readFileSync(path, "utf8");
+  assert.equal(actual, expected, `golden mismatch for ${name}`);
+}
+
+const SHIP_BASIC: PrEvidenceInput = {
+  milestoneId: "M001",
+  milestoneTitle: "Authentication",
+  changeType: "feat",
+  linkedIssue: "Closes #123",
+  summaries: ["### S01\nImplemented login flow."],
+  roadmapItems: ["- [x] **S01: Login**"],
+  metrics: ["**Units executed:** 3"],
+  testsRun: ["npm test", "npm run typecheck:extensions"],
+  why: "Users need to authenticate before accessing protected resources.",
+  how: "Added password hash check and session token issuance.",
+  rollbackNotes: ["Revert the merge commit."],
+};
+
+const SHIP_EMPTY_OPTIONALS: PrEvidenceInput = {
+  milestoneId: "M001",
+  milestoneTitle: "Authentication",
+  changeType: "feat",
+};
+
+const SWARM_WITH_BLOCKERS: SwarmLanePRData = {
+  lane: {
+    id: "writer",
+    branch: "lane/single-writer",
+    owner: "@owner",
+    latestCommit: "abc1234",
+    changedContracts: ["WriterToken"],
+    testEvidence: ["npm run typecheck:extensions"],
+    blockers: ["Awaiting state-lane writer-sequence merge", "Parity report incomplete"],
+  },
+  impactArea: "Single-writer UOK metadata.",
+  transitionRisks: ["Writer token lifecycle regression"],
+  rollbackPlan: ["Disable writer sequence enrichment"],
+  linkedIssue: 123,
+};
+
+const SWARM_NO_BLOCKERS: SwarmLanePRData = {
+  lane: {
+    id: "writer",
+    branch: "lane/single-writer",
+    owner: "@owner",
+    latestCommit: "abc1234",
+    changedContracts: ["WriterToken"],
+    testEvidence: ["npm run typecheck:extensions"],
+  },
+  impactArea: "Single-writer UOK metadata.",
+  transitionRisks: ["Writer token lifecycle regression"],
+  rollbackPlan: ["Disable writer sequence enrichment"],
+  linkedIssue: 123,
+};
+
+test("pr-evidence golden: commands-ship basic", () => {
+  compareGolden("commands-ship-basic.md", buildPrEvidence(SHIP_BASIC).body);
+});
+
+test("pr-evidence golden: commands-ship empty optionals", () => {
+  compareGolden("commands-ship-empty-optionals.md", buildPrEvidence(SHIP_EMPTY_OPTIONALS).body);
+});
+
+test("pr-evidence golden: swarm-lane with blockers", () => {
+  const body = formatSwarmLanePRBody(SWARM_WITH_BLOCKERS);
+  compareGolden("swarm-lane-with-blockers.md", body);
+  // Cross-check: top-level ## Blockers heading must appear (regression guard
+  // for the silent-drop fixed in this PR).
+  assert.ok(body.includes("\n## Blockers\n"), "swarm-lane body must emit a top-level ## Blockers heading");
+});
+
+test("pr-evidence golden: swarm-lane no blockers (no Blockers heading)", () => {
+  const body = formatSwarmLanePRBody(SWARM_NO_BLOCKERS);
+  compareGolden("swarm-lane-no-blockers.md", body);
+  assert.ok(!body.includes("## Blockers"), "swarm-lane body without blockers must not emit ## Blockers heading");
+});

package/src/resources/extensions/gsd/tests/pr-evidence-hardening.test.ts

@@ -0,0 +1,165 @@
+// Project/App: GSD-2
+// File Purpose: Hardening tests for buildPrEvidence — HTML-comment stripping, fake commit-trailer removal, and per-item length capping.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildPrEvidence, type PrEvidenceInput } from "../pr-evidence.ts";
+
+test("pr-evidence hardening: strips HTML comments from summaries", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: ["visible<!-- hidden secret -->tail"],
+  });
+  assert.ok(!evidence.body.includes("<!--"), "raw <!-- must not appear");
+  assert.ok(!evidence.body.includes("hidden secret"), "comment contents must be stripped");
+  assert.ok(evidence.body.includes("visibletail"), "non-comment text must remain");
+});
+
+test("pr-evidence hardening: removes Co-Authored-By trailer from why", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    why: "Real reason here.\nCo-Authored-By: Evil <e@evil.com>\nMore reason.",
+  });
+  assert.ok(!evidence.body.includes("Evil <e@evil.com>"));
+  assert.ok(!/Co-Authored-By:/i.test(evidence.body));
+  assert.ok(evidence.body.includes("Real reason here."));
+  assert.ok(evidence.body.includes("More reason."));
+});
+
+test("pr-evidence hardening: removes Signed-off-by trailer from how", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    how: "Step one.\nSigned-off-by: Forged <f@x.com>\nStep two.",
+  });
+  assert.ok(!evidence.body.includes("Forged <f@x.com>"));
+  assert.ok(!/Signed-off-by:/i.test(evidence.body));
+  assert.ok(evidence.body.includes("Step one."));
+  assert.ok(evidence.body.includes("Step two."));
+});
+
+test("pr-evidence hardening: trailer-name match is case-insensitive", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    why: "ok\nco-authored-by: lower <l@l.com>\nSIGNED-OFF-BY: upper <u@u.com>\nend",
+  });
+  assert.ok(!evidence.body.includes("lower <l@l.com>"));
+  assert.ok(!evidence.body.includes("upper <u@u.com>"));
+  assert.ok(evidence.body.includes("ok"));
+  assert.ok(evidence.body.includes("end"));
+});
+
+test("pr-evidence hardening: caps oversize summaries item with truncation suffix", () => {
+  const big = "A".repeat(5 * 1024); // 5 KB
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: [big],
+  });
+  // Find the truncated A-block in the body and assert it is bounded.
+  const lines = evidence.body.split("\n");
+  const longLine = lines.find((l) => l.startsWith("AAAA"));
+  assert.ok(longLine, "expected truncated A-line in body");
+  assert.ok(longLine!.endsWith(" … [truncated]"), "must end with truncation suffix");
+  assert.ok(
+    Buffer.byteLength(longLine!, "utf8") <= 2048,
+    `truncated item must be within 2 KB cap, got ${Buffer.byteLength(longLine!, "utf8")}`,
+  );
+});
+
+test("pr-evidence hardening: HTML comment split across summary items is preserved literally", () => {
+  // Documented behavior: each item is sanitized independently. A comment
+  // that begins in one item and closes in the next is NOT joined, so the
+  // open/close markers remain as literal text. This is intentional — joining
+  // items before sanitizing would let an attacker straddle items to inject
+  // an aligned comment that hides the second item from rendered view.
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    summaries: ["first item ends <!--", "--> second item begins"],
+  });
+  // The literal markers survive because each item was sanitized alone.
+  assert.ok(evidence.body.includes("<!--"), "open marker preserved as literal");
+  assert.ok(evidence.body.includes("-->"), "close marker preserved as literal");
+  assert.ok(evidence.body.includes("first item ends"));
+  assert.ok(evidence.body.includes("second item begins"));
+});
+
+test("pr-evidence hardening: clean input is byte-identical to pre-hardening output", () => {
+  // This test is the contract that protects the golden fixtures: the
+  // sanitizer must be a true no-op for well-formed input. If this fails,
+  // there is a bug in the sanitizer (not in the goldens).
+  const cleanInput: PrEvidenceInput = {
+    milestoneId: "M001",
+    milestoneTitle: "Authentication",
+    changeType: "feat",
+    linkedIssue: "Closes #123",
+    summaries: ["### S01\nImplemented login flow."],
+    blockers: ["Awaiting design review"],
+    roadmapItems: ["- [x] **S01: Login**"],
+    metrics: ["**Units executed:** 3"],
+    testsRun: ["npm test", "npm run typecheck:extensions"],
+    why: "Users need to authenticate before accessing protected resources.",
+    how: "Added password hash check and session token issuance.",
+    rollbackNotes: ["Revert the merge commit."],
+  };
+
+  const expected = [
+    "## TL;DR",
+    "",
+    "**What:** Ship milestone M001 - Authentication",
+    "**Why:** Users need to authenticate before accessing protected resources.",
+    "**How:** Added password hash check and session token issuance.",
+    "",
+    "## What",
+    "",
+    "### S01\nImplemented login flow.",
+    "",
+    "## Blockers",
+    "",
+    "- Awaiting design review",
+    "",
+    "## Why",
+    "",
+    "Users need to authenticate before accessing protected resources.",
+    "",
+    "## How",
+    "",
+    "Added password hash check and session token issuance.",
+    "",
+    "## Linked Issue",
+    "",
+    "Closes #123",
+    "",
+    "## Roadmap",
+    "",
+    "- [x] **S01: Login**",
+    "",
+    "## Metrics",
+    "",
+    "- **Units executed:** 3",
+    "",
+    "## Tests Run",
+    "",
+    "- npm test",
+    "- npm run typecheck:extensions",
+    "",
+    "## Change Type",
+    "",
+    "- [x] `feat` - New feature or capability",
+    "- [ ] `fix` - Bug fix",
+    "- [ ] `refactor` - Code restructuring",
+    "- [ ] `test` - Adding or updating tests",
+    "- [ ] `docs` - Documentation only",
+    "- [ ] `chore` - Build, CI, or tooling changes",
+    "",
+    "## Rollback And Compatibility",
+    "",
+    "- Revert the merge commit.",
+    "",
+    "## AI Assistance Disclosure",
+    "",
+    "This PR was prepared with AI assistance.",
+  ].join("\n");
+
+  const actual = buildPrEvidence(cleanInput).body;
+  assert.equal(actual, expected, "clean input must produce byte-identical output (sanitizer is no-op)");
+});

package/src/resources/extensions/gsd/tests/pr-evidence.test.ts

@@ -0,0 +1,79 @@
+// Project/App: GSD-2
+// File Purpose: Tests for the shared GSD pull request evidence generator.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildPrEvidence, type PrChangeType } from "../pr-evidence.ts";
+
+test("pr-evidence: generated body includes contribution-required sections", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    milestoneTitle: "Authentication",
+    linkedIssue: "Closes #123",
+    summaries: ["### S01\nImplemented login."],
+    roadmapItems: ["- [x] **S01: Login**"],
+    metrics: ["**Units executed:** 3"],
+    testsRun: ["npm test"],
+    rollbackNotes: ["Revert the merge commit."],
+  });
+
+  assert.equal(evidence.title, "feat: Authentication");
+  for (const section of [
+    "## TL;DR",
+    "## What",
+    "## Why",
+    "## How",
+    "## Linked Issue",
+    "## Tests Run",
+    "## Change Type",
+    "## Rollback And Compatibility",
+    "## AI Assistance Disclosure",
+  ]) {
+    assert.ok(evidence.body.includes(section), `missing section: ${section}`);
+  }
+  assert.ok(evidence.body.includes("Closes #123"));
+  assert.ok(evidence.body.includes("npm test"));
+  assert.ok(evidence.body.includes("This PR was prepared with AI assistance."));
+});
+
+test("pr-evidence: every change type selects exactly one checklist row", () => {
+  const changeTypes: PrChangeType[] = ["feat", "fix", "refactor", "test", "docs", "chore"];
+
+  for (const changeType of changeTypes) {
+    const evidence = buildPrEvidence({ milestoneId: "M001", changeType });
+    const checkedRows = evidence.body.split("\n").filter((line) => line.startsWith("- [x] `"));
+    assert.deepEqual(checkedRows, [
+      `- [x] \`${changeType}\` - ${{
+        feat: "New feature or capability",
+        fix: "Bug fix",
+        refactor: "Code restructuring",
+        test: "Adding or updating tests",
+        docs: "Documentation only",
+        chore: "Build, CI, or tooling changes",
+      }[changeType]}`,
+    ]);
+  }
+});
+
+test("pr-evidence: missing issue, tests, and rollback data are explicit", () => {
+  const evidence = buildPrEvidence({ milestoneId: "M001", aiAssisted: false });
+
+  assert.ok(evidence.body.includes("Not specified. Add an issue link"));
+  assert.ok(evidence.body.includes("Not specified. Add exact verification commands"));
+  assert.ok(evidence.body.includes("No behavior-changing rollback notes recorded."));
+  assert.ok(!evidence.body.includes("## AI Assistance Disclosure"));
+});
+
+test("pr-evidence: subject metadata supports non-milestone PRs", () => {
+  const evidence = buildPrEvidence({
+    milestoneId: "M001",
+    subjectId: "S01",
+    subjectKind: "slice",
+    milestoneTitle: "Auth Slice",
+  });
+
+  assert.equal(evidence.title, "feat: Auth Slice");
+  assert.ok(evidence.body.includes("Ship slice S01 - Auth Slice"));
+  assert.ok(evidence.body.includes("Slice work is complete and ready for review."));
+});

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -12,14 +12,9 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-const src = readFileSync(
-  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'pre-execution-checks.ts'),
-  'utf-8',
-)
-
 describe('normalizeFilePath backtick stripping (#3649)', () => {
   it('strips backticks from file paths', () => {
     assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
@@ -58,31 +53,42 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
 })
 
 describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', () => {
-  it('source uses only task.inputs in filesToCheck', () => {
-    // Verify the fix structurally: the spread should be [...task.inputs] only
-    const fnStart = src.indexOf('export function checkFilePathConsistency(')
-    assert.ok(fnStart !== -1, 'checkFilePathConsistency function must exist')
-
-    // Find the filesToCheck assignment
-    const filesToCheckLine = src.indexOf('filesToCheck', fnStart)
-    assert.ok(filesToCheckLine !== -1, 'filesToCheck assignment must exist')
-
-    // Extract the line
-    const lineEnd = src.indexOf('\n', filesToCheckLine)
-    const line = src.slice(filesToCheckLine, lineEnd)
-
-    // Must include task.inputs
-    assert.ok(
-      line.includes('task.inputs'),
-      'filesToCheck must reference task.inputs',
-    )
+  it('ignores missing task.files entries that are only likely outputs', () => {
+    const task = {
+      milestone_id: 'M001',
+      slice_id: 'S01',
+      id: 'T01',
+      title: 'Create missing file',
+      status: 'pending',
+      one_liner: '',
+      narrative: '',
+      verification_result: '',
+      duration: '',
+      completed_at: null,
+      blocker_discovered: false,
+      deviations: '',
+      known_issues: '',
+      key_files: [],
+      key_decisions: [],
+      full_summary_md: '',
+      description: '',
+      estimate: '',
+      files: ['src/new-file.ts'],
+      verify: '',
+      inputs: [],
+      expected_output: ['src/new-file.ts'],
+      observability_impact: '',
+      full_plan_md: '',
+      sequence: 0,
+    }
 
-    // Must NOT include task.files
-    assert.ok(
-      !line.includes('task.files'),
-      'filesToCheck must NOT reference task.files — files likely touched include ' +
-        'files the task will create, so they do not need to pre-exist',
-    )
+    const tmp = resolve(process.cwd(), '.tmp-pre-exec-files-ignore')
+    try {
+      mkdirSync(tmp, { recursive: true })
+      assert.deepEqual(checkFilePathConsistency([task as any], tmp), [])
+    } finally {
+      rmSync(tmp, { recursive: true, force: true })
+    }
   })
 })
 

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for pre-execution validation checks.
+
 /**
  * pre-execution-checks.test.ts — Unit tests for pre-execution validation checks.
  *
@@ -1542,6 +1545,27 @@ describe("checkFilePathConsistency directory inputs (#4446)", () => {
     assert.equal(results[0].blocking, true);
   });
 
+  test("runtime directory annotation is skipped as a pre-execution file dependency", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-dir-runtime-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T02",
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: ["src/commands/delete.ts", "src/index.ts"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.deepEqual(
+      results,
+      [],
+      "Runtime-only directory inputs are created during command execution, not required before the task starts",
+    );
+  });
+
   test("tilde-prefixed input is matched against $HOME, not the project basePath", (t) => {
     const fakeHome = join(tmpdir(), `pre-exec-tilde-home-${Date.now()}`);
     const projectDir = join(tmpdir(), `pre-exec-tilde-proj-${Date.now()}`);
@@ -1597,6 +1621,20 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
       "Directory reference should not be treated as reading a file created later",
     );
   });
+
+  test("runtime directory annotation does not produce an ordering violation", () => {
+    const tasks = [
+      createTask({
+        id: "T02",
+        sequence: 0,
+        inputs: ["entries/ directory (runtime)"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.deepEqual(results, []);
+  });
 });
 
 // ─── Regression Tests: checkTaskOrdering false positive for pre-execution refs (#4071) ──
@@ -1781,7 +1819,7 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
     );
   });
 
-  test("pending task at higher index still causes a missing-file error", (t) => {
+  test("pending task at higher index does NOT cause a duplicate consistency error (ordering check handles it)", (t) => {
     const tempDir = join(tmpdir(), `pre-exec-fc-pending-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });
     t.after(() => rmSync(tempDir, { recursive: true, force: true }));
@@ -1803,14 +1841,16 @@ describe("checkFilePathConsistency completed-task output exemption (#4071)", ()
       }),
     ];
 
+    // checkFilePathConsistency suppresses the error here because checkTaskOrdering
+    // will fire a more precise "sequence violation" error for the same file.
+    // The combined output of runPreExecutionChecks still flags the issue — just
+    // once, via the ordering check, instead of twice.
     const results = checkFilePathConsistency(tasks, tempDir);
     assert.equal(
       results.length,
-      1,
-      "pending task at higher index must still be flagged — the file is not available yet",
+      0,
+      "consistency check must not duplicate what the ordering check already reports",
     );
-    assert.equal(results[0].blocking, true);
-    assert.equal(results[0].target, "artifacts/output.json");
   });
 });
 

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Integration tests for pre-execution check pause wiring.
 /**
  * pre-execution-pause-wiring.test.ts — Integration tests for pre-execution check → pauseAuto wiring.
  *
@@ -27,6 +29,11 @@ let tempDir: string;
 let dbPath: string;
 let originalCwd: string;
 
+function resetAllCaches(): void {
+  invalidateAllCaches();
+  _clearGsdRootCache();
+}
+
 /**
  * Create a minimal mock ExtensionContext.
  */
@@ -112,8 +119,8 @@ function setupTestEnvironment(): void {
   // Change cwd so loadEffectiveGSDPreferences finds our PREFERENCES.md
   process.chdir(tempDir);
   
-  // Clear gsdRoot cache so it finds the new .gsd directory
-  _clearGsdRootCache();
+  // Clear caches so it finds the new .gsd directory and preferences.
+  resetAllCaches();
   
   // Initialize DB
   dbPath = join(gsdDir, "gsd.db");
@@ -136,6 +143,7 @@ function cleanupTestEnvironment(): void {
   } catch {
     // Ignore close errors
   }
+  resetAllCaches();
   try {
     rmSync(tempDir, { recursive: true, force: true });
   } catch {
@@ -158,8 +166,7 @@ ${yamlLines.join("\n")}
 `;
   writeFileSync(join(tempDir, ".gsd", "PREFERENCES.md"), prefsContent);
   // Invalidate caches so the new preferences file is found
-  invalidateAllCaches();
-  _clearGsdRootCache();
+  resetAllCaches();
 }
 
 /**
@@ -486,6 +493,69 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
     );
   });
 
+  test("files present in s.basePath (worktree) but absent from canonicalProjectRoot do not block", async () => {
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: true,
+      enhanced_verification_strict: false,
+    });
+
+    // Regression: pre-exec checks used canonicalProjectRoot (project root), so
+    // files that a prior slice created in the worktree were falsely flagged as
+    // missing because they hadn't merged to main yet. Fix: use s.basePath.
+
+    // Create a separate "worktree" directory with the referenced files present.
+    const worktreeDir = join(tempDir, "worktree");
+    mkdirSync(join(worktreeDir, "lib"), { recursive: true });
+    mkdirSync(join(worktreeDir, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(join(worktreeDir, "lib", "types.ts"), "export type Habit = { id: string; name: string; };");
+    writeFileSync(join(worktreeDir, "lib", "useLocalStorage.ts"), "export function useLocalStorage() {}");
+
+    // The DB lives under tempDir (the "project root"). Insert slice + tasks.
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", risk: "low" });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task that reads prior-slice files",
+      status: "pending",
+      planning: {
+        description: "Reads lib/types.ts and lib/useLocalStorage.ts from prior slice",
+        estimate: "1h",
+        files: [],
+        verify: "npm test",
+        inputs: ["lib/types.ts", "lib/useLocalStorage.ts"],
+        expectedOutput: ["lib/utils.ts"],
+        observabilityImpact: "",
+      },
+      sequence: 0,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+
+    // s.basePath = worktreeDir (files exist here)
+    // Override canonicalProjectRoot → tempDir (files do NOT exist there)
+    const s = makeMockSession(worktreeDir, { type: "plan-slice", id: "M001/S01" });
+    Object.defineProperty(s, "canonicalProjectRoot", { get: () => tempDir });
+
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+    const result = await postUnitPostVerification(pctx);
+
+    assert.equal(
+      pauseAutoMock.mock.callCount(),
+      0,
+      "pauseAuto should NOT be called when referenced files exist in s.basePath (worktree)",
+    );
+    assert.equal(
+      result,
+      "continue",
+      "postUnitPostVerification should return 'continue' when worktree files satisfy pre-exec inputs",
+    );
+  });
+
   test("uok gate runner persists pre-execution gate outcomes when enabled", async () => {
     writePreferences({
       enhanced_verification: true,