gsd-pi 2.82.0-dev.9d5798940 → 2.82.0-dev.dfbc5f58f

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -13,17 +13,19 @@
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { chmodSync, existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import {
   assertWorktreeMaterialized,
   nativeBranchDelete,
   nativeCommit,
+  nativeGetCurrentBranch,
   nativeIsRepo,
   nativeResetHard,
   nativeWorktreeAdd,
 } from "../native-git-bridge.js";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 
 // Note: prior static-analysis tests that scanned native-git-bridge.ts for
 // the raw shell-spawn pattern were removed under #4827 — the integration
@@ -78,6 +80,55 @@ describe("native-git-bridge #4180: fallback runtime behaviour", () => {
     assert.equal(subject, "test: regression commit #4180");
   });
 
+  test("nativeCommit retries once after transient ENOBUFS from git", (t) => {
+    const bin = mkdtempSync(join(tmpdir(), "ngb-enobufs-bin-"));
+    t.after(() => rmSync(bin, { recursive: true, force: true }));
+
+    const realGit = execFileSync("git", ["--exec-path"], { encoding: "utf-8" }).trim();
+    const attempts = join(bin, "attempts.txt");
+    const fakeGit = join(bin, "fake-git.cjs");
+    writeFileSync(fakeGit, `
+const { appendFileSync, readFileSync } = require("node:fs");
+const { spawnSync } = require("node:child_process");
+const attempts = ${JSON.stringify(attempts)};
+const realGit = ${JSON.stringify(join(realGit, process.platform === "win32" ? "git.exe" : "git"))};
+appendFileSync(attempts, "1");
+if (process.argv[2] === "commit" && readFileSync(attempts, "utf-8").length === 1) {
+  console.error("spawnSync git ENOBUFS");
+  process.exit(1);
+}
+const result = spawnSync(realGit, process.argv.slice(2), { stdio: "inherit" });
+process.exit(result.status ?? 1);
+`, "utf-8");
+
+    if (process.platform === "win32") {
+      writeFileSync(join(bin, "git.cmd"), `@echo off\r\nnode "${fakeGit}" %*\r\n`, "utf-8");
+    } else {
+      const shim = join(bin, "git");
+      writeFileSync(shim, `#!/bin/sh\nexec node "${fakeGit}" "$@"\n`, "utf-8");
+      chmodSync(shim, 0o755);
+    }
+
+    writeFileSync(join(repo, "file.txt"), "retry commit\n");
+    git(["add", "."], repo);
+
+    const originalPath = process.env.PATH ?? "";
+    const gitEnv = GIT_NO_PROMPT_ENV as NodeJS.ProcessEnv;
+    const originalGitEnvPath = gitEnv.PATH;
+    try {
+      process.env.PATH = `${bin}${delimiter}${originalPath}`;
+      gitEnv.PATH = process.env.PATH;
+      const result = nativeCommit(repo, "test: retry ENOBUFS commit");
+      assert.ok(result !== null, "commit should succeed after retry");
+    } finally {
+      process.env.PATH = originalPath;
+      gitEnv.PATH = originalGitEnvPath;
+    }
+
+    assert.equal(readFileSync(attempts, "utf-8").length, 2);
+    assert.equal(git(["log", "-1", "--format=%s"], repo), "test: retry ENOBUFS commit");
+  });
+
   test("nativeCommit runs commit hooks", () => {
     const hookPath = join(repo, ".git", "hooks", "commit-msg");
     const marker = join(repo, "hook-ran.txt");
@@ -119,7 +170,17 @@ describe("native-git-bridge #4180: fallback runtime behaviour", () => {
   test("nativeBranchDelete throws when git cannot delete the branch", () => {
     assert.throws(
       () => nativeBranchDelete(repo, "does-not-exist"),
-      /GSD_GIT_ERROR|git branch -D does-not-exist failed/,
+      /git branch -D does-not-exist failed[\s\S]*does-not-exist/,
+    );
+  });
+
+  test("nativeGetCurrentBranch preserves git stderr in fallback errors", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "ngb-stderr-notrepo-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+    assert.throws(
+      () => nativeGetCurrentBranch(dir),
+      /git branch --show-current failed[\s\S]*(not a git repository|not a git repo|fatal:)/,
     );
   });
 

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -243,7 +243,7 @@ describe("auditOrphanedMilestoneBranches", () => {
     );
   });
 
-  test("handles milestone in DB but no branch (no-op)", () => {
+  test("milestone in DB, no branch, no worktree dir → no-op", () => {
     insertMilestone({ id: "M001", title: "Test", status: "complete" });
 
     const result = auditOrphanedMilestoneBranches(dir, "worktree");
@@ -251,4 +251,124 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
   });
+
+  test("#5879 — cleans orphaned worktree dir for complete milestone whose branch was already deleted", () => {
+    // Reproduces the postflight-stash-restore-failed scenario:
+    // 1. An earlier audit deleted milestone/M001 (merged + complete).
+    // 2. The worktree dir cleanup failed silently (logWarning only).
+    // 3. On the next startup the branch is gone, so the existing branch-keyed
+    //    loop is invisible to the orphan dir. Without the second pass, the
+    //    directory lives forever.
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded from a prior session\n");
+
+    // No milestone/M001 branch — already deleted on a previous run.
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.equal(branches, "", "test fixture: branch should not exist");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(
+      result.recovered.some((r) => r.includes("M001") && r.includes("branch already deleted")),
+      `should report branch-less orphan cleanup; got: ${JSON.stringify(result.recovered)}`,
+    );
+    assert.ok(!existsSync(wtDir), "branch-less orphan worktree dir should be removed");
+  });
+
+  test("#5879 — branch list failure still cleans complete orphan only after branch absence is verified", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded from a prior session\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: (_basePath, branch) => {
+        assert.equal(branch, "milestone/M001");
+        return false;
+      },
+    });
+
+    assert.ok(
+      result.recovered.some((r) => r.includes("M001") && r.includes("branch already deleted")),
+      `should report verified branch-less orphan cleanup; got: ${JSON.stringify(result.recovered)}`,
+    );
+    assert.ok(!existsSync(wtDir), "verified branch-less orphan worktree dir should be removed");
+  });
+
+  test("#5879 — branch list failure preserves complete worktree when branch still exists", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: (_basePath, branch) => {
+        assert.equal(branch, "milestone/M001");
+        return true;
+      },
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "worktree dir must be preserved when branch existence is verified");
+  });
+
+  test("#5879 — skips branch-less orphan for milestone that is not complete", () => {
+    // Defensive: only `complete` milestones get the branch-less cleanup. An
+    // `active` milestone with no branch but a worktree dir is a different
+    // state (probably mid-recovery) and should not be silently wiped.
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "active milestone worktree dir must be preserved");
+  });
+
+  test("#5879 — branch list failure does not delete worktree for milestone that is not complete", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "live-work.txt"), "do not delete\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree", {
+      branchList: () => {
+        throw new Error("branch list failed");
+      },
+      branchExists: () => {
+        throw new Error("branchExists should not be called for active milestones");
+      },
+    });
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "active milestone worktree dir must be preserved");
+  });
+
+  test("#5879 — skips branch-less orphan in 'none' isolation mode", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "stranded\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "none");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.ok(existsSync(wtDir), "'none' mode must not touch worktree dirs");
+  });
 });

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

@@ -116,6 +116,32 @@ test('handlePlanMilestone rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanMilestone rejects delimiter characters in milestone and slice titles', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    const milestoneResult = await handlePlanMilestone({ ...validParams(), title: 'Client/Server split' }, base);
+    assert.ok('error' in milestoneResult);
+    assert.match(milestoneResult.error, /validation failed: title is invalid: .*forward slash/);
+    assert.equal(getMilestone('M001'), null, 'invalid milestone title must not persist');
+
+    const sliceResult = await handlePlanMilestone({
+      ...validParams(),
+      slices: [
+        validParams().slices[0],
+        { ...validParams().slices[1], title: 'Client/Server migration' },
+      ],
+    }, base);
+    assert.ok('error' in sliceResult);
+    assert.match(sliceResult.error, /validation failed: slices\[1\]\.title is invalid: .*forward slash/);
+    assert.equal(getMilestoneSlices('M001').length, 0, 'invalid slice title must not persist partial roadmap state');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanMilestone surfaces render failures and does not clear parse-visible state on failure', async () => {
   const base = makeTmpBase();
   const dbPath = join(base, '.gsd', 'gsd.db');

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

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, getSliceTasks, getTask } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
 import { handlePlanSlice } from '../tools/plan-slice.ts';
 import { parsePlan } from '../parsers-legacy.ts';
 import { parseTaskPlanFile } from '../files.ts';
@@ -15,6 +15,10 @@ import { deriveState, invalidateStateCache } from '../state.ts';
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-slice-'));
   mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks'), { recursive: true });
+  mkdirSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
+  writeFileSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
+  writeFileSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
+  writeFileSync(join(base, 'stale-input.py'), '# fixture\n', 'utf-8');
   return base;
 }
 
@@ -197,6 +201,28 @@ test('handlePlanSlice rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanSlice explains string task IO fields must be arrays', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: 'src/index.ts' as unknown as string[],
+        },
+      ],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: tasks\[0\]\.inputs must be an array of strings, not string/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice rejects absolute task IO paths outside the active worktree', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -223,6 +249,63 @@ test('handlePlanSlice rejects absolute task IO paths outside the active worktree
   }
 });
 
+test('handlePlanSlice rejects missing task input paths before persisting tasks', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({
+      ...validParams(),
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          inputs: ['fixtures/missing-source.json'],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /pre-execution validation failed:/);
+    assert.match(result.error, /fixtures\/missing-source\.json/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid planning IO must not persist tasks');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice rejects task input paths created by later tasks before persisting tasks', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const params = validParams();
+    const result = await handlePlanSlice({
+      ...params,
+      tasks: [
+        {
+          ...params.tasks[0],
+          inputs: ['generated/report.json'],
+          expectedOutput: ['generated/summary.json'],
+        },
+        {
+          ...params.tasks[1],
+          inputs: [],
+          expectedOutput: ['generated/report.json'],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /pre-execution validation failed:/);
+    assert.match(result.error, /sequence violation/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid task ordering 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'));
@@ -329,3 +412,119 @@ test('handlePlanSlice reruns idempotently and refreshes parse-visible state', as
     cleanup(base);
   }
 });
+
+test('handlePlanSlice removes omitted pending tasks when replanning a smaller task set', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const fourTaskPlan = {
+      ...validParams(),
+      tasks: [
+        ...validParams().tasks,
+        { ...validParams().tasks[0], taskId: 'T03', title: 'Third task' },
+        { ...validParams().tasks[0], taskId: 'T04', title: 'Stale task', inputs: ['stale-input.py'] },
+      ],
+    };
+
+    const first = await handlePlanSlice(fourTaskPlan, base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+    const staleTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T04-PLAN.md');
+    assert.ok(existsSync(staleTaskPlanPath), 'initial plan should render T04');
+
+    const second = await handlePlanSlice({
+      ...validParams(),
+      tasks: fourTaskPlan.tasks.filter((task) => task.taskId !== 'T04'),
+    }, base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01', 'T02', 'T03']);
+    assert.equal(getGateResults('M001', 'S02', 'task').some((gate) => gate.task_id === 'T04'), false);
+    assert.equal(existsSync(staleTaskPlanPath), false, 'omitted task plan artifact should be removed');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice rejects omitted completed tasks without changing slice or task state', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const fourTaskPlan = {
+      ...validParams(),
+      tasks: [
+        ...validParams().tasks,
+        { ...validParams().tasks[0], taskId: 'T03', title: 'Third task' },
+        { ...validParams().tasks[0], taskId: 'T04', title: 'Stale task', inputs: ['stale-input.py'] },
+      ],
+    };
+
+    const first = await handlePlanSlice(fourTaskPlan, base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+    const staleTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T04-PLAN.md');
+    assert.ok(existsSync(staleTaskPlanPath), 'initial plan should render T04');
+
+    updateTaskStatus('M001', 'S02', 'T04', 'complete', '2026-05-12T00:00:00.000Z');
+    const tasksBefore = getSliceTasks('M001', 'S02');
+    const gatesBefore = getGateResults('M001', 'S02', 'task');
+
+    const second = await handlePlanSlice({
+      ...validParams(),
+      goal: 'Rejected replan should not persist.',
+      tasks: fourTaskPlan.tasks.filter((task) => task.taskId !== 'T04'),
+    }, base);
+    assert.deepEqual(second, { error: 'cannot remove completed task T04' });
+
+    assert.equal(getSlice('M001', 'S02')?.goal, 'Persist slice planning through the DB.');
+    assert.deepEqual(getSliceTasks('M001', 'S02'), tasksBefore);
+    assert.deepEqual(getGateResults('M001', 'S02', 'task'), gatesBefore);
+    assert.ok(existsSync(staleTaskPlanPath), 'completed task plan artifact should remain after rejected replan');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('regression: validateTasks surfaces clean per-field errors for non-array IO inputs', async () => {
+  // Regression for the bug fixed in PR #5872: an earlier refactor on main
+  // (0b0e1a901) re-added validateStringArray() calls inside validateTasks
+  // without re-adding its import. The catch around validateParams swallowed
+  // the ReferenceError into a generic "validation failed: validateStringArray
+  // is not defined" message, so silent runtime breakage was possible.
+  //
+  // Exercise every validateStringArray call site (files, inputs, expectedOutput)
+  // so a future missing-import would surface as a per-field assertion failure
+  // here, not a deep ReferenceError that's easy to mis-diagnose.
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    for (const field of ['files', 'inputs', 'expectedOutput'] as const) {
+      const result = await handlePlanSlice({
+        ...validParams(),
+        tasks: [{
+          ...validParams().tasks[0],
+          [field]: 'not-an-array' as unknown as string[],
+        }],
+      }, base);
+      assert.ok('error' in result, `${field}: expected validation error, got success`);
+      assert.match(
+        result.error,
+        new RegExp(`tasks\\[0\\]\\.${field} must be an array`),
+        `${field}: expected per-field validation message, got: ${result.error}`,
+      );
+      assert.doesNotMatch(
+        result.error,
+        /is not defined/,
+        `${field}: validation surfaced ReferenceError — likely a missing import in plan-slice.ts`,
+      );
+      assert.equal(getSliceTasks('M001', 'S02').length, 0, `${field}: invalid input must not persist`);
+    }
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -79,6 +79,23 @@ test('handlePlanTask rejects invalid payloads', async () => {
   }
 });
 
+test('handlePlanTask explains string IO fields must be arrays', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      expectedOutput: 'src/output.ts' as unknown as string[],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: expectedOutput must be an array of strings, not string/);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanTask rejects absolute task IO paths outside the active worktree', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

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

@@ -127,6 +127,61 @@ import { b } from './b';
     assert.equal(imports.length, 2);
   });
 
+  test("ignores import-looking string literals in test fixtures", () => {
+    const source = `
+const rewritten = source.replace(
+  'import { normalizeZagrebBusinessDeadline } from "./cutoff";',
+  'const helper = true;'
+);
+
+import realThing from "./real-thing";
+`;
+    const imports = extractRelativeImports(source);
+    assert.deepEqual(imports, [
+      { importPath: "./real-thing", lineNum: 7 },
+    ]);
+  });
+
+  test("ignores import-looking lines inside template literals", () => {
+    const source = [
+      "const fixture = `",
+      "import missingThing from './missing-thing';",
+      "`;",
+      "",
+      "import realThing from './real-thing';",
+    ].join("\n");
+    const imports = extractRelativeImports(source);
+    assert.deepEqual(imports, [
+      { importPath: "./real-thing", lineNum: 5 },
+    ]);
+  });
+
+  test("ignores require() inside string literals", () => {
+    const source = [
+      'const fixture = "const x = require(\'./missing\');";',
+      "const otherFixture = 'const y = require(\"./also-missing\");';",
+      "const real = require('./real');",
+    ].join("\n");
+    const imports = extractRelativeImports(source);
+    assert.deepEqual(imports, [
+      { importPath: "./real", lineNum: 3 },
+    ]);
+  });
+
+  test("ignores require() inside template literals", () => {
+    const source = [
+      "const fixture = `",
+      "const x = require('./missing');",
+      "`;",
+      "",
+      "const real = require('./real');",
+    ].join("\n");
+    const imports = extractRelativeImports(source);
+    assert.deepEqual(imports, [
+      { importPath: "./real", lineNum: 5 },
+    ]);
+  });
+
   test("handles empty source", () => {
     const imports = extractRelativeImports("");
     assert.deepEqual(imports, []);
@@ -810,6 +865,37 @@ describe("runPostExecutionChecks", () => {
     }
   });
 
+  test("does not fail on import-looking strings in task key files", () => {
+    tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    mkdirSync(join(tempDir, "tests"), { recursive: true });
+    writeFileSync(join(tempDir, "tests", "real-thing.ts"), "export default true;");
+    writeFileSync(
+      join(tempDir, "tests", "source-verifier.test.ts"),
+      `
+const rewritten = source.replace(
+  'import { normalizeZagrebBusinessDeadline } from "./cutoff";',
+  'const helper = true;'
+);
+
+import realThing from "./real-thing";
+assert.ok(realThing);
+`
+    );
+
+    try {
+      const task = createTask({
+        id: "T03",
+        key_files: ["tests/source-verifier.test.ts"],
+      });
+      const result = runPostExecutionChecks(task, [], tempDir);
+      assert.equal(result.status, "pass");
+      assert.deepEqual(result.checks, []);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
   test("returns fail status when blocking failure exists", () => {
     tempDir = join(tmpdir(), `post-exec-test-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });