gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

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

@@ -2,11 +2,11 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync, realpathSync } from 'node:fs';
 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;
 }
 
@@ -84,6 +88,8 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
     assert.equal(tasks[0]?.title, 'Write slice handler');
     assert.equal(tasks[0]?.description, 'Implement the slice planning handler.');
     assert.equal(tasks[1]?.estimate, '30m');
+    assert.deepEqual(slice?.target_repositories, ['project']);
+    assert.deepEqual(tasks[0]?.target_repositories, ['project']);
 
     const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
     assert.ok(existsSync(planPath), 'slice plan should be rendered to disk');
@@ -101,6 +107,120 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice persists explicit slice/task target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const params = validParams();
+    const result = await handlePlanSlice({
+      ...params,
+      targetRepositories: ['project'],
+      tasks: [
+        { ...params.tasks[0], targetRepositories: ['project'] },
+        { ...params.tasks[1], targetRepositories: ['project'] },
+      ],
+    }, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const slice = getSlice('M001', 'S02');
+    const task = getTask('M001', 'S02', 'T01');
+    assert.deepEqual(slice?.target_repositories, ['project']);
+    assert.deepEqual(task?.target_repositories, ['project']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice rejects unknown target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    const result = await handlePlanSlice({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: unknown targetRepositories:/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid target repositories must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice enforces absolute path scope to declared target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    mkdirSync(join(base, 'frontend'), { recursive: true });
+    mkdirSync(join(base, 'backend'), { recursive: true });
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'workspace:',
+        '  mode: parent',
+        '  repositories:',
+        '    frontend:',
+        '      path: frontend',
+        '    backend:',
+        '      path: backend',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const badPath = join(base, 'backend', 'src', 'server.ts');
+    const result = await handlePlanSlice({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+      tasks: [
+        {
+          ...validParams().tasks[0],
+          files: [badPath],
+          targetRepositories: ['frontend'],
+        },
+      ],
+    }, base);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /outside allowed repository roots/);
+    assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid scoped path must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanSlice renders plan artifacts under worktree-local .gsd while using project DB', async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, '.gsd', 'worktrees', 'M001');
+  mkdirSync(join(worktree, '.gsd'), { recursive: true });
+  mkdirSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const result = await handlePlanSlice(validParams(), worktree);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const worktreePlan = join(worktree, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const projectPlan = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    assert.ok(existsSync(worktreePlan), 'slice plan should be rendered to worktree-local .gsd');
+    assert.ok(!existsSync(projectPlan), 'slice plan should not be rendered to project .gsd');
+    assert.equal(result.planPath, realpathSync(worktreePlan));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -125,6 +245,31 @@ test('handlePlanSlice advances DB-derived state out of planning immediately', as
   }
 });
 
+test('handlePlanSlice clears sketch flag so DB-derived state leaves refining', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    invalidateStateCache();
+    const before = await deriveState(base);
+    assert.equal(before.phase, 'refining');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 0, 'planned slice must no longer be treated as a sketch');
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.notEqual(after.phase, 'refining');
+    assert.equal(after.progress?.tasks?.total, 2);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice leaves omitted enrichment fields empty instead of rendering placeholders', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -172,6 +317,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'));
@@ -191,13 +358,70 @@ test('handlePlanSlice rejects absolute task IO paths outside the active worktree
     }, base);
 
     assert.ok('error' in result);
-    assert.match(result.error, /validation failed: tasks\[0\]\.inputs contains absolute path outside working directory/);
+    assert.match(result.error, /validation failed: tasks\[0\]\.inputs contains absolute path outside allowed repository roots/);
     assert.equal(getSliceTasks('M001', 'S02').length, 0, 'invalid planning IO must not persist tasks');
   } finally {
     cleanup(base);
   }
 });
 
+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'));
@@ -304,3 +528,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'));
@@ -93,7 +110,7 @@ test('handlePlanTask rejects absolute task IO paths outside the active worktree'
     }, base);
 
     assert.ok('error' in result);
-    assert.match(result.error, /validation failed: inputs contains absolute path outside working directory/);
+    assert.match(result.error, /validation failed: inputs contains absolute path outside allowed repository roots/);
     assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid planning IO must not persist the task');
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Tests for post-execution retry bypass and verification gate failure handling.
 /**
  * post-exec-retry-bypass.test.ts — Tests for post-execution blocking failure retry bypass.
  *
@@ -9,7 +11,7 @@
 import { describe, test, mock, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { tmpdir } from "node:os";
-import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
@@ -71,6 +73,7 @@ function setupTestEnvironment(): void {
   mkdirSync(milestonesDir, { recursive: true });
 
   process.chdir(tempDir);
+  invalidateAllCaches();
   _clearGsdRootCache();
 
   dbPath = join(gsdDir, "gsd.db");
@@ -140,6 +143,34 @@ function createBasicTask(): void {
   });
 }
 
+function createTaskWithoutVerify(): void {
+  insertMilestone({ id: "M001" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task without host verification",
+    status: "pending",
+    planning: {
+      description: "Task intentionally missing runnable verification",
+      estimate: "1h",
+      files: [],
+      verify: "",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+}
+
 function createPostExecFailureTask(): void {
   insertMilestone({ id: "M001" });
   insertSlice({
@@ -327,6 +358,53 @@ describe("Post-execution blocking failure retry bypass", () => {
     assert.equal(row?.outcome, "fail");
     assert.equal(row?.failure_class, "artifact");
   });
+
+  test("execute-task with no host-owned verification pauses fail-closed", async () => {
+    createTaskWithoutVerify();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    assert.equal(s.pendingVerificationRetry, null);
+
+    const evidencePath = join(tempDir, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-VERIFY.json");
+    const evidence = JSON.parse(readFileSync(evidencePath, "utf-8"));
+    assert.equal(evidence.passed, false);
+    assert.equal(evidence.discoverySource, "none");
+    assert.ok(!("retryAttempt" in evidence), "no-host-checks evidence must not include retryAttempt");
+    assert.ok(!("maxRetries" in evidence), "no-host-checks evidence must not include maxRetries");
+  });
+
+  test("auto-discovered package.json verification failure retries instead of continuing", async () => {
+    createTaskWithoutVerify();
+    writeFileSync(
+      join(tempDir, "package.json"),
+      JSON.stringify({ scripts: { test: "exit 1" } }),
+      "utf-8",
+    );
+    writePreferences({
+      verification_auto_fix: true,
+      verification_max_retries: 2,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const result = await runPostUnitVerification({ s, ctx, pi }, pauseAutoMock);
+
+    assert.equal(result, "retry");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.equal(s.pendingVerificationRetry?.unitId, "M001/S01/T01");
+    assert.match(s.pendingVerificationRetry?.failureContext ?? "", /npm run test/);
+  });
 });
 
 describe("Post-execution retry behavior", () => {

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, []);
@@ -317,7 +372,23 @@ describe("resolveImportPath", () => {
     assert.ok(result.resolvedPath?.endsWith("route.server.ts"));
   });
 
-  test("missing unknown explicit extension does not match code-extension shadow", (t) => {
+  test("resolves dotted TS module stem like .test-utils via extension probing", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "post-exec-test-dotted-stem-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    mkdirSync(join(dir, "src", "lib"), { recursive: true });
+    writeFileSync(join(dir, "src", "lib", "test-helpers.test-utils.ts"), "export {};\n");
+    writeFileSync(join(dir, "src", "main.integration.test.ts"), "");
+
+    const result = resolveImportPath(
+      "./lib/test-helpers.test-utils",
+      "src/main.integration.test.ts",
+      dir
+    );
+    assert.ok(result.exists);
+    assert.ok(result.resolvedPath?.endsWith("test-helpers.test-utils.ts"));
+  });
+
+  test("unknown dotted stem falls through to extension probing", (t) => {
     const dir = mkdtempSync(join(tmpdir(), "post-exec-test-unknown-shadow-"));
     t.after(() => rmSync(dir, { recursive: true, force: true }));
     mkdirSync(join(dir, "src"), { recursive: true });
@@ -325,8 +396,8 @@ describe("resolveImportPath", () => {
     writeFileSync(join(dir, "src", "main.ts"), "");
 
     const result = resolveImportPath("./video.mp4", "src/main.ts", dir);
-    assert.ok(!result.exists);
-    assert.equal(result.resolvedPath, null);
+    assert.ok(result.exists);
+    assert.ok(result.resolvedPath?.endsWith("video.mp4.ts"));
   });
 });
 
@@ -810,6 +881,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 });