gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/dashboard-model-label-ordering.test.ts

@@ -1,107 +0,0 @@
-/**
- * dashboard-model-label-ordering.test.ts — Regression test for #2899.
- *
- * The dashboard model label was showing the previous unit's model because
- * updateProgressWidget was called before selectAndApplyModel in phases.ts.
- * This test verifies:
- *   1. updateProgressWidget is called AFTER selectAndApplyModel in phases.ts
- *   2. session.ts has a currentDispatchedModelId field
- *   3. auto.ts exposes getCurrentDispatchedModelId in widgetStateAccessors
- *   4. auto-dashboard.ts reads from a dispatched model accessor, not cmdCtx?.model
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertTrue, assertMatch, report } = createTestContext();
-
-const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
-const sessionPath = join(import.meta.dirname, "..", "auto", "session.ts");
-const autoPath = join(import.meta.dirname, "..", "auto.ts");
-const dashboardPath = join(import.meta.dirname, "..", "auto-dashboard.ts");
-
-const phasesSrc = readFileSync(phasesPath, "utf-8");
-const sessionSrc = readFileSync(sessionPath, "utf-8");
-const autoSrc = readFileSync(autoPath, "utf-8");
-const dashboardSrc = readFileSync(dashboardPath, "utf-8");
-
-console.log("\n=== #2899: Dashboard model label shows correct (dispatched) model ===");
-
-// ── Test 1: updateProgressWidget is called AFTER selectAndApplyModel ──────
-
-// Find the positions of the calls in the dispatch function body.
-// selectAndApplyModel must appear BEFORE updateProgressWidget.
-const selectModelPos = phasesSrc.indexOf("deps.selectAndApplyModel(");
-const updateWidgetPos = phasesSrc.indexOf("deps.updateProgressWidget(");
-
-assertTrue(
-  selectModelPos > 0,
-  "phases.ts contains deps.selectAndApplyModel call",
-);
-
-assertTrue(
-  updateWidgetPos > 0,
-  "phases.ts contains deps.updateProgressWidget call",
-);
-
-assertTrue(
-  selectModelPos < updateWidgetPos,
-  `selectAndApplyModel (pos ${selectModelPos}) must be called BEFORE updateProgressWidget (pos ${updateWidgetPos}) — widget needs fresh model`,
-);
-
-// ── Test 2: session.ts declares currentDispatchedModelId ──────────────────
-
-assertTrue(
-  sessionSrc.includes("currentDispatchedModelId"),
-  "session.ts has currentDispatchedModelId field",
-);
-
-// ── Test 3: auto.ts exposes getCurrentDispatchedModelId in widgetStateAccessors ──
-
-assertTrue(
-  autoSrc.includes("getCurrentDispatchedModelId"),
-  "auto.ts exposes getCurrentDispatchedModelId accessor",
-);
-
-// Verify it's in the widgetStateAccessors object
-const accessorsBlock = autoSrc.slice(
-  autoSrc.indexOf("const widgetStateAccessors"),
-  autoSrc.indexOf("};", autoSrc.indexOf("const widgetStateAccessors")) + 2,
-);
-
-assertTrue(
-  accessorsBlock.includes("getCurrentDispatchedModelId"),
-  "getCurrentDispatchedModelId is in the widgetStateAccessors object",
-);
-
-// ── Test 4: WidgetStateAccessors interface has getCurrentDispatchedModelId ──
-
-assertTrue(
-  dashboardSrc.includes("getCurrentDispatchedModelId"),
-  "auto-dashboard.ts references getCurrentDispatchedModelId",
-);
-
-// The dashboard render closure should NOT read model from cmdCtx?.model for display.
-// It should use the accessor for the dispatched model ID.
-// Check that the "Model display" section uses the accessor, not cmdCtx?.model directly.
-const modelDisplaySection = dashboardSrc.slice(
-  dashboardSrc.indexOf("// Model display"),
-  dashboardSrc.indexOf("// Model display") + 500,
-);
-
-assertTrue(
-  modelDisplaySection.includes("getCurrentDispatchedModelId") ||
-  modelDisplaySection.includes("getDispatchedModelId"),
-  "Model display section reads from dispatched model accessor, not cmdCtx?.model alone",
-);
-
-// ── Test 5: currentDispatchedModelId is set after selectAndApplyModel in phases.ts ──
-
-// After selectAndApplyModel returns, phases.ts should store the dispatched model ID
-assertTrue(
-  phasesSrc.includes("currentDispatchedModelId"),
-  "phases.ts stores currentDispatchedModelId after model selection",
-);
-
-report();

package/src/resources/extensions/gsd/tests/find-missing-summaries-closed.test.ts

@@ -1,48 +0,0 @@
-/**
- * Regression test for #3669 — findMissingSummaries skips closed slices
- *
- * When a slice has status "skipped", "complete", or "done", it should be
- * excluded from the missing-summary check because closed slices intentionally
- * lack SUMMARY files (or their DB status is authoritative).
- *
- * This is a structural verification test — it reads the source to confirm the
- * CLOSED_STATUSES guard exists at the filter site.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'auto-dispatch.ts'), 'utf-8');
-
-describe('findMissingSummaries closed-status exclusion (#3669)', () => {
-  test('CLOSED_STATUSES set includes skipped, complete, and done', () => {
-    // The source must define a CLOSED_STATUSES set with all three statuses
-    assert.match(source, /CLOSED_STATUSES.*=.*new Set\(/,
-      'CLOSED_STATUSES set should be defined');
-    assert.match(source, /"skipped"/, 'CLOSED_STATUSES should include "skipped"');
-    assert.match(source, /"complete"/, 'CLOSED_STATUSES should include "complete"');
-    assert.match(source, /"done"/, 'CLOSED_STATUSES should include "done"');
-  });
-
-  test('filter uses CLOSED_STATUSES.has() to exclude closed slices', () => {
-    assert.match(source, /CLOSED_STATUSES\.has\(s\.status\)/,
-      'filter should call CLOSED_STATUSES.has(s.status)');
-  });
-
-  test('findMissingSummaries function exists', () => {
-    assert.match(source, /function findMissingSummaries\(/,
-      'findMissingSummaries function should be defined');
-  });
-
-  test('filter is negated (excludes closed, keeps open)', () => {
-    // The filter should use !CLOSED_STATUSES.has() to exclude closed slices
-    assert.match(source, /!CLOSED_STATUSES\.has\(s\.status\)/,
-      'filter should negate CLOSED_STATUSES.has() to exclude closed slices');
-  });
-});

package/src/resources/extensions/gsd/tests/forensics-context-persist.test.ts

@@ -1,159 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } 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, "..");
-
-/**
- * Test suite for #2941: Forensics report context lost on follow-up turns.
- *
- * The forensics flow sends a one-shot message via sendMessage() with
- * triggerTurn: true. On follow-up turns, the context is gone because
- * there's no re-injection mechanism like buildGuidedExecuteContextInjection
- * provides for task execution.
- *
- * Fix: write an active-forensics.json marker when forensics starts, and
- * have buildBeforeAgentStartResult() re-inject the forensics prompt on
- * subsequent turns.
- */
-
-describe("forensics context persistence (#2941)", () => {
-  // ─── Source-level invariant tests ──────────────────────────────────────────
-
-  it("forensics.ts writes active-forensics marker after saving report", () => {
-    const src = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      src.includes("active-forensics.json"),
-      "forensics.ts must reference active-forensics.json marker file",
-    );
-    assert.ok(
-      src.includes("writeForensicsMarker"),
-      "forensics.ts must call writeForensicsMarker to persist session state",
-    );
-  });
-
-  it("system-context.ts checks for active forensics marker in buildBeforeAgentStartResult", () => {
-    const src = readFileSync(join(gsdDir, "bootstrap", "system-context.ts"), "utf-8");
-    assert.ok(
-      src.includes("active-forensics.json"),
-      "system-context.ts must check for active-forensics.json marker",
-    );
-    assert.ok(
-      src.includes("gsd-forensics"),
-      "system-context.ts must inject gsd-forensics customType message",
-    );
-  });
-
-  it("system-context.ts exports clearForensicsMarker for cleanup", () => {
-    const src = readFileSync(join(gsdDir, "bootstrap", "system-context.ts"), "utf-8");
-    assert.ok(
-      src.includes("clearForensicsMarker"),
-      "system-context.ts must export clearForensicsMarker function",
-    );
-  });
-
-  // ─── Functional tests using temp directories ──────────────────────────────
-
-  const tmpBase = join(__dirname, "__tmp_forensics_persist__");
-
-  beforeEach(() => {
-    rmSync(tmpBase, { recursive: true, force: true });
-    mkdirSync(join(tmpBase, ".gsd", "runtime"), { recursive: true });
-    mkdirSync(join(tmpBase, ".gsd", "forensics"), { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(tmpBase, { recursive: true, force: true });
-  });
-
-  it("writeForensicsMarker creates marker with reportPath and promptContent", async () => {
-    const { writeForensicsMarker } = await import("../forensics.ts");
-
-    const reportPath = join(tmpBase, ".gsd", "forensics", "report-2026-01-01.md");
-    writeFileSync(reportPath, "# Test Report", "utf-8");
-
-    writeForensicsMarker(tmpBase, reportPath, "Test forensics prompt content");
-
-    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
-    assert.ok(existsSync(markerPath), "marker file must be created");
-
-    const marker = JSON.parse(readFileSync(markerPath, "utf-8"));
-    assert.equal(marker.reportPath, reportPath);
-    assert.equal(marker.promptContent, "Test forensics prompt content");
-    assert.ok(marker.createdAt, "marker must have createdAt timestamp");
-  });
-
-  it("readForensicsMarker returns null when no marker exists", async () => {
-    const { readForensicsMarker } = await import("../forensics.ts");
-
-    const result = readForensicsMarker(join(tmpBase, "nonexistent"));
-    assert.equal(result, null);
-  });
-
-  it("readForensicsMarker returns marker data when file exists", async () => {
-    const { readForensicsMarker } = await import("../forensics.ts");
-
-    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
-    const markerData = {
-      reportPath: "/some/report.md",
-      promptContent: "forensics prompt",
-      createdAt: new Date().toISOString(),
-    };
-    writeFileSync(markerPath, JSON.stringify(markerData), "utf-8");
-
-    const result = readForensicsMarker(tmpBase);
-    assert.ok(result);
-    assert.equal(result.reportPath, "/some/report.md");
-    assert.equal(result.promptContent, "forensics prompt");
-  });
-
-  it("clearForensicsMarker removes the marker file", async () => {
-    const { clearForensicsMarker } = await import("../bootstrap/system-context.ts");
-
-    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
-    writeFileSync(markerPath, JSON.stringify({ reportPath: "/x", promptContent: "y", createdAt: new Date().toISOString() }), "utf-8");
-    assert.ok(existsSync(markerPath), "precondition: marker must exist");
-
-    clearForensicsMarker(tmpBase);
-    assert.ok(!existsSync(markerPath), "marker must be removed after clear");
-  });
-
-  it("clearForensicsMarker is a no-op when no marker exists", async () => {
-    const { clearForensicsMarker } = await import("../bootstrap/system-context.ts");
-    // Should not throw
-    clearForensicsMarker(join(tmpBase, "nonexistent"));
-  });
-
-  it("buildForensicsContextInjection keeps marker for low-entropy resume prompts", async () => {
-    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
-
-    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
-    writeFileSync(markerPath, JSON.stringify({
-      reportPath: "/some/report.md",
-      promptContent: "forensics prompt",
-      createdAt: new Date().toISOString(),
-    }), "utf-8");
-
-    const result = buildForensicsContextInjection(tmpBase, "continue");
-    assert.equal(result, "forensics prompt");
-    assert.ok(existsSync(markerPath), "resume-like follow-up should keep marker intact");
-  });
-
-  it("buildForensicsContextInjection clears marker on unrelated user prompts", async () => {
-    const { buildForensicsContextInjection } = await import("../bootstrap/system-context.ts");
-
-    const markerPath = join(tmpBase, ".gsd", "runtime", "active-forensics.json");
-    writeFileSync(markerPath, JSON.stringify({
-      reportPath: "/some/report.md",
-      promptContent: "forensics prompt",
-      createdAt: new Date().toISOString(),
-    }), "utf-8");
-
-    const result = buildForensicsContextInjection(tmpBase, "please summarize the README");
-    assert.equal(result, null);
-    assert.ok(!existsSync(markerPath), "unrelated follow-up should clear the stale marker");
-  });
-});

package/src/resources/extensions/gsd/tests/forensics-db-completion.test.ts

@@ -1,96 +0,0 @@
-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, "..");
-
-/**
- * Tests for #3129: forensics reads DB for completion status instead of legacy file.
- *
- * The old loadCompletedKeys() reads completed-units.json which is never populated
- * during normal auto-mode completion. The DB (milestones/slices/tasks tables) is
- * the authoritative source for completion status.
- */
-describe("forensics DB completion status (#3129)", () => {
-  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-  const stateSrc = readFileSync(join(gsdDir, "state.ts"), "utf-8");
-
-  // ── Primary fix: forensics queries DB for completion counts ──────────
-
-  it("ForensicReport has dbCompletionCounts field for DB-sourced completion data", () => {
-    assert.ok(
-      forensicsSrc.includes("dbCompletionCounts"),
-      "ForensicReport must include dbCompletionCounts field for DB-sourced completion data",
-    );
-  });
-
-  it("buildForensicReport queries DB for completed milestones, slices, and tasks", () => {
-    assert.ok(
-      forensicsSrc.includes("getDbCompletionCounts"),
-      "buildForensicReport must call getDbCompletionCounts to query DB completion status",
-    );
-  });
-
-  it("getDbCompletionCounts checks isDbAvailable before querying", () => {
-    assert.ok(
-      forensicsSrc.includes("isDbAvailable"),
-      "getDbCompletionCounts must check isDbAvailable() before querying the DB",
-    );
-  });
-
-  it("getDbCompletionCounts queries getAllMilestones for milestone completion", () => {
-    assert.ok(
-      forensicsSrc.includes("getAllMilestones"),
-      "getDbCompletionCounts must use getAllMilestones() to count completed milestones",
-    );
-  });
-
-  it("completion counting uses isClosedStatus for consistent status checks", () => {
-    assert.ok(
-      forensicsSrc.includes("isClosedStatus"),
-      "forensics must use isClosedStatus() for consistent status checks",
-    );
-  });
-
-  it("report rendering shows DB completion counts instead of just legacy key count", () => {
-    assert.ok(
-      forensicsSrc.includes("milestones complete"),
-      "report must show '__ milestones complete' from DB data",
-    );
-    assert.ok(
-      forensicsSrc.includes("slices complete"),
-      "report must show '__ slices complete' from DB data",
-    );
-    assert.ok(
-      forensicsSrc.includes("tasks complete"),
-      "report must show '__ tasks complete' from DB data",
-    );
-  });
-
-  it("falls back to completed-units.json only when DB is unavailable", () => {
-    // loadCompletedKeys should still exist as fallback
-    assert.ok(
-      forensicsSrc.includes("loadCompletedKeys"),
-      "loadCompletedKeys must still exist as fallback for non-DB projects",
-    );
-    // But the report should prefer DB counts
-    assert.ok(
-      forensicsSrc.includes("dbCompletionCounts"),
-      "report must prefer dbCompletionCounts over legacy completedKeys",
-    );
-  });
-
-  // ── Secondary fix: STATE.md label when all milestones complete ───────
-
-  it("state.ts returns null activeMilestone when all milestones are complete", () => {
-    // When phase is "complete", activeMilestone should be null, not the last milestone
-    // The last completed milestone should be in a separate field
-    assert.ok(
-      stateSrc.includes("lastCompletedMilestone"),
-      "GSDState must have lastCompletedMilestone field for the final milestone when phase=complete",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/forensics-dedup.test.ts

@@ -1,79 +0,0 @@
-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, "..");
-
-describe("forensics dedup (#2096)", () => {
-  it("forensics_dedup is in KNOWN_PREFERENCE_KEYS", () => {
-    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
-    assert.ok(source.includes('"forensics_dedup"'),
-      "KNOWN_PREFERENCE_KEYS must contain forensics_dedup");
-    assert.ok(source.includes("forensics_dedup?: boolean"),
-      "GSDPreferences must declare forensics_dedup as optional boolean");
-  });
-
-  it("forensics prompt contains {{dedupSection}} placeholder", () => {
-    const prompt = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
-    assert.ok(prompt.includes("{{dedupSection}}"),
-      "forensics.md must contain {{dedupSection}} placeholder");
-  });
-
-  it("DEDUP_PROMPT_SECTION contains required search commands", async () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(source.includes("DEDUP_PROMPT_SECTION"), "forensics.ts must define DEDUP_PROMPT_SECTION");
-    assert.ok(source.includes("gh issue list --repo gsd-build/gsd-2 --state closed"));
-    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state open"));
-    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state merged"));
-  });
-
-  it("handleForensics checks forensics_dedup preference", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(source.includes("forensics_dedup"),
-      "handleForensics must reference forensics_dedup preference");
-    assert.ok(source.includes("dedupSection"),
-      "handleForensics must pass dedupSection to loadPrompt");
-  });
-
-  it("first-time opt-in shows when preference is undefined", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(source.includes("=== undefined"),
-      "first-time detection must check for undefined (not false)");
-    assert.ok(source.includes("Duplicate detection available") || source.includes("duplicate detection"),
-      "opt-in notice must mention duplicate detection");
-  });
-});
-
-describe("forensics dedup ordering (#2704)", () => {
-  it("{{dedupSection}} appears before Investigation Protocol in the prompt template", () => {
-    const prompt = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
-    const dedupIndex = prompt.indexOf("{{dedupSection}}");
-    const investigationIndex = prompt.indexOf("## Investigation Protocol");
-    assert.ok(dedupIndex !== -1, "prompt must contain {{dedupSection}}");
-    assert.ok(investigationIndex !== -1, "prompt must contain ## Investigation Protocol");
-    assert.ok(
-      dedupIndex < investigationIndex,
-      `{{dedupSection}} (index ${dedupIndex}) must appear before Investigation Protocol (index ${investigationIndex}) — dedup should run before expensive investigation to avoid wasting tokens on already-fixed bugs`,
-    );
-  });
-
-  it("DEDUP_PROMPT_SECTION contains a decision gate to skip investigation", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    // The dedup section must instruct the agent to skip investigation when a match is found
-    assert.ok(
-      source.includes("Skip full investigation") || source.includes("skip full investigation") || source.includes("Skip investigation"),
-      "DEDUP_PROMPT_SECTION must contain a decision gate telling the agent to skip full investigation when a duplicate is found",
-    );
-  });
-
-  it("DEDUP_PROMPT_SECTION heading reflects pre-investigation role", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      source.includes("Pre-Investigation") || source.includes("pre-investigation"),
-      "DEDUP_PROMPT_SECTION heading must indicate it runs before investigation, not just before issue creation",
-    );
-  });
-});

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

@@ -1,74 +0,0 @@
-/**
- * Regression test for #2826: detectMissingArtifacts must parse hook/
- * compound unit types correctly, not just the first slash segment.
- *
- * Keys like "hook/telegram-progress/M007/S01" must yield:
- *   unitType = "hook/telegram-progress"  (not "hook")
- *   unitId   = "M007/S01"               (not "telegram-progress/M007/S01")
- *
- * The fix extracts a shared splitCompletedKey() helper used by both
- * forensics.ts and doctor-runtime-checks.ts.
- */
-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, "..");
-
-describe("forensics hook compound key parsing (#2826)", () => {
-  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-  const doctorSrc = readFileSync(join(gsdDir, "doctor-runtime-checks.ts"), "utf-8");
-
-  it("forensics.ts exports splitCompletedKey helper", () => {
-    assert.ok(
-      forensicsSrc.includes("export function splitCompletedKey("),
-      "forensics.ts must export splitCompletedKey()",
-    );
-  });
-
-  it("splitCompletedKey handles hook/ prefix by splitting on the second slash", () => {
-    assert.ok(
-      forensicsSrc.includes('key.startsWith("hook/")'),
-      'splitCompletedKey must branch on key.startsWith("hook/")',
-    );
-    assert.ok(
-      forensicsSrc.includes('key.indexOf("/", 5)'),
-      'splitCompletedKey must use indexOf("/", 5) to find second slash past "hook/"',
-    );
-  });
-
-  it("detectMissingArtifacts delegates to splitCompletedKey", () => {
-    const fnStart = forensicsSrc.indexOf("function detectMissingArtifacts(");
-    assert.ok(fnStart !== -1, "detectMissingArtifacts must exist in forensics.ts");
-    const fnBody = forensicsSrc.slice(fnStart, fnStart + 1000);
-    assert.ok(
-      fnBody.includes("splitCompletedKey("),
-      "detectMissingArtifacts must call splitCompletedKey() rather than inline the split logic",
-    );
-  });
-
-  it("doctor-runtime-checks.ts imports and uses splitCompletedKey", () => {
-    assert.ok(
-      doctorSrc.includes('from "./forensics.js"'),
-      'doctor-runtime-checks.ts must import from "./forensics.js"',
-    );
-    assert.ok(
-      doctorSrc.includes("splitCompletedKey"),
-      "doctor-runtime-checks.ts must use splitCompletedKey()",
-    );
-  });
-
-  it("splitCompletedKey unit: plain type", () => {
-    // Inline test of the helper logic to guard against future regressions
-    // without needing a filesystem setup.
-    const src = forensicsSrc;
-    // Confirm the plain-type branch also exists
-    assert.ok(
-      src.includes('slashIdx = key.indexOf("/")') || src.includes("key.indexOf(\"/\")"),
-      "splitCompletedKey must handle plain (non-hook) keys via first-slash split",
-    );
-  });
-});