gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/src/resources/extensions/gsd/tests/queue-auto-guard.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Tests that /gsd queue is blocked when auto-mode is active.
+ *
+ * Relates to #4704: /gsd queue writes .gsd/PROJECT.md + QUEUE-ORDER.json
+ * directly into the project-root worktree, racing with auto-mode's
+ * pre-merge dirty-tree check and causing __dirty_working_tree__ failures.
+ *
+ * The fix adds an isAutoActive() guard in handleWorkflowCommand before
+ * delegating to showQueue, mirroring the existing /gsd quick guard (#2417).
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Structural test: verify the guard exists in source ──────────────────────
+
+describe("/gsd queue auto-mode guard (#4704)", () => {
+  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    // Find the queue command block
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
+
+    const queueBlock = queueBlockMatch[1];
+
+    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
+    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
+    // helper (Tier 2 / #4712).
+    const guardIndex = Math.max(
+      queueBlock.indexOf("isAutoActive()"),
+      queueBlock.indexOf("requireNotAutoActive("),
+    );
+    const showQueueIndex = queueBlock.indexOf("showQueue(");
+
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
+    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
+    assert.ok(
+      guardIndex < showQueueIndex,
+      "auto-mode guard appears before showQueue() call",
+    );
+  });
+
+  it("guard shows error message mentioning /gsd stop", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
+    );
+    assert.ok(
+      src.includes("/gsd stop"),
+      "error message mentions /gsd stop as the resolution",
+    );
+  });
+
+  it("guard returns true (handled) to prevent falling through", () => {
+    const src = readFileSync(
+      join(
+        import.meta.dirname,
+        "..",
+        "commands",
+        "handlers",
+        "workflow.ts",
+      ),
+      "utf-8",
+    );
+
+    const queueBlockMatch = src.match(
+      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
+    );
+    assert.ok(queueBlockMatch);
+    const queueBlock = queueBlockMatch[1];
+
+    // The guard block should have its own return true before showQueue
+    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
+    assert.ok(
+      guardBlock.includes("return true"),
+      "guard block returns true before showQueue is reached",
+    );
+  });
+});
+
+// ─── .gsd/audit/ runtime classification regression ──────────────────────────
+
+describe(".gsd/audit/ runtime classification (#4704)", () => {
+  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "gitignore.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
+    );
+  });
+
+  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "git-service.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
+    );
+  });
+
+  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "worktree-manager.ts"),
+      "utf-8",
+    );
+    assert.ok(
+      src.includes('".gsd/audit/"'),
+      ".gsd/audit/ listed in SKIP_PATHS",
+    );
+  });
+});
+
+// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
+
+describe("Windows pre-merge DB release (#4704)", () => {
+  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    // Locate the stash push line and ensure a win32-gated closeDatabase()
+    // call precedes it in the same function scope.
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
+
+    const beforeStash = src.slice(0, stashIndex);
+    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
+    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
+
+    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
+    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
+    assert.ok(
+      win32Index < closeIndex && closeIndex < stashIndex,
+      "platform guard wraps the closeDatabase() call before the stash",
+    );
+  });
+
+  it("openDatabase is called after the stash to reopen the connection", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
+    const afterStash = src.slice(stashIndex);
+    assert.ok(
+      afterStash.includes("openDatabase("),
+      "openDatabase() called after the pre-merge stash",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/queue-draft-detection.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { buildExistingMilestonesContext } from "../guided-flow.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 describe('queue-draft-detection', () => {
   test('draft and context milestone detection', async () => {
@@ -68,7 +69,7 @@ describe('queue-draft-detection', () => {
 
       // both files: CONTEXT.md wins, no draft label
       const m003Idx = context.indexOf("M003:");
-      const m003Section = context.slice(m003Idx, m003Idx + 500);
+      const m003Section = extractSourceRegion(context, "M003:");
       assert.ok(
         m003Section.includes("**Context:**"),
         "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
@@ -84,7 +85,7 @@ describe('queue-draft-detection', () => {
 
       // neither file: no context section
       const m004Idx = context.indexOf("M004:");
-      const m004Section = context.slice(m004Idx, m004Idx + 500);
+      const m004Section = extractSourceRegion(context, "M004:");
       assert.ok(
         !m004Section.includes("**Context:**"),
         "M004 (neither file) should not have Context: label",

package/src/resources/extensions/gsd/tests/queued-discuss-fast-path.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -28,7 +29,7 @@ describe("queued-discuss-fast-path", () => {
     const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
     assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
     const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 2000);
+    const fnBody = extractSourceRegion(source, "async function dispatchDiscussForMilestone(");
     assert.ok(
       fnBody.includes("fastPathInstruction"),
       "dispatchDiscussForMilestone must compute fastPathInstruction",
@@ -61,8 +62,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("hasDraft"),
       "showDiscussQueuedMilestone must check hasDraft",
@@ -81,8 +81,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("let fastPath = hasDraft"),
       "showDiscussQueuedMilestone must set fastPath = hasDraft so draft presence auto-enables fast path",

package/src/resources/extensions/gsd/tests/quick-auto-guard.test.ts

@@ -35,15 +35,20 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
 
     const quickBlock = quickBlockMatch[1];
 
-    // Verify isAutoActive guard comes BEFORE handleQuick call
-    const guardIndex = quickBlock.indexOf("isAutoActive()");
+    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
+    // Accepts either the inline isAutoActive() check (legacy) or the shared
+    // requireNotAutoActive() helper (#4712).
+    const guardIndex = Math.max(
+      quickBlock.indexOf("isAutoActive()"),
+      quickBlock.indexOf("requireNotAutoActive("),
+    );
     const handleQuickIndex = quickBlock.indexOf("handleQuick(");
 
-    assert.ok(guardIndex !== -1, "isAutoActive() guard exists in quick command block");
+    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
     assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
     assert.ok(
       guardIndex < handleQuickIndex,
-      "isAutoActive() guard appears before handleQuick() call",
+      "auto-mode guard appears before handleQuick() call",
     );
   });
 
@@ -59,10 +64,11 @@ describe("/gsd quick auto-mode guard (#2417)", () => {
       "utf-8",
     );
 
-    // The error message should tell the user to stop auto-mode first
+    // The shared helper assembles the message dynamically from the command name,
+    // so assert on the message fragment and the /gsd stop instruction.
     assert.ok(
-      src.includes("/gsd quick cannot run while auto-mode is active"),
-      "error message explains that quick cannot run during auto-mode",
+      src.includes("cannot run while auto-mode is active"),
+      "error message explains that the command cannot run during auto-mode",
     );
     assert.ok(
       src.includes("/gsd stop"),

package/src/resources/extensions/gsd/tests/require-slice-discussion-dispatch.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Regression tests for #3454: auto-dispatch must honour
+ * require_slice_discussion and pause before plan-slice when:
+ *   1. state.phase === "planning"
+ *   2. require_slice_discussion is enabled in preferences
+ *   3. state.activeSlice is non-null
+ *   4. the slice has no CONTEXT file on disk
+ *
+ * Exercises the dispatch rule from DISPATCH_RULES directly with a
+ * DispatchContext built against a real temp directory — no source-string
+ * matching, no brittle rename dependencies.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+// Use a stable token (the preference name) for rule lookup instead of the
+// full human-readable title — copy edits to the rule name will not break
+// these tests as long as the rule still references the preference it gates.
+const RULE_NAME_TOKEN = "require_slice_discussion";
+
+function findRule() {
+  const matches = DISPATCH_RULES.filter(r => r.name.includes(RULE_NAME_TOKEN));
+  if (matches.length !== 1) {
+    throw new Error(`expected exactly one dispatch rule containing "${RULE_NAME_TOKEN}", found ${matches.length}`);
+  }
+  return matches[0];
+}
+
+function buildState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test milestone" },
+    activeSlice: { id: "S01", title: "Test slice" },
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeBasePath(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), `gsd-req-slice-${prefix}-`));
+  mkdirSync(join(dir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  return dir;
+}
+
+function buildCtx(
+  basePath: string,
+  prefs: GSDPreferences | undefined,
+  state: GSDState = buildState(),
+): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Test milestone",
+    state,
+    prefs,
+  };
+}
+
+describe("require_slice_discussion dispatch rule (#3454)", () => {
+  // ─── Positive case: rule fires ────────────────────────────────────────
+
+  test("returns stop action when preference enabled and CONTEXT missing", async () => {
+    const basePath = makeBasePath("fire");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.ok(action, "rule must return a non-null action when pausing is required");
+      assert.strictEqual(action!.action, "stop");
+      if (action!.action === "stop") {
+        assert.match(action!.reason, /S01/);
+        assert.match(action!.reason, /require_slice_discussion/);
+        assert.match(action!.reason, /\/gsd discuss/);
+        assert.strictEqual(action!.level, "info");
+      }
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Negative cases: rule falls through ───────────────────────────────
+
+  test("falls through (null) when preference is disabled", async () => {
+    const basePath = makeBasePath("pref-disabled");
+    try {
+      const prefs = { phases: { require_slice_discussion: false } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when preference is absent / undefined", async () => {
+    const basePath = makeBasePath("pref-absent");
+    try {
+      const action = await findRule().match(buildCtx(basePath, undefined));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when phase is not 'planning'", async () => {
+    const basePath = makeBasePath("wrong-phase");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ phase: "executing" });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("falls through (null) when no active slice", async () => {
+    const basePath = makeBasePath("no-slice");
+    try {
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const state = buildState({ activeSlice: null });
+      const action = await findRule().match(buildCtx(basePath, prefs, state));
+      assert.strictEqual(action, null);
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Context-file present: should not pause ───────────────────────────
+
+  test("falls through (null) when CONTEXT file already exists on disk", async () => {
+    const basePath = makeBasePath("ctx-present");
+    try {
+      // Seed the CONTEXT file that /gsd discuss would have written.
+      const sliceDir = join(basePath, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(join(sliceDir, "S01-CONTEXT.md"), "# Discussion notes\n", "utf-8");
+
+      const prefs = { phases: { require_slice_discussion: true } } as unknown as GSDPreferences;
+      const action = await findRule().match(buildCtx(basePath, prefs));
+      assert.strictEqual(
+        action,
+        null,
+        "once the slice has a CONTEXT file, the rule must fall through so planning proceeds",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  // ─── Rule ordering: must run before the plan-slice rule ──────────────
+
+  test("rule is ordered before the 'planning → plan-slice' rule", () => {
+    const discussIdx = DISPATCH_RULES.findIndex(r => r.name.includes(RULE_NAME_TOKEN));
+    const planIdx = DISPATCH_RULES.findIndex(r => r.name.startsWith("planning → plan-slice"));
+    assert.ok(discussIdx >= 0, "require_slice_discussion rule must be registered");
+    assert.ok(planIdx >= 0, "plan-slice rule must be registered");
+    assert.ok(
+      discussIdx < planIdx,
+      "require_slice_discussion rule must be ordered before plan-slice so it preempts dispatch",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -13,6 +13,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const src = readFileSync(
   resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'guided-flow.ts'),
@@ -37,7 +38,7 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     assert.ok(discussCheck !== -1)
 
     // Look for savedTools assignment within the discuss block
-    const blockAfter = src.slice(discussCheck, discussCheck + 500)
+    const blockAfter = extractSourceRegion(src, 'if (unitType?.startsWith("discuss-"))')
     assert.ok(
       blockAfter.includes('savedTools = currentTools'),
       'savedTools must be assigned from currentTools inside the discuss block',
@@ -55,8 +56,10 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
     assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
-    // After sendMessage, savedTools should be restored via setActiveTools
-    const afterSend = src.slice(sendMsg, sendMsg + 500)
+    // After sendMessage, savedTools should be restored via setActiveTools.
+    // Use fromIdx to anchor at the discuss-flow sendMessage, not the first
+    // triggerTurn: true occurrence in the file.
+    const afterSend = extractSourceRegion(src, 'triggerTurn: true', { fromIdx: savedToolsAssign })
     assert.ok(
       afterSend.includes('if (savedTools)'),
       'savedTools restoration guard must exist after sendMessage',

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);
+  });
+});
+