gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/file-lock.test.ts

@@ -52,7 +52,7 @@ test("withFileLock: executes callback when file does not exist", async () => {
   }
 });
 
-test("withFileLockSync: falls back to unlocked callback on ELOCKED", () => {
+test("withFileLockSync: throws ELOCKED by default (no silent fallback)", () => {
   if (!hasProperLockfile() || process.platform === "win32") {
     return;
   }
@@ -65,19 +65,56 @@ test("withFileLockSync: falls back to unlocked callback on ELOCKED", () => {
   const release = lockfile.lockSync(filePath, { retries: 0, stale: 10000 });
   try {
     let called = 0;
-    const result = withFileLockSync(filePath, () => {
-      called++;
-      return "fallback-ok";
-    });
+    assert.throws(
+      () => {
+        withFileLockSync(
+          filePath,
+          () => {
+            called++;
+            return "should-not-return";
+          },
+          { retries: 0 },
+        );
+      },
+      (err: any) => err?.code === "ELOCKED",
+    );
+    assert.equal(called, 0, "callback must not run when lock cannot be acquired");
+  } finally {
+    release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLockSync: onLocked=\"skip\" runs callback unlocked on ELOCKED", () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = lockfile.lockSync(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = withFileLockSync(
+      filePath,
+      () => {
+        called++;
+        return "fallback-ok";
+      },
+      { retries: 0, onLocked: "skip" },
+    );
     assert.equal(result, "fallback-ok");
-    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+    assert.equal(called, 1, "callback should run when onLocked is skip");
   } finally {
     release();
     rmSync(dir, { recursive: true, force: true });
   }
 });
 
-test("withFileLock: falls back to unlocked callback on ELOCKED", async () => {
+test("withFileLock: throws ELOCKED by default (no silent fallback)", async () => {
   if (!hasProperLockfile() || process.platform === "win32") {
     return;
   }
@@ -90,12 +127,49 @@ test("withFileLock: falls back to unlocked callback on ELOCKED", async () => {
   const release = await lockfile.lock(filePath, { retries: 0, stale: 10000 });
   try {
     let called = 0;
-    const result = await withFileLock(filePath, async () => {
-      called++;
-      return "fallback-ok";
-    });
+    await assert.rejects(
+      async () => {
+        await withFileLock(
+          filePath,
+          async () => {
+            called++;
+            return "should-not-return";
+          },
+          { retries: 0 },
+        );
+      },
+      (err: any) => err?.code === "ELOCKED",
+    );
+    assert.equal(called, 0, "callback must not run when lock cannot be acquired");
+  } finally {
+    await release();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("withFileLock: onLocked=\"skip\" runs callback unlocked on ELOCKED", async () => {
+  if (!hasProperLockfile() || process.platform === "win32") {
+    return;
+  }
+
+  const lockfile = require("proper-lockfile");
+  const dir = mkdtempSync(join(tmpdir(), "gsd-file-lock-test-"));
+  const filePath = join(dir, "locked.jsonl");
+  writeFileSync(filePath, "{}\n", "utf-8");
+
+  const release = await lockfile.lock(filePath, { retries: 0, stale: 10000 });
+  try {
+    let called = 0;
+    const result = await withFileLock(
+      filePath,
+      async () => {
+        called++;
+        return "fallback-ok";
+      },
+      { retries: 0, onLocked: "skip" },
+    );
     assert.equal(result, "fallback-ok");
-    assert.equal(called, 1, "callback should run even when lock acquisition fails");
+    assert.equal(called, 1, "callback should run when onLocked is skip");
   } finally {
     await release();
     rmSync(dir, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/finalize-timeout-guard.test.ts

@@ -26,14 +26,6 @@ import { MAX_FINALIZE_TIMEOUTS } from "../auto/types.ts";
 
 const { assertTrue, assertEq, report } = createTestContext();
 
-function getRunFinalizeBody(phasesSource: string): string {
-  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
-  assertTrue(fnIdx > 0, "runFinalize function should exist in phases.ts");
-
-  const nextExportIdx = phasesSource.indexOf("\nexport ", fnIdx + 1);
-  return phasesSource.slice(fnIdx, nextExportIdx > fnIdx ? nextExportIdx : undefined);
-}
-
 // ═══ Test: withTimeout resolves when inner promise resolves promptly ══════════
 
 {
@@ -142,45 +134,6 @@ function getRunFinalizeBody(phasesSource: string): string {
   assertEq(result.timedOut, false, "should not time out");
 }
 
-// ═══ Test: runFinalize wraps BOTH pre and post verification with withTimeout ═
-
-{
-  console.log("\n=== #3757: runFinalize wraps preVerification with timeout guard ===");
-
-  const { readFileSync } = await import("node:fs");
-  const phasesSource = readFileSync(
-    new URL("../auto/phases.ts", import.meta.url),
-    "utf-8",
-  );
-
-  const fnBody = getRunFinalizeBody(phasesSource);
-
-  // postUnitPreVerification must be wrapped in withTimeout
-  const preTimeoutIdx = fnBody.indexOf("withTimeout(");
-  assertTrue(preTimeoutIdx > 0, "withTimeout should appear in runFinalize");
-
-  const preVerIdx = fnBody.indexOf("postUnitPreVerification");
-  assertTrue(preVerIdx > 0, "postUnitPreVerification should appear in runFinalize");
-
-  // The first withTimeout should wrap postUnitPreVerification (not postUnitPostVerification)
-  const firstWithTimeout = fnBody.slice(preTimeoutIdx, preTimeoutIdx + 200);
-  assertTrue(
-    firstWithTimeout.includes("postUnitPreVerification"),
-    "first withTimeout in runFinalize should wrap postUnitPreVerification",
-  );
-
-  // postUnitPostVerification must also be wrapped
-  const postVerIdx = fnBody.indexOf("postUnitPostVerification");
-  assertTrue(postVerIdx > 0, "postUnitPostVerification should appear in runFinalize");
-
-  // Count withTimeout occurrences — should be at least 2 (pre + post)
-  const timeoutCount = (fnBody.match(/withTimeout\(/g) || []).length;
-  assertTrue(
-    timeoutCount >= 2,
-    `runFinalize should have at least 2 withTimeout guards (found ${timeoutCount})`,
-  );
-}
-
 // ═══ Test: MAX_FINALIZE_TIMEOUTS is defined and reasonable ═══════════════════
 
 {
@@ -200,62 +153,13 @@ function getRunFinalizeBody(phasesSource: string): string {
   );
 }
 
-// ═══ Test: timeout handlers escalate after consecutive timeouts ══════════════
-
-{
-  console.log("\n=== #3757: timeout handlers escalate and detach currentUnit ===");
-
-  const { readFileSync } = await import("node:fs");
-  const phasesSource = readFileSync(
-    new URL("../auto/phases.ts", import.meta.url),
-    "utf-8",
-  );
-
-  const fnBody = getRunFinalizeBody(phasesSource);
-
-  const helperCallCount = (fnBody.match(/failClosedOnFinalizeTimeout\(/g) || []).length;
-  assertTrue(
-    helperCallCount >= 2,
-    `runFinalize should route both timeout branches through failClosedOnFinalizeTimeout (found ${helperCallCount})`,
-  );
-
-  const helperStart = phasesSource.indexOf("async function failClosedOnFinalizeTimeout");
-  assertTrue(helperStart > 0, "failClosedOnFinalizeTimeout helper should exist");
-  const helperEnd = phasesSource.indexOf("// ─── runPreDispatch", helperStart);
-  const helperBody = phasesSource.slice(helperStart, helperEnd > helperStart ? helperEnd : undefined);
-
-  const incrementCount = (helperBody.match(/consecutiveFinalizeTimeouts\+\+/g) || []).length;
-  assertTrue(
-    incrementCount >= 1,
-    `timeout helper should increment consecutiveFinalizeTimeouts (found ${incrementCount})`,
-  );
-
-  const detachCount = (helperBody.match(/s\.currentUnit\s*=\s*null/g) || []).length;
-  assertTrue(
-    detachCount >= 1,
-    `timeout helper should detach s.currentUnit (found ${detachCount})`,
-  );
-
-  const pauseCount = (helperBody.match(/pauseAuto\(/g) || []).length;
-  assertTrue(
-    pauseCount >= 1,
-    `timeout helper should pause auto-mode (found ${pauseCount})`,
-  );
-
-  assertTrue(
-    helperBody.includes('eventType: "unit-end"'),
-    "timeout helper should emit a terminal unit-end event",
-  );
-  assertTrue(
-    helperBody.includes('phase: "finalize-timeout"'),
-    "timeout helper should persist finalize-timeout runtime state",
-  );
-
-  // Successful finalize should reset the counter
-  assertTrue(
-    fnBody.includes("consecutiveFinalizeTimeouts = 0"),
-    "should reset consecutiveFinalizeTimeouts on successful finalize",
-  );
-}
+// Note: the two previous source-grep blocks that scanned phases.ts for
+// `withTimeout(` / `failClosedOnFinalizeTimeout(` occurrences were removed
+// under #4825 — they encoded implementation shape (Goodhart) and broke on
+// any helper/loop refactor without catching a real regression. The intended
+// behavioural invariant (pre+post verification hangs → pauseAuto called,
+// unit-end emitted, escalation counter incremented) should be covered by a
+// runFinalize integration test with mocked hanging verification — tracked
+// separately. Refs #4825.
 
 report();

package/src/resources/extensions/gsd/tests/gate-state-canonicalization.test.ts

@@ -0,0 +1,102 @@
+// GSD Gate State Canonicalization Tests
+// Regression tests for #4950: canonical omitted state and GateVerdict type narrowing.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertGateRow,
+  markAllGatesOmitted,
+  getGateResults,
+  getPendingGates,
+  insertMilestone,
+  insertSlice,
+} from "../gsd-db.ts";
+import type { GateVerdict } from "../types.ts";
+
+describe("gate-state canonicalization (#4950)", () => {
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gate-canon-test-"));
+    dbPath = join(tmpDir, "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Test Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+    });
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("markAllGatesOmitted produces status=complete, verdict=omitted (not status=omitted)", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    markAllGatesOmitted("M001", "S01");
+
+    const all = getGateResults("M001", "S01");
+    assert.equal(all.length, 2);
+    for (const g of all) {
+      assert.equal(g.status, "complete", `expected status=complete for gate ${g.gate_id}`);
+      assert.equal(g.verdict, "omitted", `expected verdict=omitted for gate ${g.gate_id}`);
+    }
+  });
+
+  test("markAllGatesOmitted leaves no pending gates", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    markAllGatesOmitted("M001", "S01");
+
+    const pending = getPendingGates("M001", "S01");
+    assert.equal(pending.length, 0);
+  });
+
+  test("pending gate verdict is null, not empty string", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+
+    const pending = getPendingGates("M001", "S01");
+    assert.equal(pending.length, 1);
+    assert.equal(pending[0].verdict, null, "pending gate verdict must be null, not empty string");
+  });
+
+  test("complete gate verdict round-trips as a valid GateVerdict (pass/flag/omitted only)", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+    markAllGatesOmitted("M001", "S01");
+
+    const results = getGateResults("M001", "S01");
+    const q4 = results.find((g) => g.gate_id === "Q4");
+    assert.ok(q4, "Q4 gate must exist");
+
+    const validVerdicts: GateVerdict[] = ["pass", "flag", "omitted"];
+    assert.ok(
+      q4.verdict !== null && validVerdicts.includes(q4.verdict),
+      `verdict "${q4.verdict}" must be one of: ${validVerdicts.join(", ")}`,
+    );
+  });
+
+  test("empty-string verdict is not reachable after round-trip through DB", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    markAllGatesOmitted("M001", "S01");
+
+    const results = getGateResults("M001", "S01");
+    for (const g of results) {
+      assert.notEqual(g.verdict, "", `gate ${g.gate_id} verdict must not be empty string`);
+    }
+  });
+});

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

@@ -109,7 +109,7 @@ describe("quality_gates CRUD", () => {
     const all = getGateResults("M001", "S01");
     assert.equal(all.length, 3);
     for (const g of all) {
-      assert.equal(g.status, "omitted");
+      assert.equal(g.status, "complete");
       assert.equal(g.verdict, "omitted");
     }
   });

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -85,8 +85,10 @@ test("google-search stub: session_start warning contains package name", async (_
   );
 });
 
-test("google-search stub: session_start warning contains install command", async (_t) => {
-  // STUB-01: warning includes "gsd extensions install"
+test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
+  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
+  // package is not yet on npm, so that command would 404. The message must
+  // explain the extraction is in progress and no user action is required.
   const mod = await import("../../google-search/index.ts");
   const stubFn = mod.default;
 
@@ -115,7 +117,15 @@ test("google-search stub: session_start warning contains install command", async
   await capturedHandler!({}, mockCtx);
 
   assert.ok(
-    capturedMessage?.includes("gsd extensions install"),
-    `Expected message to include "gsd extensions install", got: "${capturedMessage}"`,
+    !capturedMessage?.includes("gsd extensions install"),
+    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("not yet published"),
+    `Expected message to include "not yet published", got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("No action needed"),
+    `Expected message to include "No action needed", got: "${capturedMessage}"`,
   );
 });

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

@@ -0,0 +1,117 @@
+/**
+ * Regression tests for the headless vs interactive milestone-bootstrap divergence.
+ *
+ * Two defects were covered here:
+ *   1. `showHeadlessMilestoneCreation` dispatched with `unitType: "plan-milestone"`
+ *      instead of `"discuss-milestone"`. The `discuss-` prefix drives tool
+ *      scoping (`guided-flow.ts:583`) and enables the `checkAutoStartAfterDiscuss`
+ *      guardrails — routing through `plan-milestone` bypassed them even
+ *      though headless is semantically a discuss flow.
+ *   2. The `discuss-headless.md` ready-phrase pre-condition was a prose
+ *      sentence, so models that treated it as advisory could skip ahead to
+ *      the ready phrase without actually writing the artifacts. The checkbox
+ *      format from `discuss.md` has lower abstraction cost and is harder to
+ *      rationalize past.
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
+const DISCUSS_HEADLESS_PATH = join(__dirname, "..", "prompts", "discuss-headless.md");
+
+function getGuidedFlowSource(): string {
+  return readFileSync(GUIDED_FLOW_PATH, "utf-8");
+}
+
+function getHeadlessPromptSource(): string {
+  return readFileSync(DISCUSS_HEADLESS_PATH, "utf-8");
+}
+
+describe("headless milestone bootstrap — parity with interactive flow", () => {
+  test("showHeadlessMilestoneCreation dispatches as discuss-milestone, not plan-milestone", () => {
+    const source = getGuidedFlowSource();
+    const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
+    assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist");
+
+    // Scope: from the function start to the next top-level export (or EOF).
+    const nextExport = source.indexOf("\nexport ", fnStart + 1);
+    const fnBody = source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
+
+    // Match only the actual dispatchWorkflow call — comments in the body
+    // may mention "plan-milestone" as part of the fix rationale.
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    assert.strictEqual(
+      dispatchMatches.length,
+      1,
+      `expected exactly one dispatchWorkflow call, found ${dispatchMatches.length}`,
+    );
+    assert.strictEqual(
+      dispatchMatches[0][1],
+      "discuss-milestone",
+      `showHeadlessMilestoneCreation must dispatch as "discuss-milestone" so tool scoping and discuss-flow guardrails apply; got "${dispatchMatches[0][1]}"`,
+    );
+  });
+
+  test("discuss-headless single-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const section = source.split("### Multi-Milestone")[0];
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
+      "single-milestone ready-phrase section must be present",
+    );
+    // All four required artifacts must appear as checkboxes, not a prose list.
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`{{contextPath}}`",
+      "`gsd_plan_milestone`",
+    ]) {
+      assert.ok(
+        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        `single-milestone pre-condition must include a checkbox for ${artifact}`,
+      );
+    }
+    assert.ok(
+      /If ANY box is unchecked, \*\*STOP\*\*/.test(section),
+      "single-milestone pre-condition must include the 'If ANY box is unchecked, STOP' sentinel",
+    );
+    assert.ok(
+      /Do not announce the ready phrase as something you are "about to" do/.test(section),
+      "single-milestone pre-condition must include the 'do not announce intent' guard",
+    );
+  });
+
+  test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const multiIdx = source.indexOf("### Multi-Milestone");
+    assert.ok(multiIdx > -1, "multi-milestone section must be present");
+    const multiSection = source.slice(multiIdx);
+
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(multiSection),
+      "multi-milestone ready-phrase section must be present",
+    );
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`gsd_plan_milestone`",
+      "`.gsd/DISCUSSION-MANIFEST.json`",
+    ]) {
+      const escaped = artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      assert.ok(
+        new RegExp(`- \\[ \\] [\\s\\S]*?${escaped}`).test(multiSection),
+        `multi-milestone pre-condition must include a checkbox referencing ${artifact}`,
+      );
+    }
+    assert.ok(
+      /gates_completed === total/.test(multiSection),
+      "multi-milestone pre-condition must still enforce gates_completed === total",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/hook-key-parsing.test.ts

@@ -1,11 +1,5 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
 
 /**
  * Regression tests for #2826: hook/* completed-unit keys were parsed
@@ -15,17 +9,13 @@ const gsdDir = join(__dirname, "..");
  * The root cause: `key.indexOf("/")` splits "hook/telegram-progress/M007/S01"
  * into unitType="hook" + unitId="telegram-progress/M007/S01" instead of
  * unitType="hook/telegram-progress" + unitId="M007/S01".
+ *
+ * These tests exercise the real `splitCompletedKey` helper — the previous
+ * source-grep "does not use indexOf" blocks were dropped under #4825 as
+ * they over-specified implementation shape.
  */
 
 describe("splitCompletedKey (#2826)", () => {
-  it("is exported from forensics.ts", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      source.includes("export function splitCompletedKey"),
-      "forensics.ts must export splitCompletedKey helper",
-    );
-  });
-
   it("splits simple unit types correctly", async () => {
     const { splitCompletedKey } = await import("../forensics.ts");
     const result = splitCompletedKey("execute-task/M007/S01/T01");
@@ -64,44 +54,3 @@ describe("splitCompletedKey (#2826)", () => {
     assert.strictEqual(splitCompletedKey("hook/someName"), null);
   });
 });
-
-describe("forensics detectMissingArtifacts uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    // Extract only the detectMissingArtifacts function body
-    const fnStart = source.indexOf("function detectMissingArtifacts");
-    assert.ok(fnStart !== -1, "detectMissingArtifacts must exist");
-    const fnBody = source.slice(fnStart, source.indexOf("\n}\n", fnStart) + 3);
-
-    assert.ok(
-      !fnBody.includes('key.indexOf("/")'),
-      "detectMissingArtifacts must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      fnBody.includes("splitCompletedKey"),
-      "detectMissingArtifacts must use splitCompletedKey helper",
-    );
-  });
-});
-
-describe("doctor-runtime-checks uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting in orphaned-key check", () => {
-    const source = readFileSync(
-      join(gsdDir, "doctor-runtime-checks.ts"),
-      "utf-8",
-    );
-    // Find the orphaned completed-units section
-    const sectionStart = source.indexOf("Orphaned completed-units");
-    assert.ok(sectionStart !== -1, "orphaned completed-units section must exist");
-    const sectionBody = source.slice(sectionStart, source.indexOf("} catch", sectionStart));
-
-    assert.ok(
-      !sectionBody.includes('key.indexOf("/")'),
-      "doctor orphaned-key check must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      sectionBody.includes("splitCompletedKey"),
-      "doctor orphaned-key check must use splitCompletedKey helper",
-    );
-  });
-});