gsd-pi 2.67.0-dev.2142d3e → 2.67.0-dev.2367d7e

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -219,39 +219,6 @@ describe('doctor-proactive', async () => {
       assert.ok(result.fixesApplied.some((f: string) => f.includes("STATE.md")), "reports STATE.md status as info");
     });
 
-    test('health gate: pre-dispatch snapshot includes new untracked files', async () => {
-      const dir = createRepoWithActiveMilestone();
-      cleanups.push(dir);
-
-      const pastDate = new Date(Date.now() - 45 * 60 * 1000).toISOString();
-      run(`git commit --amend --no-edit --date="${pastDate}"`, dir);
-      execSync(`git commit --amend --no-edit`, {
-        cwd: dir,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: { ...process.env, GIT_COMMITTER_DATE: pastDate },
-      });
-
-      writeFileSync(join(dir, "README.md"), "# test\nmodified content\n");
-      writeFileSync(join(dir, "new-untracked.ts"), "export const preserved = true;\n");
-
-      const result = await preDispatchHealthGate(dir);
-      assert.ok(result.proceed, "dispatch still proceeds after snapshotting");
-      assert.ok(
-        result.fixesApplied.some((f: string) => f.includes("gsd snapshot")),
-        "pre-dispatch gate creates a snapshot commit",
-      );
-
-      const log = run("git log -1 --oneline", dir);
-      assert.ok(log.includes("gsd snapshot"), "snapshot commit is created");
-
-      const files = run("git show --name-only --format= HEAD", dir);
-      assert.ok(files.includes("README.md"), "snapshot keeps tracked modifications");
-      assert.ok(files.includes("new-untracked.ts"), "snapshot also includes new untracked files");
-      const status = run("git status --short", dir);
-      assert.ok(!status.includes("new-untracked.ts"), "snapshot does not leave the new source file untracked");
-    });
-
     test('health gate: stale crash lock auto-cleared', async () => {
       const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-proactive-")));
       cleanups.push(dir);

package/src/resources/extensions/gsd/tests/integration/merge-cwd-restore.test.ts

@@ -0,0 +1,169 @@
+/**
+ * GSD-2 — Regression tests for merge cwd restore (#2929)
+ * merge-cwd-restore.test.ts — Regression tests for #2929.
+ *
+ * Verifies:
+ *   1. MergeConflictError restores process.cwd() to the pre-merge directory.
+ *   2. autoCommitDirtyState does not run on the integration branch when cwd
+ *      leaked there from a prior failed merge (parallel mode).
+ *
+ * Bug: PR #2298 added a stash lifecycle around mergeMilestoneToMain but the
+ * MergeConflictError throw path omitted the process.chdir(previousCwd) that
+ * the dirty-working-tree and divergence handlers both include. In parallel
+ * merge sequences, this left cwd on the integration branch, causing the next
+ * merge's autoCommitDirtyState to commit dirty files from OTHER milestones
+ * onto main.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  realpathSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { MergeConflictError } from "../../git-service.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(
+    mkdtempSync(join(tmpdir(), "merge-cwd-restore-test-")),
+  );
+  run("git init -b main", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  return dir;
+}
+
+function makeRoadmap(mid: string, title: string): string {
+  return [
+    `# ${mid}: Test milestone`,
+    "",
+    "## Slices",
+    "- [x] **S01: Test slice**",
+  ].join("\n");
+}
+
+describe("merge cwd restore (#2929)", () => {
+  let repo: string;
+  let savedCwd: string;
+
+  beforeEach(() => {
+    savedCwd = process.cwd();
+    repo = createTempRepo();
+  });
+
+  afterEach(() => {
+    process.chdir(savedCwd);
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Test 1: MergeConflictError restores cwd (#2929 bug 2)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  test("MergeConflictError restores cwd to pre-merge directory", () => {
+    // Create milestone branch that modifies README.md
+    run("git checkout -b milestone/M010", repo);
+    writeFileSync(join(repo, "README.md"), "# M010 version\n");
+    run("git add .", repo);
+    run('git commit -m "M010 changes README"', repo);
+    run("git checkout main", repo);
+
+    // Modify README.md on main to create a conflict
+    writeFileSync(join(repo, "README.md"), "# main version (diverged)\n");
+    run("git add .", repo);
+    run('git commit -m "main diverges README"', repo);
+
+    // cwd must be repo root (simulates parallel-merge calling from project root)
+    process.chdir(repo);
+    const cwdBefore = process.cwd();
+
+    let caught: unknown = null;
+    try {
+      mergeMilestoneToMain(repo, "M010", makeRoadmap("M010", "Conflict test"));
+    } catch (err) {
+      caught = err;
+    }
+
+    // Should have thrown a MergeConflictError
+    assert.ok(caught instanceof MergeConflictError, "expected MergeConflictError");
+
+    // Critical: cwd must be restored to where it was before the merge
+    const cwdAfter = process.cwd();
+    assert.equal(
+      cwdAfter,
+      cwdBefore,
+      "cwd should be restored after MergeConflictError — was left on integration branch before fix",
+    );
+  });
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Test 2: autoCommitDirtyState skipped when on integration branch (#2929 bug 1)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  test("autoCommitDirtyState does not commit on integration branch in worktree mode", () => {
+    // Create milestone branch with real work
+    run("git checkout -b milestone/M010", repo);
+    writeFileSync(join(repo, "m010.ts"), "export const m010 = true;\n");
+    run("git add .", repo);
+    run('git commit -m "M010 work"', repo);
+    run("git checkout main", repo);
+
+    // Simulate the parallel-mode state: cwd is on main with dirty files
+    // from another milestone (as if a prior merge's MergeConflictError
+    // left cwd on main and syncStateToProjectRoot wrote these files).
+    writeFileSync(join(repo, "dirty-from-m020.txt"), "should not be committed\n");
+
+    // Set up roadmap so mergeMilestoneToMain can find milestone metadata
+    mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
+    writeFileSync(
+      join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"),
+      makeRoadmap("M010", "First milestone"),
+    );
+
+    process.chdir(repo);
+
+    const result = mergeMilestoneToMain(
+      repo,
+      "M010",
+      makeRoadmap("M010", "First milestone"),
+    );
+
+    assert.ok(result.commitMessage.includes("M010"), "commit should be for M010");
+
+    // Verify the squash merge brought M010's work file
+    const mergeLog = run("git log --oneline --diff-filter=A -- m010.ts", repo);
+    assert.ok(mergeLog.length > 0, "m010.ts should be in a commit on main");
+
+    // The dirty file should NOT appear in the squash merge commit.
+    const squashCommit = run("git log --format=%H --grep='GSD-Milestone: M010' -1", repo);
+    assert.ok(squashCommit.length > 0, "should find the squash merge commit");
+    const filesInSquash = run(`git diff-tree --no-commit-id --name-only -r ${squashCommit}`, repo);
+    assert.ok(
+      !filesInSquash.includes("dirty-from-m020.txt"),
+      "dirty-from-m020.txt should NOT be in the squash merge commit",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/interrupted-session-auto.test.ts

@@ -0,0 +1,146 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { assessInterruptedSession } from "../interrupted-session.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-auto-interrupted-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writeRoadmap(base: string, checked = false): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "## Vision",
+      "",
+      "Test milestone.",
+      "",
+      "## Success Criteria",
+      "",
+      "- It works.",
+      "",
+      "## Slices",
+      "",
+      `- [${checked ? "x" : " "}] **S01: Test slice** \`risk:low\``,
+      "  After this: Demo",
+      "",
+      "## Boundary Map",
+      "",
+      "- S01 → terminal",
+      "  - Produces: done",
+      "  - Consumes: nothing",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+function writeCompleteArtifacts(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
+}
+
+function writeLock(base: string, unitType: string, unitId: string): void {
+  writeFileSync(
+    join(base, ".gsd", "auto.lock"),
+    JSON.stringify({
+      pid: 999999999,
+      startedAt: new Date().toISOString(),
+      unitType,
+      unitId,
+      unitStartedAt: new Date().toISOString(),
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
+  const runtimeDir = join(base, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  writeFileSync(
+    join(runtimeDir, "paused-session.json"),
+    JSON.stringify({ milestoneId, originalBasePath: base, stepMode }, null, 2),
+    "utf-8",
+  );
+}
+
+test("direct /gsd auto stale complete repo yields stale classification with no recovery payload", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteArtifacts(base);
+    writeLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.recoveryPrompt, null);
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("direct /gsd auto paused-session metadata remains recoverable when work is unfinished", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base, "M001", false);
+    writeLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("direct /gsd auto stale paused-session metadata is treated as stale when no resumable work remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteArtifacts(base);
+    writePausedSession(base, "M999", true);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("direct /gsd auto source only resumes paused-session metadata for recoverable state with real recovery signals", async () => {
+  const source = await import(`node:fs/promises`).then((fs) =>
+    fs.readFile(new URL("../auto.ts", import.meta.url), "utf-8")
+  );
+  assert.ok(source.includes('const shouldResumePausedSession ='));
+  assert.ok(source.includes('freshStartAssessment.classification === "recoverable"'));
+  assert.ok(source.includes('&& ('));
+  assert.ok(source.includes('freshStartAssessment.hasResumableDiskState'));
+  assert.ok(source.includes('|| !!freshStartAssessment.recoveryPrompt'));
+  assert.ok(source.includes('|| !!freshStartAssessment.lock'));
+});
+
+test("auto module imports successfully after interrupted-session changes", async () => {
+  const mod = await import(`../auto.ts?ts=${Date.now()}-${Math.random()}`);
+  assert.equal(typeof mod.startAuto, "function");
+  assert.equal(typeof mod.pauseAuto, "function");
+});

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -0,0 +1,136 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { assessInterruptedSession } from "../interrupted-session.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-smart-entry-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function writeRoadmap(base: string, checked = false): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "## Vision",
+      "",
+      "Test milestone.",
+      "",
+      "## Success Criteria",
+      "",
+      "- It works.",
+      "",
+      "## Slices",
+      "",
+      `- [${checked ? "x" : " "}] **S01: Test slice** \`risk:low\``,
+      "  After this: Demo",
+      "",
+      "## Boundary Map",
+      "",
+      "- S01 → terminal",
+      "  - Produces: done",
+      "  - Consumes: nothing",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+function writeCompleteArtifacts(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Summary\nDone.\n", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.\n", "utf-8");
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\nDone.\n", "utf-8");
+}
+
+function writePausedSession(base: string, milestoneId = "M001", stepMode = false): void {
+  const runtimeDir = join(base, ".gsd", "runtime");
+  mkdirSync(runtimeDir, { recursive: true });
+  writeFileSync(
+    join(runtimeDir, "paused-session.json"),
+    JSON.stringify({ milestoneId, originalBasePath: base, stepMode }, null, 2),
+    "utf-8",
+  );
+}
+
+function writeLock(base: string, unitType: string, unitId: string): void {
+  writeFileSync(
+    join(base, ".gsd", "auto.lock"),
+    JSON.stringify({
+      pid: 999999999,
+      startedAt: new Date().toISOString(),
+      unitType,
+      unitId,
+      unitStartedAt: new Date().toISOString(),
+    }, null, 2),
+    "utf-8",
+  );
+}
+
+test("guided-flow stale complete scenario classifies as stale so the resume prompt can be suppressed", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteArtifacts(base);
+    writeLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.recoveryPrompt, null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("guided-flow paused-session scenario classifies as recoverable so resume remains available", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, false);
+    writePausedSession(base);
+    writeLock(base, "execute-task", "M001/S01/T01");
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "recoverable");
+    assert.equal(assessment.pausedSession?.milestoneId, "M001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("guided-flow stale paused-session scenario is suppressed when no resumable work remains", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, true);
+    writeCompleteArtifacts(base);
+    writePausedSession(base, "M999", true);
+
+    const assessment = await assessInterruptedSession(base);
+    assert.equal(assessment.classification, "stale");
+    assert.equal(assessment.hasResumableDiskState, false);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("guided-flow source uses step-aware resume and clears stale paused metadata without changing discuss handoff semantics", () => {
+  const source = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
+  assert.ok(source.includes('const interrupted = await assessInterruptedSession(basePath);'));
+  assert.ok(source.includes('resumeLabel = interrupted.pausedSession?.stepMode'));
+  assert.ok(source.includes('step: interrupted.pausedSession?.stepMode ?? false'));
+  assert.ok(source.includes('unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"))'));
+  assert.ok(source.includes('pendingAutoStartMap.set(basePath,'));
+});

package/src/resources/extensions/gsd/tests/mcp-project-config.test.ts

@@ -0,0 +1,85 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  ensureProjectWorkflowMcpConfig,
+  GSD_WORKFLOW_MCP_SERVER_NAME,
+} from "../mcp-project-config.ts";
+
+test("ensureProjectWorkflowMcpConfig creates .mcp.json with the workflow server", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(result.status, "created");
+    assert.equal(existsSync(result.configPath), true);
+
+    const parsed = JSON.parse(readFileSync(result.configPath, "utf-8")) as {
+      mcpServers?: Record<string, { command?: string; args?: string[]; env?: Record<string, string> }>;
+    };
+    const server = parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME];
+    assert.ok(server, "workflow server should be written to mcpServers");
+    assert.equal(typeof server?.command, "string");
+    assert.equal(Array.isArray(server?.args), true);
+    assert.equal(server?.env?.GSD_WORKFLOW_PROJECT_ROOT, projectRoot);
+    assert.match(server?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.js$/);
+    assert.match(server?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.js$/);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("ensureProjectWorkflowMcpConfig preserves existing mcp servers", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+  const configPath = join(projectRoot, ".mcp.json");
+
+  writeFileSync(
+    configPath,
+    `${JSON.stringify({
+      mcpServers: {
+        railway: {
+          command: "npx",
+          args: ["railway-mcp"],
+        },
+      },
+    }, null, 2)}\n`,
+    "utf-8",
+  );
+
+  try {
+    const result = ensureProjectWorkflowMcpConfig(projectRoot);
+    assert.equal(result.status, "updated");
+
+    const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as {
+      mcpServers?: Record<string, { command?: string; args?: string[] }>;
+    };
+    assert.deepEqual(parsed.mcpServers?.railway, {
+      command: "npx",
+      args: ["railway-mcp"],
+    });
+    assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("ensureProjectWorkflowMcpConfig is idempotent when config is already current", () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-init-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  try {
+    const first = ensureProjectWorkflowMcpConfig(projectRoot);
+    const second = ensureProjectWorkflowMcpConfig(projectRoot);
+
+    assert.equal(first.status, "created");
+    assert.equal(second.status, "unchanged");
+    assert.equal(first.configPath, second.configPath);
+  } finally {
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -2,6 +2,7 @@ import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  formatMcpInitResult,
   formatMcpStatusReport,
   formatMcpServerDetail,
   type McpServerStatus,
@@ -101,3 +102,17 @@ describe("formatMcpServerDetail", () => {
     assert.match(result, /disconnected/i);
   });
 });
+
+describe("formatMcpInitResult", () => {
+  test("shows created message with config path", () => {
+    const result = formatMcpInitResult("created", "/tmp/project/.mcp.json", "/tmp/project");
+    assert.match(result, /created project mcp config/i);
+    assert.match(result, /\/tmp\/project\/\.mcp\.json/);
+    assert.match(result, /claude code/i);
+  });
+
+  test("shows unchanged message when config is current", () => {
+    const result = formatMcpInitResult("unchanged", "/tmp/project/.mcp.json", "/tmp/project");
+    assert.match(result, /already up to date/i);
+  });
+});

package/src/resources/extensions/gsd/tests/verification-operational-gate.test.ts

@@ -32,6 +32,17 @@ test("isVerificationNotApplicable: 'None planned' is not applicable", () => {
   assert.equal(isVerificationNotApplicable("None planned"), true);
 });
 
+test("isVerificationNotApplicable: 'None — <rationale>' is not applicable (#3897)", () => {
+  assert.equal(
+    isVerificationNotApplicable("None — no new background jobs, workers, or lifecycle changes introduced."),
+    true,
+  );
+});
+
+test("isVerificationNotApplicable: em dash without spaces is not applicable (#3897)", () => {
+  assert.equal(isVerificationNotApplicable("none—inline"), true);
+});
+
 test("isVerificationNotApplicable: 'N/A' is not applicable", () => {
   assert.equal(isVerificationNotApplicable("N/A"), true);
 });