gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/tests/event-replay-idempotency.test.ts

@@ -1,140 +0,0 @@
-// GSD State Machine Regression Tests — Event Replay & Reconciliation (#3161)
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-  updateTaskStatus,
-  insertVerificationEvidence,
-  upsertDecision,
-} from "../gsd-db.ts";
-import { extractEntityKey } from "../workflow-reconcile.ts";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-const MID = "M001";
-const SID = "S01";
-const TID = "T01";
-const TS = new Date().toISOString();
-
-function setupDb(): void {
-  openDatabase(":memory:");
-  insertMilestone({ id: MID, title: "Test Milestone" });
-  insertSlice({ id: SID, milestoneId: MID, title: "Test Slice" });
-  insertTask({ id: TID, sliceId: SID, milestoneId: MID, title: "Test Task" });
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe("event-replay-idempotency", () => {
-  beforeEach(() => {
-    setupDb();
-  });
-
-  afterEach(() => {
-    closeDatabase();
-  });
-
-  test("updateTaskStatus is idempotent for complete_task replay", () => {
-    // Simulates replaying a complete_task event twice (e.g. crash recovery)
-    updateTaskStatus(MID, SID, TID, "done", TS);
-    updateTaskStatus(MID, SID, TID, "done", TS);
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after status update");
-    assert.equal(task!.status, "done", "status should be 'done' after double replay");
-  });
-
-  test("updateTaskStatus is idempotent for start_task replay", () => {
-    // Simulates replaying a start_task event twice
-    updateTaskStatus(MID, SID, TID, "in-progress");
-    updateTaskStatus(MID, SID, TID, "in-progress");
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after status update");
-    assert.equal(task!.status, "in-progress", "status should be 'in-progress' after double replay");
-  });
-
-  test("updateTaskStatus for report_blocker does not set blocker_discovered flag (M4)", () => {
-    // M4 finding: report_blocker replay only calls updateTaskStatus("blocked").
-    // The blocker_discovered column is NOT set during replay — this is a known
-    // lossy replay: status is recovered but the blocker flag is not.
-    updateTaskStatus(MID, SID, TID, "blocked");
-
-    const task = getTask(MID, SID, TID);
-    assert.ok(task !== null, "task should exist after blocked status update");
-    assert.equal(task!.status, "blocked", "status should be 'blocked'");
-    assert.equal(
-      task!.blocker_discovered,
-      false,
-      "blocker_discovered should remain false — report_blocker replay is lossy (M4 finding)",
-    );
-  });
-
-  test("insertVerificationEvidence is NOT idempotent — duplicates accumulate (M5)", () => {
-    // M5 finding: insertVerificationEvidence uses a plain INSERT (no ON CONFLICT),
-    // so replaying the same record_verification event twice produces two rows.
-    // Both calls must succeed without throwing — the duplication is the risk.
-    const evidence = {
-      taskId: TID,
-      sliceId: SID,
-      milestoneId: MID,
-      command: "npm test",
-      exitCode: 0,
-      verdict: "pass",
-      durationMs: 1200,
-    };
-
-    assert.doesNotThrow(
-      () => insertVerificationEvidence(evidence),
-      "first insertVerificationEvidence call should not throw",
-    );
-    assert.doesNotThrow(
-      () => insertVerificationEvidence(evidence),
-      "second insertVerificationEvidence call should not throw — duplicates accumulate silently (M5 finding)",
-    );
-  });
-
-  test("upsertDecision is idempotent via INSERT OR REPLACE", () => {
-    // save_decision replay uses upsertDecision which is INSERT OR REPLACE,
-    // so replaying the same decision id twice overwrites without error.
-    const base = {
-      id: "arch:logging",
-      when_context: "during planning",
-      scope: "arch",
-      decision: "logging",
-      rationale: "structured logs",
-      revisable: "yes" as const,
-      made_by: "agent" as const,
-      superseded_by: null,
-    };
-
-    upsertDecision({ ...base, choice: "structured" });
-    upsertDecision({ ...base, choice: "unstructured" });
-
-    // No error means the second call replaced the first — idempotent at the id level.
-    // The final choice is "unstructured" per INSERT OR REPLACE semantics.
-  });
-
-  test("unknown event commands in replayEvents are silently skipped — extractEntityKey returns null for unknown commands", () => {
-    // replayEvents uses a switch/default that silently skips unrecognised commands.
-    // We verify this via extractEntityKey which follows the same command set.
-    // A future_command not in the switch must return null (not throw).
-    const event = {
-      cmd: "future_command",
-      params: { foo: "bar" },
-      ts: new Date().toISOString(),
-      hash: "0000000000000000",
-      actor: "agent" as const,
-      session_id: "test-session",
-    };
-
-    const key = extractEntityKey(event);
-    assert.equal(key, null, "extractEntityKey should return null for unknown commands");
-  });
-});

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

@@ -1,129 +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"));
-  });
-});

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/gsdroot-worktree-detection.test.ts

@@ -1,164 +0,0 @@
-/**
- * gsdroot-worktree-detection.test.ts — Regression test for #2594.
- *
- * gsdRoot() must return the worktree's own .gsd directory when the basePath
- * is inside a .gsd/worktrees/<name>/ structure, not walk up to the project
- * root's .gsd via the git-root probe.
- *
- * The bug: when a git worktree lives at /project/.gsd/worktrees/M008/,
- * probeGsdRoot() runs `git rev-parse --show-toplevel` which can return the
- * main project root (not the worktree root) depending on git version and
- * worktree setup. The walk-up then finds /project/.gsd and returns that
- * instead of the worktree's own .gsd path.
- */
-
-import { describe, test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { mkdtempSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { spawnSync } from "node:child_process";
-
-import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
-
-describe("gsdRoot() worktree detection (#2594)", () => {
-  let projectRoot: string;
-  let projectGsd: string;
-
-  beforeEach(() => {
-    _clearGsdRootCache();
-    // Create a temporary project with a git repo to simulate real conditions.
-    // realpathSync handles macOS /tmp -> /private/tmp.
-    projectRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsdroot-wt-")));
-    projectGsd = join(projectRoot, ".gsd");
-    mkdirSync(projectGsd, { recursive: true });
-
-    // Initialize a git repo in the project root so git rev-parse works
-    spawnSync("git", ["init", "--initial-branch=main"], {
-      cwd: projectRoot,
-      stdio: "ignore",
-    });
-    spawnSync("git", ["config", "user.email", "test@test.com"], {
-      cwd: projectRoot,
-      stdio: "ignore",
-    });
-    spawnSync("git", ["config", "user.name", "Test"], {
-      cwd: projectRoot,
-      stdio: "ignore",
-    });
-    // Create an initial commit so we have a HEAD
-    writeFileSync(join(projectRoot, "README.md"), "# Test");
-    spawnSync("git", ["add", "."], { cwd: projectRoot, stdio: "ignore" });
-    spawnSync("git", ["commit", "-m", "init"], {
-      cwd: projectRoot,
-      stdio: "ignore",
-    });
-  });
-
-  afterEach(() => {
-    _clearGsdRootCache();
-    rmSync(projectRoot, { recursive: true, force: true });
-  });
-
-  test("returns worktree .gsd when basePath is a worktree with its own .gsd (fast path)", () => {
-    // Simulates a worktree that already had copyPlanningArtifacts() run,
-    // so it has its own .gsd/ directory.
-    const worktreeBase = join(projectGsd, "worktrees", "M008");
-    const worktreeGsd = join(worktreeBase, ".gsd");
-    mkdirSync(worktreeGsd, { recursive: true });
-
-    const result = gsdRoot(worktreeBase);
-    assert.equal(
-      result,
-      worktreeGsd,
-      `Expected worktree .gsd (${worktreeGsd}), got ${result}. ` +
-        "gsdRoot() should use the fast path for an existing worktree .gsd.",
-    );
-  });
-
-  test("returns worktree .gsd path (not project root .gsd) when worktree .gsd does not exist yet", () => {
-    // This is the core #2594 bug: the worktree directory exists but its .gsd
-    // subdirectory hasn't been created yet. Without the fix, probeGsdRoot()
-    // walks up from the worktree path, finds /project/.gsd, and returns it.
-    // With the fix, it detects the .gsd/worktrees/<name>/ pattern and returns
-    // the worktree-local .gsd path as the creation fallback.
-    const worktreeBase = join(projectGsd, "worktrees", "M008");
-    mkdirSync(worktreeBase, { recursive: true });
-    // NOTE: no .gsd/ inside worktreeBase
-
-    const result = gsdRoot(worktreeBase);
-    const expected = join(worktreeBase, ".gsd");
-
-    // Without the fix, this returns projectGsd (/project/.gsd) because the
-    // walk-up from worktreeBase finds it. With the fix, it returns the
-    // worktree-local path.
-    assert.notEqual(
-      result,
-      projectGsd,
-      "gsdRoot() must NOT return the project root .gsd when basePath is inside .gsd/worktrees/",
-    );
-    assert.equal(
-      result,
-      expected,
-      `Expected worktree-local .gsd (${expected}), got ${result}.`,
-    );
-  });
-
-  test("returns worktree .gsd when basePath is a real git worktree inside .gsd/worktrees/", () => {
-    // Create a real git worktree at .gsd/worktrees/M010
-    const worktreeName = "M010";
-    const worktreeBase = join(projectGsd, "worktrees", worktreeName);
-
-    // Use git worktree add to create a real worktree
-    const result = spawnSync(
-      "git",
-      ["worktree", "add", "-b", `milestone/${worktreeName}`, worktreeBase],
-      { cwd: projectRoot, encoding: "utf-8" },
-    );
-
-    if (result.status !== 0) {
-      // If git worktree add fails, skip the test gracefully
-      assert.ok(true, "Skipped: git worktree add not available");
-      return;
-    }
-
-    // The real git worktree exists at worktreeBase but has NO .gsd/ subdir yet
-    const gsdResult = gsdRoot(worktreeBase);
-    const expected = join(worktreeBase, ".gsd");
-
-    assert.notEqual(
-      gsdResult,
-      projectGsd,
-      "gsdRoot() must NOT escape to project root .gsd from inside a git worktree",
-    );
-    assert.equal(
-      gsdResult,
-      expected,
-      `Expected worktree-local .gsd (${expected}), got ${gsdResult}`,
-    );
-
-    // Cleanup worktree
-    spawnSync("git", ["worktree", "remove", "--force", worktreeBase], {
-      cwd: projectRoot,
-      stdio: "ignore",
-    });
-  });
-
-  test("still returns project .gsd for normal (non-worktree) basePath", () => {
-    const result = gsdRoot(projectRoot);
-    assert.equal(result, projectGsd);
-  });
-
-  test("still returns project .gsd for a subdirectory of the project", () => {
-    const subdir = join(projectRoot, "src", "lib");
-    mkdirSync(subdir, { recursive: true });
-
-    const result = gsdRoot(subdir);
-    assert.equal(
-      result,
-      projectGsd,
-      "Non-worktree subdirectories should still resolve to project .gsd",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/guided-flow-dynamic-routing.test.ts

@@ -1,135 +0,0 @@
-/**
- * Guided-flow dynamic routing — regression test for #2958.
- *
- * Verifies that dispatchWorkflow() routes through the dynamic routing pipeline
- * (selectAndApplyModel from auto-model-selection.ts) instead of bypassing it
- * with a direct call to resolveModelWithFallbacksForUnit.
- *
- * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
- */
-
-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 gsdDir = join(__dirname, "..");
-
-function readSrc(file: string): string {
-  return readFileSync(join(gsdDir, file), "utf-8");
-}
-
-const guidedFlowSrc = readSrc("guided-flow.ts");
-
-// ═══════════════════════════════════════════════════════════════════════════
-// #2958: dispatchWorkflow must route through dynamic routing pipeline
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("#2958: guided-flow imports selectAndApplyModel from auto-model-selection", () => {
-  assert.ok(
-    guidedFlowSrc.includes("selectAndApplyModel"),
-    "guided-flow.ts must import and use selectAndApplyModel from auto-model-selection.ts",
-  );
-});
-
-test("#2958: dispatchWorkflow does not call resolveModelWithFallbacksForUnit directly", () => {
-  // Extract the dispatchWorkflow function body
-  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
-  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
-
-  // Find the function body by tracking brace depth
-  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
-  let depth = 1;
-  let pos = openBrace + 1;
-  while (depth > 0 && pos < guidedFlowSrc.length) {
-    if (guidedFlowSrc[pos] === "{") depth++;
-    else if (guidedFlowSrc[pos] === "}") depth--;
-    pos++;
-  }
-  const fnBody = guidedFlowSrc.slice(openBrace, pos);
-
-  assert.ok(
-    !fnBody.includes("resolveModelWithFallbacksForUnit"),
-    "dispatchWorkflow must NOT call resolveModelWithFallbacksForUnit directly — " +
-    "it must route through selectAndApplyModel for dynamic routing support (#2958)",
-  );
-});
-
-test("#2958: dispatchWorkflow calls selectAndApplyModel for model selection", () => {
-  // Extract the dispatchWorkflow function body
-  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
-  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
-
-  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
-  let depth = 1;
-  let pos = openBrace + 1;
-  while (depth > 0 && pos < guidedFlowSrc.length) {
-    if (guidedFlowSrc[pos] === "{") depth++;
-    else if (guidedFlowSrc[pos] === "}") depth--;
-    pos++;
-  }
-  const fnBody = guidedFlowSrc.slice(openBrace, pos);
-
-  assert.ok(
-    fnBody.includes("selectAndApplyModel"),
-    "dispatchWorkflow must call selectAndApplyModel to route through the dynamic routing pipeline (#2958)",
-  );
-});
-
-test("#2958: dispatchWorkflow does not use resolveAvailableModel inline", () => {
-  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
-  assert.ok(fnStart !== -1, "dispatchWorkflow function not found");
-
-  const openBrace = guidedFlowSrc.indexOf("{", fnStart);
-  let depth = 1;
-  let pos = openBrace + 1;
-  while (depth > 0 && pos < guidedFlowSrc.length) {
-    if (guidedFlowSrc[pos] === "{") depth++;
-    else if (guidedFlowSrc[pos] === "}") depth--;
-    pos++;
-  }
-  const fnBody = guidedFlowSrc.slice(openBrace, pos);
-
-  assert.ok(
-    !fnBody.includes("resolveAvailableModel"),
-    "dispatchWorkflow must NOT use resolveAvailableModel inline — " +
-    "model resolution is handled by selectAndApplyModel (#2958)",
-  );
-});
-
-test("#2958: guided-flow does not import resolveModelWithFallbacksForUnit", () => {
-  // The import should be removed since dispatchWorkflow was the only consumer
-  // Check if resolveModelWithFallbacksForUnit is still used elsewhere in the file
-  const fnStart = guidedFlowSrc.indexOf("async function dispatchWorkflow(");
-  const beforeDispatch = guidedFlowSrc.slice(0, fnStart);
-  const afterFnEnd = (() => {
-    const openBrace = guidedFlowSrc.indexOf("{", fnStart);
-    let depth = 1;
-    let p = openBrace + 1;
-    while (depth > 0 && p < guidedFlowSrc.length) {
-      if (guidedFlowSrc[p] === "{") depth++;
-      else if (guidedFlowSrc[p] === "}") depth--;
-      p++;
-    }
-    return guidedFlowSrc.slice(p);
-  })();
-
-  // If resolveModelWithFallbacksForUnit is not used outside dispatchWorkflow,
-  // the import should be removed
-  const usedOutside = beforeDispatch.includes("resolveModelWithFallbacksForUnit(")
-    || afterFnEnd.includes("resolveModelWithFallbacksForUnit(");
-
-  if (!usedOutside) {
-    // Verify the import line was cleaned up
-    const importLines = guidedFlowSrc.split("\n").filter(l =>
-      l.includes("import") && l.includes("resolveModelWithFallbacksForUnit"),
-    );
-    assert.equal(
-      importLines.length,
-      0,
-      "resolveModelWithFallbacksForUnit import should be removed when no longer used outside dispatchWorkflow",
-    );
-  }
-});