gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -7,91 +7,111 @@
  * call stopAuto and return { action: "break" } for non-conflict errors.
  */
 
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { createTestContext } from "./test-helpers.ts";
+import { runPreDispatch } from "../auto/phases.ts";
 
 const { assertTrue, report } = createTestContext();
 
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const phasesSrc = readFileSync(phasesPath, "utf-8");
-
 console.log("\n=== #2766: Non-MergeConflictError stops auto mode ===");
 
-// ── Test 1: every mergeAndExit call site has a catch (mergeErr) block ──
-
-// Count all mergeAndExit catch blocks by finding "} catch (mergeErr)" patterns
-const mergeAndExitCallCount = [...phasesSrc.matchAll(/\.mergeAndExit\(/g)].length;
-const mergeErrCatchCount = [...phasesSrc.matchAll(/\} catch \(mergeErr\)/g)].length;
-assertTrue(
-  mergeErrCatchCount === mergeAndExitCallCount && mergeAndExitCallCount > 0,
-  `every mergeAndExit call site has a catch (mergeErr) block (calls=${mergeAndExitCallCount}, catches=${mergeErrCatchCount})`,
-);
-
-// ── Test 2: Every mergeErr catch block handles non-MergeConflictError ───
-
-// Find each catch block and verify it has the non-conflict error handling pattern
-const catchPattern = /\} catch \(mergeErr\) \{/g;
-let match;
-let blocksWithNonConflictHandling = 0;
-let blocksTotal = 0;
-
-while ((match = catchPattern.exec(phasesSrc)) !== null) {
-  blocksTotal++;
-  // Look at the ~800 chars after the catch to find both the MergeConflictError
-  // instanceof check AND the non-conflict handling
-  const afterCatch = phasesSrc.slice(match.index, match.index + 1200);
-
-  const hasInstanceofCheck = afterCatch.includes("instanceof MergeConflictError");
-  const hasNonConflictStop = afterCatch.includes('reason: "merge-failed"');
-  const hasStopAuto = afterCatch.includes("stopAuto");
-  const hasLogError = afterCatch.includes("logError");
-
-  if (hasInstanceofCheck && hasNonConflictStop && hasStopAuto && hasLogError) {
-    blocksWithNonConflictHandling++;
-  }
+const notifications: Array<{ message: string; level?: string }> = [];
+const calls: string[] = [];
+const basePath = "/tmp/gsd-test";
+const ic = {
+  ctx: {
+    ui: {
+      notify(message: string, level?: string) {
+        notifications.push({ message, level });
+      },
+    },
+  },
+  pi: {},
+  s: {
+    basePath,
+    originalBasePath: basePath,
+    canonicalProjectRoot: basePath,
+    resourceVersionOnStart: "test",
+    currentMilestoneId: "M001",
+    currentUnit: null,
+    milestoneMergedInPhases: false,
+  },
+  prefs: undefined,
+  iteration: 1,
+  flowId: "test-flow",
+  nextSeq: () => 1,
+  deps: {
+    checkResourcesStale() {
+      return null;
+    },
+    invalidateAllCaches() {
+      calls.push("invalidate");
+    },
+    async preDispatchHealthGate() {
+      calls.push("health");
+      return { proceed: true, fixesApplied: [] };
+    },
+    async deriveState(projectRoot: string) {
+      calls.push(`derive:${projectRoot}`);
+      return {
+        phase: "complete",
+        activeMilestone: { id: "M001", title: "Milestone one" },
+        activeSlice: null,
+        activeTask: null,
+        registry: [{ id: "M001", status: "complete" }],
+        nextAction: "complete",
+      };
+    },
+    syncCmuxSidebar() {
+      calls.push("sync-sidebar");
+    },
+    setActiveMilestoneId(_basePath: string, mid: string) {
+      calls.push(`set-active:${mid}`);
+    },
+    reconcileMergeState() {
+      calls.push("reconcile");
+      return "clean";
+    },
+    preflightCleanRoot() {
+      calls.push("preflight");
+      return { ok: true, stashPushed: true, stashMarker: "marker" };
+    },
+    postflightPopStash() {
+      calls.push("postflight");
+      return { ok: true, needsManualRecovery: false };
+    },
+    lifecycle: {
+      exitMilestone() {
+        calls.push("merge");
+        return {
+          ok: false,
+          reason: "teardown-failed",
+          cause: new Error("remote rejected push"),
+        };
+      },
+    },
+    async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {
+      calls.push(`stop:${reason}`);
+    },
+  },
+} as any;
+
+const result = await runPreDispatch(ic, {
+  recentUnits: [],
+  stuckRecoveryAttempts: 0,
+  consecutiveFinalizeTimeouts: 0,
+});
+
+assertTrue(result.action === "break", "non-conflict merge error returns break");
+if (result.action === "break") {
+  assertTrue(result.reason === "merge-failed", "non-conflict merge error uses merge-failed reason");
 }
-
 assertTrue(
-  blocksWithNonConflictHandling === blocksTotal && blocksTotal >= 3,
-  `all ${blocksTotal} mergeAndExit catch blocks stop auto on non-conflict errors (${blocksWithNonConflictHandling}/${blocksTotal})`,
+  calls.join(" > ") === "invalidate > health > derive:/tmp/gsd-test > sync-sidebar > set-active:M001 > reconcile > preflight > merge > postflight > stop:Merge error on milestone M001: Error: remote rejected push",
+  `pre-dispatch stops immediately after non-conflict merge failure (${calls.join(" > ")})`,
 );
-
-// ── Test 3: Non-conflict handler returns break (does not continue) ──────
-
-// Verify the pattern: after the MergeConflictError instanceof block,
-// the non-conflict path returns { action: "break", reason: "merge-failed" }
-const mergeFailedReasons = [...phasesSrc.matchAll(/reason: "merge-failed"/g)].length;
-assertTrue(
-  mergeFailedReasons >= 3,
-  `all catch blocks return reason: "merge-failed" (found ${mergeFailedReasons}, expected >= 3)`,
-);
-
-// ── Test 4: Non-conflict handler notifies user ──────────────────────────
-
-// Each non-conflict block should call ctx.ui.notify with error severity
-const notifyErrorPattern = /Merge failed:.*Resolve and run \/gsd auto to resume/g;
-const notifyCount = [...phasesSrc.matchAll(notifyErrorPattern)].length;
-assertTrue(
-  notifyCount >= 3,
-  `all catch blocks notify user about merge failure (found ${notifyCount}, expected >= 3)`,
-);
-
-// ── Test 5: logError replaces logWarning for non-conflict merge errors ──
-
-// The old code used logWarning — verify logError is used instead
-const logWarningMergePattern = /logWarning\(.*Milestone merge failed with non-conflict error/g;
-const logWarningCount = [...phasesSrc.matchAll(logWarningMergePattern)].length;
-assertTrue(
-  logWarningCount === 0,
-  "logWarning is no longer used for non-conflict merge errors (replaced by logError)",
-);
-
-const logErrorMergePattern = /logError\(.*Milestone merge failed with non-conflict error/g;
-const logErrorCount = [...phasesSrc.matchAll(logErrorMergePattern)].length;
 assertTrue(
-  logErrorCount >= 3,
-  `logError is used for non-conflict merge errors (found ${logErrorCount}, expected >= 3)`,
+  notifications.some((n) => n.level === "error" && n.message.includes("Merge failed: remote rejected push")),
+  "user is notified with an error that merge failed",
 );
 
 report();

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -172,6 +172,56 @@ test('handlePlanSlice rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanSlice rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [outside],
+          expectedOutput: [outside],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: tasks\[0\]\.inputs contains absolute path outside working directory/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid planning IO must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice accepts absolute task IO paths inside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const inside = join(base, 'index.html');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: [inside],
+          expectedOutput: [inside],
+        },
+      ],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -79,6 +79,27 @@ test('handlePlanTask rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const outside = join(tmpdir(), 'outside-checkout', 'index.html');
+    const result = await handlePlanTask({
+      ...validParams(),
+      inputs: [outside],
+      expectedOutput: [outside],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: inputs contains absolute path outside working directory/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid planning IO must not persist the task');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -5,31 +5,45 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { AutoSession } from "../auto/session.ts";
+import { postUnitPreVerification } from "../auto-post-unit.ts";
 
-const source = readFileSync(join(import.meta.dirname, "..", "auto-post-unit.ts"), "utf-8");
+test("postUnitPreVerification rebuilds STATE.md after a completed unit", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-state-"));
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap\n\n## Slices\n\n- [ ] **S01: Discussed slice** `risk:low` `depends:[]`\n",
+    );
+    writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Slice Context\n\nReady.\n");
 
-test("auto-post-unit imports rebuildState", () => {
-  assert.ok(
-    source.includes('import { rebuildState } from "./doctor.js";'),
-    "auto-post-unit.ts should import rebuildState from doctor.ts",
-  );
-});
-
-test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
-  const fnStart = source.indexOf("export async function postUnitPreVerification");
-  assert.ok(fnStart > 0, "postUnitPreVerification should exist");
+    const s = new AutoSession();
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentMilestoneId = "M001";
+    s.currentUnit = { type: "discuss-slice", id: "M001/S01", startedAt: Date.now() };
 
-  const fnEnd = source.indexOf("export async function postUnitPostVerification", fnStart);
-  const section = source.slice(fnStart, fnEnd > fnStart ? fnEnd : undefined);
-  const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
-  const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
+    const result = await postUnitPreVerification({
+      s,
+      ctx: { ui: { notify() {} } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    }, { skipSettleDelay: true, skipWorktreeSync: true });
 
-  assert.ok(rebuildIdx > 0, "postUnitPreVerification should rebuild STATE.md after unit completion");
-  assert.ok(syncIdx > 0, "postUnitPreVerification should sync worktree state back to the project root");
-  assert.ok(
-    rebuildIdx < syncIdx,
-    "STATE.md rebuild should happen before worktree sync so synced state is fresh",
-  );
+    assert.equal(result, "continue");
+    const statePath = join(base, ".gsd", "STATE.md");
+    assert.equal(existsSync(statePath), true);
+    assert.ok(readFileSync(statePath, "utf-8").includes("M001"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

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,