gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

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

@@ -0,0 +1,230 @@
+/**
+ * Tests for fix of #3723: auto-mode resume/crash-recovery dispatches
+ * from project root instead of milestone worktree.
+ *
+ * During resume, the paused-session metadata may record `worktreePath` that
+ * was active when the session paused. The resume path must use that path (or
+ * derive the worktree path via filesystem lookup) to set the dispatch context
+ * (`s.basePath`), rather than defaulting to the project root.
+ *
+ * The fix adds an early worktree-path resolution step in the paused-session
+ * resume block of auto.ts — immediately after `s.basePath = base` — so that
+ * the correct dispatch directory is used before the dispatch loop runs.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const autoSrc = readFileSync(join(__dirname, "..", "auto.ts"), "utf-8");
+
+// ── Source-structure tests ────────────────────────────────────────────────────
+
+/**
+ * Extract the paused-session resume block from auto.ts.
+ *
+ * The block we care about is the `if (s.paused) { ... }` section inside
+ * startAuto, which contains `s.basePath = base` (line ~1473) followed by the
+ * `enterMilestone` call.
+ *
+ * We find it by locating the `s.basePath = base` assignment that appears
+ * WITHIN the s.paused branch (there's only one: all other basePath assignments
+ * use originalBasePath or a different value). We extract from that assignment
+ * up to just before `enterMilestone(`.
+ */
+function getBasepathToEnterMilestoneSegment(): string {
+  // Find `s.basePath = base;` in the s.paused branch
+  // This assignment appears uniquely inside the resume block
+  const assignPattern = "s.basePath = base;";
+  const assignIdx = autoSrc.indexOf(assignPattern);
+  assert.ok(
+    assignIdx > -1,
+    `auto.ts must contain '${assignPattern}' in the resume block`,
+  );
+
+  // Find the next enterMilestone call after this assignment
+  const enterMilestoneIdx = autoSrc.indexOf("enterMilestone(", assignIdx);
+  assert.ok(
+    enterMilestoneIdx > assignIdx,
+    "auto.ts must call enterMilestone after the s.basePath = base assignment",
+  );
+
+  // Return the code between the assignment and enterMilestone
+  return autoSrc.slice(assignIdx, enterMilestoneIdx);
+}
+
+test("auto.ts resume block resolves paused-session worktreePath and applies it to s.basePath before entering worktree (fixes #3723)", () => {
+  // The segment between `s.basePath = base` and `enterMilestone(` must
+  // contain logic that resolves the paused-session worktreePath and applies
+  // it to s.basePath when the worktree exists on disk.
+  //
+  // The fix reads the worktree path from freshStartAssessment.pausedSession
+  // (since `meta` is out of scope at this point in startAuto) and assigns
+  // it to s.basePath, guarded by existsSync.
+  //
+  // Without this fix, the dispatch loop runs from `base` (project root)
+  // instead of the worktree, causing split-brain execution (#3723).
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // The fix uses freshStartAssessment.pausedSession?.worktreePath via a
+  // local variable (resumeWorktreePath) and assigns to s.basePath.
+  const hasWorktreePathResolution =
+    segment.includes("worktreePath") &&
+    segment.includes("existsSync") &&
+    segment.includes("s.basePath =");
+
+  assert.ok(
+    hasWorktreePathResolution,
+    "auto.ts must resolve the paused-session worktreePath, check existsSync, and assign " +
+    "s.basePath before enterMilestone — crash-recovery currently dispatches from project root " +
+    "instead of milestone worktree (issue #3723). The fix belongs between `s.basePath = base` " +
+    "and the enterMilestone call.",
+  );
+});
+
+test("auto.ts worktreePath assignment in resume block guards against non-existent path (fixes #3723)", () => {
+  // The assignment to s.basePath from the paused-session worktreePath must
+  // be guarded by existsSync to avoid setting an invalid basePath if the
+  // worktree was cleaned up between pause and resume.
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // Must have existsSync guard AND a worktreePath reference AND s.basePath assignment
+  const hasGuardedAssignment =
+    segment.includes("existsSync") &&
+    segment.includes("worktreePath") &&
+    segment.includes("s.basePath =");
+
+  assert.ok(
+    hasGuardedAssignment,
+    "auto.ts must guard the s.basePath = worktreePath assignment with existsSync (fixes #3723)",
+  );
+});
+
+// ── Functional tests ──────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writePausedSession(
+  base: string,
+  milestoneId: string,
+  worktreePath: string | null,
+): void {
+  writeFileSync(
+    join(base, ".gsd", "runtime", "paused-session.json"),
+    JSON.stringify({
+      milestoneId,
+      originalBasePath: base,
+      stepMode: false,
+      worktreePath,
+      pausedAt: new Date().toISOString(),
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+function makeWorktreePath(base: string, milestoneId: string): string {
+  return join(base, ".gsd", "worktrees", milestoneId);
+}
+
+function setupWorktreeOnDisk(wt: string): void {
+  mkdirSync(wt, { recursive: true });
+  // Simulate a git worktree: .git file with gitdir pointer
+  writeFileSync(
+    join(wt, ".git"),
+    "gitdir: /project/.git/worktrees/M001-test\n",
+    "utf-8",
+  );
+}
+
+function writeRoadmap(base: string, milestoneId = "M001-test"): void {
+  const milestoneDir = join(base, ".gsd", "milestones", milestoneId);
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, `${milestoneId}-ROADMAP.md`),
+    [
+      `# ${milestoneId}: Test Milestone`,
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Test slice** `risk:low`",
+      "  After this: Demo",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+test("readPausedSessionMetadata round-trips worktreePath from paused-session.json", () => {
+  // Verify that the paused-session metadata correctly stores and reads back
+  // the worktreePath field — this is what the resume path in auto.ts uses
+  // to determine the dispatch basePath (#3723).
+  //
+  // Implemented inline to avoid slow import chain from interrupted-session.ts.
+  const base = makeTmpBase();
+  const wt = makeWorktreePath(base, "M001-test");
+  try {
+    setupWorktreeOnDisk(wt);
+    writePausedSession(base, "M001-test", wt);
+
+    // Simulate readPausedSessionMetadata without importing the full module
+    const pausedPath = join(base, ".gsd", "runtime", "paused-session.json");
+    const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
+
+    assert.ok(meta, "paused-session metadata must be readable");
+    assert.equal(meta.milestoneId, "M001-test");
+    assert.equal(meta.worktreePath, wt, "worktreePath must round-trip through paused-session.json");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("auto.ts resume block uses worktreePath from freshStartAssessment.pausedSession as dispatch basePath when worktree exists (#3723)", () => {
+  // End-to-end structural verification: the auto.ts source must contain code
+  // that reads the worktreePath from freshStartAssessment.pausedSession AND
+  // applies it to s.basePath (guarded by existsSync) between the
+  // `s.basePath = base` assignment and `enterMilestone`.
+  //
+  // This is the core of the #3723 fix. Without this check, a session that
+  // paused while operating inside a worktree will resume dispatching from the
+  // project root, not the worktree — causing split-brain execution where some
+  // operations target the worktree and others target the project root.
+  const segment = getBasepathToEnterMilestoneSegment();
+
+  // Must reference freshStartAssessment.pausedSession?.worktreePath or
+  // equivalent local variable, AND contain an existsSync guard
+  const hasAssessmentWorktreePath =
+    segment.includes("freshStartAssessment.pausedSession") &&
+    segment.includes("worktreePath");
+
+  assert.ok(
+    hasAssessmentWorktreePath,
+    "auto.ts must read worktreePath from freshStartAssessment.pausedSession between " +
+    "s.basePath=base and enterMilestone",
+  );
+  assert.ok(
+    segment.includes("existsSync"),
+    "auto.ts must guard worktreePath usage with existsSync",
+  );
+  // The actual basePath re-assignment must be present in the segment
+  // (note: there are multiple `s.basePath =` assignments — we need one after
+  // the initial `s.basePath = base` assignment within this segment)
+  const worktreeAssignIdx = segment.lastIndexOf("s.basePath =");
+  const baseAssignIdx = segment.indexOf("s.basePath = base");
+  assert.ok(
+    worktreeAssignIdx > baseAssignIdx,
+    "auto.ts must assign s.basePath to the worktree path after `s.basePath = base` in the resume block",
+  );
+});

package/src/resources/extensions/gsd/tests/rewrite-docs-abandon-detect.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Regression tests for #3490: post-unit handler for rewrite-docs must
+ * detect abandon/descope overrides that target the current milestone and
+ * park it — without false-positive parking on unrelated scope-change
+ * overrides that merely contain an abandon-family verb.
+ *
+ * Exercises detectAbandonMilestone() directly — a pure function over
+ * Override objects, no I/O and no production-code import chain.
+ * parkMilestone() end-to-end behavior is covered by the existing
+ * park-milestone.test.ts / park-edge-cases.test.ts / park-db-sync.test.ts
+ * suites; here we only validate the decision layer that feeds it.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { detectAbandonMilestone } from "../abandon-detect.ts";
+import type { Override } from "../files.ts";
+
+function mkOverride(change: string): Override {
+  return {
+    timestamp: "2026-04-21T00:00:00.000Z",
+    change,
+    scope: "active",
+    appliedAt: "M001/S01/T01",
+  };
+}
+
+describe("detectAbandonMilestone (#3490)", () => {
+  test("parks on explicit abandon-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon this milestone, it's no longer relevant")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 1);
+    assert.match(d.reason, /abandon this milestone/);
+  });
+
+  test("parks on descope-milestone phrasing", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("descope the entire milestone")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks when override references milestone by ID instead of the word", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("shelve M003 for now, coming back next quarter")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched[0], "shelve M003 for now, coming back next quarter");
+  });
+
+  test("parks on past-tense / gerund verb forms (UK spelling)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("this milestone was cancelled by product")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on US spelling 'canceled' (single-l)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("the milestone was canceled by the PM")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on hyphenated 'de-scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de-scope this milestone — moved to v2")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on space-separated 'de scope' variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("de scope the milestone entirely")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  test("parks on 'de-scoped' past-tense hyphen variant", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("M003 was de-scoped last week")],
+      "M003",
+    );
+    assert.strictEqual(d.shouldPark, true);
+  });
+
+  // ─── False-positive guards ────────────────────────────────────────────
+
+  test("does NOT park on 'cancel the standup reminder' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("cancel the daily standup reminder")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("does NOT park on 'drop the dependency on X' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("drop the dependency on X and use Y instead")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on 'scrap the v1 design' (no milestone ref)", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("scrap the v1 design for the landing page")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park on override with milestone word but no abandon verb", () => {
+    const d = detectAbandonMilestone(
+      [mkOverride("change the milestone title to something clearer")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  test("does NOT park when a different milestone ID is referenced", () => {
+    // The abandon verb is present and an MID is present, but the MID is
+    // not the current milestone. We require either the literal word
+    // "milestone" OR the current MID — a reference to a different MID
+    // (M007) with neither the word "milestone" nor the current ID (M001)
+    // should not trigger.
+    const d = detectAbandonMilestone(
+      [mkOverride("drop M007")],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, false);
+  });
+
+  // ─── Edge cases ───────────────────────────────────────────────────────
+
+  test("empty overrides list returns no-park", () => {
+    const d = detectAbandonMilestone([], "M001");
+    assert.strictEqual(d.shouldPark, false);
+    assert.deepStrictEqual(d.matched, []);
+  });
+
+  test("null/undefined currentMilestoneId returns no-park even with matching text", () => {
+    const d1 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      null,
+    );
+    assert.strictEqual(d1.shouldPark, false);
+
+    const d2 = detectAbandonMilestone(
+      [mkOverride("abandon this milestone")],
+      undefined,
+    );
+    assert.strictEqual(d2.shouldPark, false);
+  });
+
+  test("multiple abandon overrides are concatenated in reason", () => {
+    const d = detectAbandonMilestone(
+      [
+        mkOverride("abandon this milestone"),
+        mkOverride("cancel the standup"),           // filtered out (no ref)
+        mkOverride("descope the milestone entirely"),
+      ],
+      "M001",
+    );
+    assert.strictEqual(d.shouldPark, true);
+    assert.strictEqual(d.matched.length, 2, "only the two milestone-scoped overrides match");
+    assert.match(d.reason, /abandon this milestone/);
+    assert.match(d.reason, /descope the milestone entirely/);
+    assert.doesNotMatch(d.reason, /cancel the standup/);
+  });
+
+  // ─── Regex-injection guard on milestone ID ────────────────────────────
+
+  test("milestone ID with regex metacharacters is escaped, not interpreted", () => {
+    // A pathological MID should not break the matcher — the function
+    // escapes regex metacharacters before building the pattern.
+    const d = detectAbandonMilestone(
+      [mkOverride("abandon M.01 the milestone")],
+      "M.01",
+    );
+    // 'milestone' is present, so this parks regardless of escaping,
+    // but the test confirms the RegExp construction does not throw.
+    assert.strictEqual(d.shouldPark, true);
+  });
+});
+

package/src/resources/extensions/gsd/tests/safety-harness-false-positives.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Regression tests for three false-positive sources in the safety harness.
+ * Issue #4385
+ *
+ * Bug 1: Hardcoded BASH_READ_ONLY_RE — new legitimate commands blocked
+ * Bug 2: Non-persisted evidence — session restart causes false positive on resume
+ * Bug 3: git diff HEAD~1 scope check — fails on initial commits / shallow clones
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { shouldBlockQueueExecution } from "../bootstrap/write-gate.ts";
+import {
+  resetEvidence,
+  recordToolCall,
+  getEvidence,
+  saveEvidenceToDisk,
+  loadEvidenceFromDisk,
+} from "../safety/evidence-collector.ts";
+import { validateFileChanges } from "../safety/file-change-validator.ts";
+
+// ─── Bug 1: Hardcoded Bash allowlist ────────────────────────────────────────
+
+test("safety-harness-bug1: npm commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "npm run test", true);
+  assert.strictEqual(r.block, false, "npm run test must be read-only-safe");
+});
+
+test("safety-harness-bug1: npx commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "npx tsc --noEmit", true);
+  assert.strictEqual(r.block, false, "npx tsc --noEmit must pass");
+});
+
+test("safety-harness-bug1: tsx commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "tsx src/index.ts", true);
+  assert.strictEqual(
+    r.block,
+    false,
+    "tsx (TypeScript runner — read-only investigative) must pass",
+  );
+});
+
+test("safety-harness-bug1: node --print commands are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "node --print 'process.version'", true);
+  assert.strictEqual(r.block, false, "node --print must pass");
+});
+
+test("safety-harness-bug1: python read-only invocations are not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "python -c 'import sys; print(sys.version)'", true);
+  assert.strictEqual(r.block, false, "python -c read-only must pass");
+});
+
+test("safety-harness-bug1: jq read-only command is not blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "jq '.version' package.json", true);
+  assert.strictEqual(r.block, false, "jq (read-only JSON query) must pass");
+});
+
+test("safety-harness-bug1: destructive commands are still blocked during queue mode", () => {
+  const r = shouldBlockQueueExecution("bash", "rm -rf dist/", true);
+  assert.strictEqual(r.block, true, "rm -rf must still be blocked");
+});
+
+// ─── Bug 2: Non-persisted evidence ──────────────────────────────────────────
+
+test("safety-harness-bug2: evidence survives save/load round-trip (simulates session restart)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-persist-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+
+  // Simulate bash tool calls during unit execution
+  recordToolCall("tc-001", "Bash", { command: "npm run test:unit" });
+  recordToolCall("tc-002", "Bash", { command: "npx tsc --noEmit" });
+  recordToolCall("tc-003", "Write", { file_path: "src/foo.ts" });
+
+  const before = getEvidence();
+  assert.equal(before.length, 3, "three entries before save");
+
+  // Persist to disk
+  saveEvidenceToDisk(base, "M001", "S001", "T001");
+
+  // Simulate session restart: module-level array reset
+  resetEvidence();
+  assert.equal(getEvidence().length, 0, "in-memory cleared after reset");
+
+  // Resume: load from disk
+  loadEvidenceFromDisk(base, "M001", "S001", "T001");
+
+  const after = getEvidence();
+  assert.equal(after.length, 3, "evidence restored from disk after simulated restart");
+
+  const bashEntries = after.filter((e) => e.kind === "bash");
+  assert.equal(bashEntries.length, 2, "both bash entries restored");
+
+  const writeEntries = after.filter((e) => e.kind === "write");
+  assert.equal(writeEntries.length, 1, "write entry restored");
+});
+
+test("safety-harness-bug2: loadEvidenceFromDisk returns empty array when no file exists (fresh unit)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-evidence-nopersist-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  resetEvidence();
+  loadEvidenceFromDisk(base, "M001", "S001", "T001");
+  assert.equal(getEvidence().length, 0, "no evidence on fresh unit is correct — not a false positive");
+});
+
+// ─── Bug 3: git diff HEAD~1 scope check ─────────────────────────────────────
+
+test("safety-harness-bug3: validateFileChanges works on initial commit (no HEAD~1)", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-initial-commit-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  execFileSync("git", ["init"], { cwd: base });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base });
+
+  writeFileSync(join(base, "index.ts"), "export const x = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base });
+
+  // On initial commit, HEAD~1 does not exist — must not throw or produce wrong results
+  const audit = validateFileChanges(base, ["index.ts"], []);
+
+  assert.ok(audit !== null, "audit must be produced for initial commit");
+  assert.deepEqual(audit!.unexpectedFiles, [], "no unexpected files on initial commit");
+  assert.deepEqual(audit!.missingFiles, [], "no missing files on initial commit");
+});
+
+test("safety-harness-bug3: validateFileChanges works on shallow clone (shallow repo without full history)", (t) => {
+  // Simulate shallow clone: create a repo, then clone it with depth=1
+  const origin = mkdtempSync(join(tmpdir(), "gsd-origin-"));
+  const shallow = mkdtempSync(join(tmpdir(), "gsd-shallow-"));
+  t.after(() => {
+    rmSync(origin, { recursive: true, force: true });
+    rmSync(shallow, { recursive: true, force: true });
+  });
+
+  // Set up origin with multiple commits
+  execFileSync("git", ["init"], { cwd: origin });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: origin });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: origin });
+  writeFileSync(join(origin, "a.ts"), "export const a = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: origin });
+  execFileSync("git", ["commit", "-m", "first"], { cwd: origin });
+  writeFileSync(join(origin, "b.ts"), "export const b = 2;\n");
+  execFileSync("git", ["add", "."], { cwd: origin });
+  execFileSync("git", ["commit", "-m", "second"], { cwd: origin });
+
+  // Shallow clone with depth=1 — HEAD~1 will not exist
+  execFileSync("git", ["clone", "--depth=1", `file://${origin}`, shallow], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  // Verify the shallow clone has no parent (HEAD~1 unavailable)
+  let hasParent = true;
+  try {
+    execFileSync("git", ["rev-parse", "HEAD~1"], {
+      cwd: shallow,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+  } catch {
+    hasParent = false;
+  }
+  assert.equal(hasParent, false, "shallow clone should not have HEAD~1");
+
+  // validateFileChanges must not throw or give wrong results
+  const audit = validateFileChanges(shallow, ["b.ts"], []);
+  assert.ok(audit !== null, "audit must be produced even in shallow clone");
+});
+
+test("safety-harness-bug3: validateFileChanges works on merge commit", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-merge-commit-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  execFileSync("git", ["init", "-b", "main"], { cwd: base });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base });
+
+  // Main branch: initial commit
+  writeFileSync(join(base, "main.ts"), "export const m = 1;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base });
+
+  // Feature branch
+  execFileSync("git", ["checkout", "-b", "feature"], { cwd: base });
+  writeFileSync(join(base, "feature.ts"), "export const f = 2;\n");
+  execFileSync("git", ["add", "."], { cwd: base });
+  execFileSync("git", ["commit", "-m", "feature work"], { cwd: base });
+
+  // Merge back to main
+  execFileSync("git", ["checkout", "main"], { cwd: base });
+  execFileSync("git", ["merge", "--no-ff", "feature", "-m", "Merge feature"], { cwd: base });
+
+  // HEAD is now a merge commit with two parents — git diff HEAD~1 gives wrong scope
+  const audit = validateFileChanges(base, ["feature.ts"], []);
+
+  // Must produce a valid result without throwing
+  assert.ok(audit !== null, "audit must be produced for merge commit repo");
+});