gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

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/forensics-worktree-telemetry.test.ts

@@ -1,145 +0,0 @@
-/**
- * Tests for the #4764 forensics integration — verifies that
- * buildForensicReport picks up worktree telemetry aggregates and emits
- * anomalies for orphans and auto-exits with unmerged work.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync, mkdirSync, rmSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
-
-import {
-  emitWorktreeOrphaned,
-  emitAutoExit,
-  emitWorktreeCreated,
-  emitWorktreeMerged,
-} from "../worktree-telemetry.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
-
-function makeTmpBase(): string {
-  const base = join(tmpdir(), `gsd-for-tel-test-${randomUUID()}`);
-  mkdirSync(join(base, ".gsd"), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
-}
-
-describe("#4764 forensics + worktree telemetry integration", () => {
-  const forensicsSrc = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-
-  it("forensics.ts imports the telemetry summarizer", () => {
-    assert.ok(
-      forensicsSrc.includes("summarizeWorktreeTelemetry"),
-      "forensics must consume the telemetry aggregator",
-    );
-  });
-
-  it("forensics.ts does NOT call queryJournal directly (memory guard)", () => {
-    // The same invariant guarded by forensics-journal.test.ts — re-asserted
-    // here so this feature change doesn't regress it.
-    assert.ok(
-      !forensicsSrc.includes("queryJournal("),
-      "forensics.ts must route journal reads through aggregators, not queryJournal",
-    );
-  });
-
-  it("ForensicReport includes worktreeTelemetry field", () => {
-    assert.ok(
-      forensicsSrc.includes("worktreeTelemetry"),
-      "report shape must include the telemetry summary",
-    );
-  });
-
-  it("formatReportForPrompt gates Worktree Telemetry section on signal", () => {
-    assert.ok(
-      forensicsSrc.includes("Worktree Telemetry"),
-      "prompt formatter must include a Worktree Telemetry section",
-    );
-  });
-
-  it("new anomaly types worktree-orphan and worktree-unmerged-exit exist on the union", () => {
-    assert.ok(forensicsSrc.includes('"worktree-orphan"'));
-    assert.ok(forensicsSrc.includes('"worktree-unmerged-exit"'));
-  });
-
-  it("buildForensicReport surfaces worktree-orphan anomaly when the journal shows an in-progress orphan", async () => {
-    const base = makeTmpBase();
-    try {
-      // Seed the journal with one in-progress orphan event
-      emitWorktreeOrphaned(base, "M001", {
-        reason: "in-progress-unmerged",
-        commitsAhead: 3,
-        worktreeDirExists: true,
-      });
-
-      const { buildForensicReport } = await import("../forensics.ts");
-      const report = await buildForensicReport(base);
-
-      const orphanAnomalies = report.anomalies.filter(a => a.type === "worktree-orphan");
-      assert.ok(orphanAnomalies.length >= 1, `expected a worktree-orphan anomaly; got ${JSON.stringify(report.anomalies.map(a => a.type))}`);
-      assert.equal(orphanAnomalies[0].severity, "warning", "in-progress orphan should be a warning");
-
-      // Aggregate fields surface in the telemetry summary
-      assert.ok(report.worktreeTelemetry, "report should carry the telemetry summary");
-      assert.equal(report.worktreeTelemetry!.orphansDetected, 1);
-      assert.equal(report.worktreeTelemetry!.orphansByReason["in-progress-unmerged"], 1);
-    } finally { cleanup(base); }
-  });
-
-  it("buildForensicReport surfaces worktree-unmerged-exit anomaly when auto-exit left work unmerged", async () => {
-    const base = makeTmpBase();
-    try {
-      emitAutoExit(base, { reason: "pause", milestoneId: "M002", milestoneMerged: false });
-      emitAutoExit(base, { reason: "stop", milestoneId: "M002", milestoneMerged: false });
-      emitAutoExit(base, { reason: "all-complete", milestoneId: "M001", milestoneMerged: true });
-
-      const { buildForensicReport } = await import("../forensics.ts");
-      const report = await buildForensicReport(base);
-
-      const unmergedExitAnomalies = report.anomalies.filter(a => a.type === "worktree-unmerged-exit");
-      assert.equal(unmergedExitAnomalies.length, 1, "exactly one aggregate unmerged-exit anomaly");
-      assert.equal(unmergedExitAnomalies[0].severity, "warning");
-      assert.ok(
-        unmergedExitAnomalies[0].summary.includes("2"),
-        "summary should mention the count (2 unmerged exits out of 3 total)",
-      );
-
-      assert.equal(report.worktreeTelemetry!.exitsWithUnmergedWork, 2);
-    } finally { cleanup(base); }
-  });
-
-  it("buildForensicReport emits no telemetry anomalies when there are no signals", async () => {
-    const base = makeTmpBase();
-    try {
-      // Healthy path — worktree created and merged without incident
-      emitWorktreeCreated(base, "M001");
-      emitWorktreeMerged(base, "M001", {
-        reason: "milestone-complete",
-        durationMs: 250,
-        conflict: false,
-      });
-      emitAutoExit(base, { reason: "all-complete", milestoneId: "M001", milestoneMerged: true });
-
-      const { buildForensicReport } = await import("../forensics.ts");
-      const report = await buildForensicReport(base);
-
-      const telemetryAnomalies = report.anomalies.filter(a =>
-        a.type === "worktree-orphan" || a.type === "worktree-unmerged-exit"
-      );
-      assert.deepStrictEqual(telemetryAnomalies, [], "no orphans, no unmerged exits → no telemetry anomalies");
-
-      assert.equal(report.worktreeTelemetry!.worktreesCreated, 1);
-      assert.equal(report.worktreeTelemetry!.worktreesMerged, 1);
-      assert.equal(report.worktreeTelemetry!.orphansDetected, 0);
-      assert.equal(report.worktreeTelemetry!.exitsWithUnmergedWork, 0);
-    } finally { cleanup(base); }
-  });
-});

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,130 +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";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-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 = extractSourceRegion(
-      TIMERS_SRC,
-      'recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle"',
-      { fromIdx: idleRecovery },
-    );
-    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",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/import-done-milestones.test.ts

@@ -1,43 +0,0 @@
-/**
- * Regression test for #3699 — import milestones with all-done slices as complete
- *
- * During DB migration, milestones whose roadmap slices are all marked done
- * should be imported with status "complete" instead of "active".
- */
-
-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';
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const importerSrc = readFileSync(
-  join(__dirname, '..', 'md-importer.ts'),
-  'utf-8',
-);
-
-describe('import done milestones as complete (#3699)', () => {
-  test('all-slices-done check sets milestoneStatus to complete', () => {
-    // The importer should check if all roadmap slices are done
-    assert.match(importerSrc, /roadmap\.slices\.every\(s\s*=>\s*s\.done\)/,
-      'should check roadmap.slices.every(s => s.done)');
-  });
-
-  test('milestoneStatus is set to complete when all slices done', () => {
-    // Find the all-done guard and verify it sets 'complete'
-    const everyIdx = importerSrc.indexOf('roadmap.slices.every(s => s.done)');
-    assert.ok(everyIdx > -1, 'all-slices-done check should exist');
-    const afterCheck = extractSourceRegion(importerSrc, 'roadmap.slices.every(s => s.done)');
-    assert.match(afterCheck, /milestoneStatus\s*=\s*'complete'/,
-      'should set milestoneStatus to complete when all slices are done');
-  });
-
-  test('roadmap.slices.length > 0 guard prevents false positives', () => {
-    assert.match(importerSrc, /roadmap\.slices\.length\s*>\s*0/,
-      'should guard against empty slices array');
-  });
-});