gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

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",
-    );
-  });
-});

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

@@ -1,162 +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 journal & activity log awareness", () => {
-  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-  const promptSrc = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
-
-  it("scanJournalForForensics reads journal files directly (no full queryJournal load)", () => {
-    // Must NOT use queryJournal which loads ALL entries into memory
-    assert.ok(
-      !forensicsSrc.includes('queryJournal('),
-      "forensics.ts must NOT call queryJournal() which loads all entries at once",
-    );
-    // Must have its own journal scanning with file-level limits
-    assert.ok(
-      forensicsSrc.includes("scanJournalForForensics"),
-      "forensics.ts must have scanJournalForForensics function",
-    );
-  });
-
-  it("journal scanning limits files parsed to avoid memory bloat", () => {
-    assert.ok(
-      forensicsSrc.includes("MAX_JOURNAL_RECENT_FILES"),
-      "must have MAX_JOURNAL_RECENT_FILES constant to limit parsed files",
-    );
-    assert.ok(
-      forensicsSrc.includes("MAX_JOURNAL_RECENT_EVENTS"),
-      "must have MAX_JOURNAL_RECENT_EVENTS constant to limit events extracted",
-    );
-  });
-
-  it("older journal files are line-counted without full JSON parse", () => {
-    assert.ok(
-      forensicsSrc.includes("olderEntryCount") || forensicsSrc.includes("olderFiles"),
-      "must handle older files separately from recent files",
-    );
-  });
-
-  it("ForensicReport includes journalSummary field", () => {
-    assert.ok(
-      forensicsSrc.includes("journalSummary"),
-      "ForensicReport must include journalSummary field",
-    );
-  });
-
-  it("ForensicReport includes activityLogMeta field", () => {
-    assert.ok(
-      forensicsSrc.includes("activityLogMeta"),
-      "ForensicReport must include activityLogMeta field",
-    );
-  });
-
-  it("buildForensicReport calls scanJournalForForensics", () => {
-    assert.ok(
-      forensicsSrc.includes("scanJournalForForensics"),
-      "buildForensicReport must call scanJournalForForensics",
-    );
-  });
-
-  it("buildForensicReport calls gatherActivityLogMeta", () => {
-    assert.ok(
-      forensicsSrc.includes("gatherActivityLogMeta"),
-      "buildForensicReport must call gatherActivityLogMeta",
-    );
-  });
-
-  it("forensics detects journal-based anomalies", () => {
-    assert.ok(
-      forensicsSrc.includes("detectJournalAnomalies"),
-      "forensics.ts must have detectJournalAnomalies function",
-    );
-    // Check for specific journal anomaly types
-    assert.ok(forensicsSrc.includes('"journal-stuck"'), "must detect journal-stuck anomalies");
-    assert.ok(forensicsSrc.includes('"journal-guard-block"'), "must detect journal-guard-block anomalies");
-    assert.ok(forensicsSrc.includes('"journal-rapid-iterations"'), "must detect journal-rapid-iterations anomalies");
-    assert.ok(forensicsSrc.includes('"journal-worktree-failure"'), "must detect journal-worktree-failure anomalies");
-  });
-
-  it("formatReportForPrompt includes journal summary section", () => {
-    assert.ok(
-      forensicsSrc.includes("Journal Summary"),
-      "prompt formatter must include a Journal Summary section",
-    );
-  });
-
-  it("formatReportForPrompt includes activity log overview section", () => {
-    assert.ok(
-      forensicsSrc.includes("Activity Log Overview"),
-      "prompt formatter must include an Activity Log Overview section",
-    );
-  });
-
-  it("activity log scanning uses tail-read with byte cap (not full file load)", () => {
-    // scanActivityLogs uses nativeParseJsonlTail + MAX_JSONL_BYTES for efficient reading
-    assert.ok(
-      forensicsSrc.includes("nativeParseJsonlTail"),
-      "activity log scanning must use nativeParseJsonlTail for tail-reading",
-    );
-    assert.ok(
-      forensicsSrc.includes("MAX_JSONL_BYTES"),
-      "activity log scanning must respect MAX_JSONL_BYTES cap",
-    );
-    // Only reads last 5 files
-    assert.ok(
-      forensicsSrc.includes("slice(-5)"),
-      "activity log scanning must limit to last 5 files",
-    );
-  });
-
-  it("activity log entries are distilled through extractTrace, not sent raw", () => {
-    assert.ok(
-      forensicsSrc.includes("extractTrace("),
-      "activity log entries must be distilled through extractTrace before reporting",
-    );
-  });
-
-  it("prompt output is hard-capped at 30KB", () => {
-    assert.ok(
-      forensicsSrc.includes("MAX_BYTES") && forensicsSrc.includes("30 * 1024"),
-      "formatReportForPrompt must have a 30KB hard cap",
-    );
-    assert.ok(
-      forensicsSrc.includes("truncated at 30KB"),
-      "prompt must show truncation message when capped",
-    );
-  });
-
-  it("forensics prompt documents journal format", () => {
-    assert.ok(
-      promptSrc.includes("### Journal Format"),
-      "forensics.md must document the journal format",
-    );
-    assert.ok(
-      promptSrc.includes("flowId"),
-      "forensics.md must reference flowId concept",
-    );
-    assert.ok(
-      promptSrc.includes("causedBy"),
-      "forensics.md must reference causedBy for causal chains",
-    );
-  });
-
-  it("forensics prompt includes journal directory in runtime path reference", () => {
-    assert.ok(
-      promptSrc.includes("journal/"),
-      "forensics.md runtime path reference must include journal/",
-    );
-  });
-
-  it("investigation protocol references journal data", () => {
-    assert.ok(
-      promptSrc.includes("journal timeline") || promptSrc.includes("journal events"),
-      "investigation protocol must reference journal data for tracing",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/gitignore-bg-shell.test.ts

@@ -1,38 +0,0 @@
-/**
- * Regression test — .bg-shell/ added to BASELINE_PATTERNS in gitignore.ts
- *
- * The bg-shell background process directory was not included in the
- * baseline gitignore patterns, causing it to appear as untracked in
- * git status and potentially be committed.
- *
- * Structural verification test — reads source to confirm .bg-shell/
- * is in BASELINE_PATTERNS.
- */
-
-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, '..', 'gitignore.ts'), 'utf-8');
-
-describe('.bg-shell/ in BASELINE_PATTERNS', () => {
-  test('BASELINE_PATTERNS array is defined', () => {
-    assert.match(source, /const BASELINE_PATTERNS\s*=/,
-      'BASELINE_PATTERNS should be defined');
-  });
-
-  test('.bg-shell/ is included in BASELINE_PATTERNS', () => {
-    // Extract the BASELINE_PATTERNS array content
-    const patternsStart = source.indexOf('BASELINE_PATTERNS');
-    const arrayStart = source.indexOf('[', patternsStart);
-    const arrayEnd = source.indexOf('] as const', arrayStart);
-    const patternsContent = source.slice(arrayStart, arrayEnd);
-    assert.match(patternsContent, /\.bg-shell\//,
-      '.bg-shell/ should be in BASELINE_PATTERNS');
-  });
-});

package/src/resources/extensions/gsd/tests/gsd-no-project-error.test.ts

@@ -1,73 +0,0 @@
-/**
- * GSDNoProjectError — tests for friendly home-directory error handling.
- *
- * Verifies that GSDNoProjectError is thrown for blocked directories and
- * that the dispatcher catches it with a user-friendly message.
- */
-
-import test 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 contextSrc = readFileSync(join(__dirname, "..", "commands", "context.ts"), "utf-8");
-const dispatcherSrc = readFileSync(join(__dirname, "..", "commands", "dispatcher.ts"), "utf-8");
-
-// ─── GSDNoProjectError class ──────────────────────────────────────────────
-
-test("GSDNoProjectError class is exported from context.ts", () => {
-  assert.ok(
-    contextSrc.includes("export class GSDNoProjectError extends Error"),
-    "GSDNoProjectError should be an exported Error subclass",
-  );
-});
-
-test("GSDNoProjectError sets name property", () => {
-  assert.ok(
-    contextSrc.includes('this.name = "GSDNoProjectError"'),
-    "GSDNoProjectError should set its name for instanceof checks",
-  );
-});
-
-// ─── projectRoot blocked directory handling ───────────────────────────────
-
-test("projectRoot uses validateDirectory and checks for blocked severity", () => {
-  assert.ok(
-    contextSrc.includes("validateDirectory(pathToCheck)"),
-    "projectRoot should call validateDirectory",
-  );
-  assert.ok(
-    contextSrc.includes('result.severity === "blocked"'),
-    "projectRoot should check for blocked severity",
-  );
-});
-
-test("projectRoot throws GSDNoProjectError on blocked directory", () => {
-  assert.ok(
-    contextSrc.includes("throw new GSDNoProjectError"),
-    "projectRoot should throw GSDNoProjectError when directory is blocked",
-  );
-});
-
-// ─── Dispatcher catch ─────────────────────────────────────────────────────
-
-test("dispatcher catches GSDNoProjectError with user-friendly message", () => {
-  assert.ok(
-    dispatcherSrc.includes("err instanceof GSDNoProjectError"),
-    "dispatcher should catch GSDNoProjectError specifically",
-  );
-  assert.ok(
-    dispatcherSrc.includes("cd"),
-    "error message should suggest cd-ing into a project directory",
-  );
-});
-
-test("dispatcher re-throws non-GSDNoProjectError exceptions", () => {
-  assert.ok(
-    dispatcherSrc.includes("throw err"),
-    "dispatcher should re-throw unexpected errors",
-  );
-});

package/src/resources/extensions/gsd/tests/idle-watchdog-stall-override.test.ts

@@ -1,125 +0,0 @@
-/**
- * Regression tests for #2527: idle watchdog stalled-tool detection.
- *
- * Bug 1: When a tool is stalled longer than idle_timeout, the watchdog
- * notifies but falls through to detectWorkingTreeActivity(), which
- * resets lastProgressAt if files were modified earlier. Recovery is
- * never called — the session burns tokens indefinitely.
- *
- * Bug 2: After async recoverTimedOutUnit(), pauseAuto/stopAuto may set
- * s.currentUnit = null, but the next line accesses .startedAt — crash.
- *
- * These tests verify the auto-timers.ts source contains the structural
- * fixes: the stalledToolDetected flag, clearInFlightTools() call, the
- * filesystem-check guard, and the null guard after recovery.
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-
-const TIMERS_SRC = readFileSync(
-  join(import.meta.dirname, "..", "auto-timers.ts"),
-  "utf-8",
-);
-
-// ═══ Bug 1: stalledToolDetected flag prevents filesystem-activity override ═══
-
-describe("#2527 Bug 1: stalled tool should not be overridden by filesystem activity", () => {
-  test("auto-timers.ts imports clearInFlightTools", () => {
-    assert.ok(
-      TIMERS_SRC.includes("clearInFlightTools"),
-      "clearInFlightTools must be imported from auto-tool-tracking",
-    );
-  });
-
-  test("auto-timers.ts declares stalledToolDetected flag", () => {
-    assert.ok(
-      TIMERS_SRC.includes("stalledToolDetected"),
-      "stalledToolDetected flag must exist in idle watchdog",
-    );
-  });
-
-  test("stalled tool sets flag to true", () => {
-    // The flag must be set before the filesystem check
-    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    assert.ok(flagSet > -1, "stalledToolDetected must be set to true when tool is stalled");
-
-    const notify = TIMERS_SRC.indexOf("Stalled tool detected:");
-    assert.ok(flagSet < notify, "flag must be set before the stall notification");
-  });
-
-  test("stalled tool calls clearInFlightTools", () => {
-    // clearInFlightTools() must be called when tool is stalled, so subsequent
-    // watchdog ticks don't re-detect the same stale entries
-    const clearCall = TIMERS_SRC.indexOf("clearInFlightTools()");
-    assert.ok(clearCall > -1, "clearInFlightTools() must be called when tool is stalled");
-
-    const flagSet = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    assert.ok(
-      Math.abs(clearCall - flagSet) < 200,
-      "clearInFlightTools() should be near stalledToolDetected = true",
-    );
-  });
-
-  test("filesystem-activity check is guarded by stalledToolDetected", () => {
-    // The detectWorkingTreeActivity check must be skipped when stalledToolDetected is true
-    assert.ok(
-      TIMERS_SRC.includes("!stalledToolDetected && detectWorkingTreeActivity"),
-      "detectWorkingTreeActivity must be guarded by !stalledToolDetected",
-    );
-  });
-
-  test("control flow: stalled tool → skip filesystem check → reach recovery", () => {
-    // Verify the structural ordering: flag declaration → stall block → guarded fs check → recovery
-    const flagDecl = TIMERS_SRC.indexOf("let stalledToolDetected = false");
-    const stallBlock = TIMERS_SRC.indexOf("stalledToolDetected = true");
-    const fsGuard = TIMERS_SRC.indexOf("!stalledToolDetected && detectWorkingTreeActivity");
-    const recovery = TIMERS_SRC.indexOf("recoverTimedOutUnit(ctx, pi, unitType, unitId, \"idle\"");
-
-    assert.ok(flagDecl > -1, "flag declaration must exist");
-    assert.ok(flagDecl < stallBlock, "flag declared before stall block");
-    assert.ok(stallBlock < fsGuard, "stall block before filesystem guard");
-    assert.ok(fsGuard < recovery, "filesystem guard before recovery call");
-  });
-});
-
-// ═══ Bug 2: null guard after async recoverTimedOutUnit ═══════════════════════
-
-describe("#2527 Bug 2: null guard after async recovery prevents crash", () => {
-  test("idle watchdog has null guard after recoverTimedOutUnit", () => {
-    // Find the idle recovery call
-    const idleRecovery = TIMERS_SRC.indexOf(
-      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
-    );
-    assert.ok(idleRecovery > -1, "idle recovery call must exist");
-
-    // The null guard must appear between the recovery call and the next
-    // writeUnitRuntimeRecord that accesses s.currentUnit.startedAt
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery, idleRecovery + 400);
-    assert.ok(
-      afterRecovery.includes("if (!s.currentUnit) return"),
-      "null guard for s.currentUnit must exist after idle recoverTimedOutUnit",
-    );
-  });
-
-  test("null guard is between recovery and writeUnitRuntimeRecord", () => {
-    const idleRecovery = TIMERS_SRC.indexOf(
-      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
-    );
-    const afterRecovery = TIMERS_SRC.slice(idleRecovery);
-
-    const recoveredReturn = afterRecovery.indexOf('if (recovery === "recovered") return');
-    const nullGuard = afterRecovery.indexOf("if (!s.currentUnit) return");
-    const writeRecord = afterRecovery.indexOf("writeUnitRuntimeRecord(s.basePath");
-
-    assert.ok(recoveredReturn > -1, "recovered return must exist");
-    assert.ok(nullGuard > -1, "null guard must exist");
-    assert.ok(writeRecord > -1, "writeUnitRuntimeRecord must exist after recovery");
-    assert.ok(
-      recoveredReturn < nullGuard && nullGuard < writeRecord,
-      "order must be: recovered-return → null-guard → writeUnitRuntimeRecord",
-    );
-  });
-});