gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -85,7 +85,49 @@ function cleanup(dir: string): void {
   try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
 }
 
-/** Set up a milestone roadmap file in .gsd/milestones/<MID>/ */
+/**
+ * Write `.gsd/preferences.md` with `git.isolation: branch` so the merge
+ * routes through the standalone Lifecycle merge body in branch mode rather
+ * than falling through `getIsolationMode === "none"` to a skipped result.
+ *
+ * Parallel-merge in production runs with `git.isolation: worktree` and a
+ * real auto-worktree on disk; these integration tests use branch mode as a
+ * simpler equivalent that exercises the same merge path without requiring
+ * `git worktree add` setup. ADR-016 phase 2 / A2 routes parallel-merge
+ * through the Module, which performs mode detection — branch mode keeps
+ * the test simple while still going through the Module.
+ */
+function setupBranchIsolation(repo: string): void {
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    "## Git\n- isolation: branch\n",
+  );
+  // Commit on main so subsequent `git checkout main` restores the file.
+  // Without this commit, `createMilestoneBranch`'s checkout dance carries
+  // the uncommitted file onto the milestone branch and back-checking-out
+  // main loses the preference file before `mergeMilestoneStandalone`
+  // reads it (ADR-016 phase 2 / A2).
+  try {
+    run("git add .gsd/preferences.md", repo);
+    run('git commit -m "test: add branch-isolation preferences"', repo);
+  } catch { /* file may already be committed */ }
+}
+
+/**
+ * Set up a milestone roadmap file in .gsd/milestones/<MID>/ AND commit it on
+ * the current branch.
+ *
+ * The commit is required after ADR-016 phase 2 / A2 because the standalone
+ * Module-level merge (now used by parallel-merge) reads the roadmap _after_
+ * its branch checkout. Uncommitted roadmaps on `main` survive a checkout
+ * for the first milestone but get committed onto the milestone branch by
+ * `autoCommitDirtyState`, which then doesn't reproduce them on the next
+ * milestone branch's checkout.
+ *
+ * Real production runs commit roadmap files on each milestone branch as
+ * part of the unit's normal output; tests should mirror that.
+ */
 function setupRoadmap(repo: string, mid: string, title: string, slices: string[]): void {
   const dir = join(repo, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -94,6 +136,10 @@ function setupRoadmap(repo: string, mid: string, title: string, slices: string[]
     join(dir, `${mid}-ROADMAP.md`),
     `# ${mid}: ${title}\n\n## Slices\n${sliceLines}\n`,
   );
+  try {
+    run(`git add .gsd/milestones/${mid}/${mid}-ROADMAP.md`, repo);
+    run(`git commit -m "test: add roadmap for ${mid}"`, repo);
+  } catch { /* file may already be committed; not a git repo; etc. */ }
 }
 
 /** Create a milestone branch with file changes, then return to main. */
@@ -234,15 +280,36 @@ test("formatMergeResults — mixed results", () => {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 test("mergeCompletedMilestone — missing roadmap returns error result", async () => {
-  const base = join(tmpdir(), `parallel-merge-noroadmap-${Date.now()}`);
-  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const savedCwd = process.cwd();
+  // Use a real git repo so the standalone's branch-mode merge body can
+  // call `getCurrentBranch` without throwing. The roadmap is intentionally
+  // omitted so the merge ends in the "no-roadmap" branch.
+  const repo = createTempRepo();
   try {
-    const result = await mergeCompletedMilestone(base, "M999");
+    setupBranchIsolation(repo);
+    // Create a milestone branch but no roadmap file — this is the
+    // condition under test.
+    run("git checkout -b milestone/M999", repo);
+    writeFileSync(join(repo, "feature.ts"), "export {};\n");
+    run("git add .", repo);
+    run('git commit -m "M999 feature"', repo);
+    run("git checkout main", repo);
+
+    process.chdir(repo);
+    const result = await mergeCompletedMilestone(repo, "M999");
+
     assert.equal(result.success, false);
-    assert.ok(result.error?.includes("No roadmap found") || result.error?.includes("Could not read"));
+    // A2 widens the error surface vs. the legacy bypass: the standalone
+    // routes through the Module, so the no-roadmap path teardowns the
+    // (non-existent) worktree branch and surfaces a typed failure.
+    // What matters is `success: false`; the exact wording can shift as
+    // the standalone evolves.
+    assert.ok(result.error, "should report a non-empty error");
     assert.equal(result.milestoneId, "M999");
   } finally {
-    cleanup(base);
+    process.chdir(savedCwd);
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    cleanup(repo);
   }
 });
 
@@ -251,14 +318,24 @@ test("mergeCompletedMilestone — clean merge, session status cleaned up", async
   const repo = createTempRepo();
 
   try {
+    // Route the merge through the Module's branch-mode path. With default
+    // `isolation: none`, the standalone returns `{ mode: "skipped" }`
+    // (ADR-016 phase 2 / A2). Branch mode exercises the same Module-level
+    // merge body without requiring an on-disk auto-worktree.
+    setupBranchIsolation(repo);
+
+    // Set up roadmap on main BEFORE the milestone branch is created so the
+    // roadmap is in the milestone branch's history. After A2, the standalone
+    // reads the roadmap _inside_ the merge body (after the branch checkout)
+    // — the file must therefore exist in the milestone branch's tree, not
+    // just as an uncommitted file on main.
+    setupRoadmap(repo, "M010", "Auth System", ["S01: JWT module"]);
+
     // Create milestone branch with a new file
     createMilestoneBranch(repo, "M010", [
       { name: "auth.ts", content: "export const auth = true;\n" },
     ]);
 
-    // Set up roadmap
-    setupRoadmap(repo, "M010", "Auth System", ["S01: JWT module"]);
-
     // Write session status to verify cleanup
     writeSessionStatus(repo, {
       milestoneId: "M010",
@@ -309,6 +386,11 @@ test("mergeCompletedMilestone — conflict returns structured error with file li
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmap committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M020", "Conflict Test", ["S01: Conflict scenario"]);
+
     // Create milestone branch that modifies README.md
     run("git checkout -b milestone/M020", repo);
     writeFileSync(join(repo, "README.md"), "# M020 version\n");
@@ -321,9 +403,6 @@ test("mergeCompletedMilestone — conflict returns structured error with file li
     run("git add .", repo);
     run('git commit -m "main changes README"', repo);
 
-    // Set up roadmap
-    setupRoadmap(repo, "M020", "Conflict Test", ["S01: Conflict scenario"]);
-
     process.chdir(repo);
     const result = await mergeCompletedMilestone(repo, "M020");
 
@@ -350,6 +429,12 @@ test("mergeAllCompleted — merges in sequential order", async () => {
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Dashboard", ["S01: Dashboard module"]);
+
     // M001: adds auth.ts
     createMilestoneBranch(repo, "M001", [
       { name: "auth.ts", content: "export const auth = true;\n" },
@@ -359,9 +444,6 @@ test("mergeAllCompleted — merges in sequential order", async () => {
       { name: "dashboard.ts", content: "export const dash = true;\n" },
     ]);
 
-    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
-    setupRoadmap(repo, "M002", "Dashboard", ["S01: Dashboard module"]);
-
     const workers = [
       makeWorker({ milestoneId: "M002", startedAt: 100 }),
       makeWorker({ milestoneId: "M001", startedAt: 200 }),
@@ -373,9 +455,9 @@ test("mergeAllCompleted — merges in sequential order", async () => {
     // Both should succeed
     assert.equal(results.length, 2, "should have two results");
     assert.equal(results[0]!.milestoneId, "M001", "M001 merged first (sequential)");
-    assert.equal(results[0]!.success, true, "M001 should succeed");
+    assert.equal(results[0]!.success, true, `M001 should succeed: ${results[0]!.error}`);
     assert.equal(results[1]!.milestoneId, "M002", "M002 merged second");
-    assert.equal(results[1]!.success, true, "M002 should succeed");
+    assert.equal(results[1]!.success, true, `M002 should succeed: ${results[1]!.error}`);
 
     // Both files on main
     assert.ok(existsSync(join(repo, "auth.ts")), "auth.ts on main");
@@ -391,6 +473,12 @@ test("mergeAllCompleted — stops on first conflict, skips later milestones", as
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Conflict milestone", ["S01: Conflict test"]);
+    setupRoadmap(repo, "M002", "Clean milestone", ["S01: Clean test"]);
+
     // M001: modifies README.md (will conflict with main)
     run("git checkout -b milestone/M001", repo);
     writeFileSync(join(repo, "README.md"), "# M001 version\n");
@@ -408,9 +496,6 @@ test("mergeAllCompleted — stops on first conflict, skips later milestones", as
     run("git add .", repo);
     run('git commit -m "main diverges README"', repo);
 
-    setupRoadmap(repo, "M001", "Conflict milestone", ["S01: Conflict test"]);
-    setupRoadmap(repo, "M002", "Clean milestone", ["S01: Clean test"]);
-
     const workers = [
       makeWorker({ milestoneId: "M001" }),
       makeWorker({ milestoneId: "M002" }),
@@ -442,6 +527,12 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Feature", ["S01: Feature module"]);
+
     // M001: adds auth.ts (started later)
     createMilestoneBranch(repo, "M001", [
       { name: "auth.ts", content: "export const auth = true;\n" },
@@ -451,9 +542,6 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
       { name: "feature.ts", content: "export const feature = true;\n" },
     ]);
 
-    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
-    setupRoadmap(repo, "M002", "Feature", ["S01: Feature module"]);
-
     const workers = [
       makeWorker({ milestoneId: "M001", startedAt: 2000 }),
       makeWorker({ milestoneId: "M002", startedAt: 1000 }),
@@ -549,11 +637,15 @@ test("mergeAllCompleted — discovers DB-complete milestones when workers show e
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmap committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
+
     // Create milestone branch with a file
     createMilestoneBranch(repo, "M011", [
       { name: "feature.ts", content: "export const feature = true;\n" },
     ]);
-    setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
 
     // Set up canonical DB showing M011 is complete
     setupCanonicalDbWithWorktree(repo, "M011");

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -1,213 +1,71 @@
 // GSD Extension — Interactive Routing Bypass Tests
-// Verifies that dynamic routing is skipped for interactive (guided-flow) dispatches
-// and that model downgrade notifications always fire (#3962).
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import test, { describe } 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";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ─── Source-level structural tests ──────────────────────────────────────────
-
-const modelSelectionSrc = readFileSync(
-  join(__dirname, "..", "auto-model-selection.ts"),
-  "utf-8",
-);
-
-const guidedFlowSrc = readFileSync(
-  join(__dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-const autoStartSrc = readFileSync(
-  join(__dirname, "..", "auto-start.ts"),
-  "utf-8",
-);
-
-describe("interactive routing bypass (#3962)", () => {
-  test("selectAndApplyModel accepts isAutoMode parameter", () => {
-    // The function signature should include isAutoMode with a default of true
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode"),
-      "selectAndApplyModel should have isAutoMode parameter",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode = true"),
-      "isAutoMode should default to true (auto-mode behavior preserved)",
-    );
-  });
-
-  test("routing is disabled when isAutoMode is false", () => {
-    // The code should disable routing when not in auto-mode
-    assert.ok(
-      modelSelectionSrc.includes("if (!isAutoMode)"),
-      "should check isAutoMode flag to disable routing",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("routingConfig.enabled = false"),
-      "should set routingConfig.enabled = false for interactive mode",
-    );
-  });
-
-  test("resolvePreferredModelConfig skips routing synthesis when isAutoMode is false", () => {
-    // resolvePreferredModelConfig should accept isAutoMode and bail early
-    // before synthesizing a routing ceiling from tier_models (#3962 codex review)
-    assert.ok(
-      modelSelectionSrc.includes("function resolvePreferredModelConfig"),
-      "resolvePreferredModelConfig should exist",
-    );
-    // The function should check isAutoMode before routing synthesis
-    const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
-    assert.ok(
-      fnBody.includes("isAutoMode"),
-      "resolvePreferredModelConfig should accept isAutoMode parameter",
-    );
-    assert.ok(
-      fnBody.includes("if (!isAutoMode) return undefined"),
-      "should return undefined (skip routing synthesis) when not in auto-mode",
-    );
-  });
-
-  test("selectAndApplyModel threads isAutoMode to resolvePreferredModelConfig", () => {
-    // The call to resolvePreferredModelConfig inside selectAndApplyModel
-    // should pass isAutoMode as the third argument
-    const callSite = "resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode)";
-    assert.ok(
-      modelSelectionSrc.includes(callSite),
-      "selectAndApplyModel should pass isAutoMode to resolvePreferredModelConfig",
-    );
-  });
-
-  test("guided-flow passes isAutoMode=false", () => {
-    // guided-flow.ts should explicitly pass isAutoMode as false
-    assert.ok(
-      guidedFlowSrc.includes("/* isAutoMode */ false"),
-      "guided-flow should pass isAutoMode=false to selectAndApplyModel",
-    );
-  });
-
-  test("auto/phases.ts does NOT pass isAutoMode=false", () => {
-    // auto/phases.ts should use the default (true) — it's auto-mode
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolvePreferredModelConfig } from "../auto-model-selection.ts";
+
+function withRoutingPrefs<T>(fn: () => T): T {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: gpt-4o-mini",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
       "utf-8",
     );
-    assert.ok(
-      !phasesSrc.includes("isAutoMode"),
-      "auto/phases.ts should use default isAutoMode=true (not pass it explicitly)",
-    );
-  });
-});
-
-describe("model downgrade notifications always visible (#3962)", () => {
-  test("downgrade notification is not gated by verbose flag", () => {
-    // The downgrade notification block should NOT be wrapped in `if (verbose)`
-    // Find the downgrade block and verify it's not behind a verbose check
-    const downgradeBlock = "if (routingResult.wasDowngraded)";
-    const downgradeIdx = modelSelectionSrc.indexOf(downgradeBlock);
-    assert.ok(downgradeIdx > 0, "downgrade block should exist");
-
-    // Extract the code between wasDowngraded check and the next routing label assignment
-    const afterDowngrade = modelSelectionSrc.slice(
-      downgradeIdx,
-      modelSelectionSrc.indexOf("routingTierLabel =", downgradeIdx),
-    );
-
-    // The notification calls should NOT be wrapped in `if (verbose)`
-    assert.ok(
-      !afterDowngrade.includes("if (verbose)"),
-      "downgrade notifications should not be gated by verbose flag",
-    );
-
-    // But the notification calls should exist
-    assert.ok(
-      afterDowngrade.includes('ctx.ui.notify('),
-      "downgrade notifications should still fire",
-    );
-  });
-
-  test("tier escalation notification is not gated by verbose flag", () => {
-    // Extract the escalation block: from "if (escalated)" to its closing
-    // and verify the notification is present but `if (verbose)` is not.
-    const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
-    assert.ok(escalatedIdx > 0, "escalation block should exist");
-
-    // Get the block from "if (escalated)" to the next distinctive marker
-    // (the capability-override loading that immediately follows).
-    const block = extractSourceRegion(
-      modelSelectionSrc,
-      "if (escalated)",
-      "// Load user capability overrides",
-    );
-    assert.ok(
-      block.includes("Tier escalation:"),
-      "escalation block should contain the notification",
-    );
-    assert.ok(
-      !block.includes("if (verbose)"),
-      "escalation block should not gate notification behind verbose flag",
-    );
-  });
-});
-
-describe("auto-mode start routing banner (#3962)", () => {
-  test("auto-start shows dynamic routing status on startup", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing:"),
-      "auto-start should display routing status banner",
-    );
-    assert.ok(
-      autoStartSrc.includes("resolveDynamicRoutingConfig"),
-      "auto-start should import resolveDynamicRoutingConfig",
-    );
-  });
-
-  test("banner shows different messages for enabled vs disabled routing", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: enabled"),
-      "should show message when routing is enabled",
-    );
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: disabled"),
-      "should show message when routing is disabled",
-    );
-  });
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+    return fn();
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+}
 
-  test("banner shows the ceiling model", () => {
-    assert.ok(
-      autoStartSrc.includes("startModelLabel"),
-      "banner should reference the start/ceiling model",
-    );
-  });
-
-  test("banner accounts for flat-rate provider suppression", () => {
-    // The banner should check isFlatRateProvider to accurately reflect
-    // whether routing will actually be active at dispatch time (#3962 codex review)
-    assert.ok(
-      autoStartSrc.includes("isFlatRateProvider"),
-      "banner should check flat-rate provider status",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectivelyEnabled"),
-      "banner should compute effective routing state, not just raw config",
-    );
+describe("interactive routing bypass (#3962)", () => {
+  test("interactive dispatch does not synthesize dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        false,
+      );
+
+      assert.equal(result, undefined);
+    });
   });
 
-  test("banner uses effective ceiling from tier_models.heavy when configured", () => {
-    // The actual ceiling may come from tier_models.heavy, not the start model
-    assert.ok(
-      autoStartSrc.includes("tier_models?.heavy"),
-      "banner should check tier_models.heavy for the effective ceiling",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectiveCeiling"),
-      "banner should compute the effective ceiling model",
-    );
+  test("auto-mode dispatch still synthesizes dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        true,
+      );
+
+      assert.ok(result);
+      assert.equal(result!.primary, "claude-opus-4-6");
+      assert.equal(result!.source, "synthesized");
+    });
   });
 });

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -1,62 +1,19 @@
-/**
- * Regression test for #3675 — isolation:none stale branch guard
- *
- * When switching from isolation:branch/worktree to isolation:none, HEAD
- * could remain on a milestone/<MID> branch. The fix in auto-start.ts
- * detects this and auto-checks out to the integration branch.
- *
- * This structural test verifies the milestone/ branch check exists
- * in auto-start.ts.
- */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
 
-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 { resolveIsolationNoneBranchCheckout } from "../auto-start.ts";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'auto-start.ts'), 'utf-8');
-
-describe('isolation:none stale branch guard (#3675)', () => {
-  test('checks for milestone/ branch prefix', () => {
-    assert.match(source, /startsWith\(["']milestone\//,
-      'auto-start should check for milestone/ branch prefix');
-  });
-
-  test('imports nativeGetCurrentBranch', () => {
-    assert.match(source, /nativeGetCurrentBranch/,
-      'auto-start should import nativeGetCurrentBranch');
-  });
-
-  test('imports nativeDetectMainBranch', () => {
-    assert.match(source, /nativeDetectMainBranch/,
-      'auto-start should import nativeDetectMainBranch');
-  });
-
-  test('imports nativeCheckoutBranch', () => {
-    assert.match(source, /nativeCheckoutBranch/,
-      'auto-start should import nativeCheckoutBranch');
-  });
-
-  test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
-      'guard should only activate when isolation mode is "none"');
-  });
-
-  test('calls nativeCheckoutBranch to return to integration branch', () => {
-    assert.match(source, /nativeCheckoutBranch\(base,\s*integrationBranch\)/,
-      'should checkout to the integration branch');
+describe("isolation:none stale branch guard (#3675)", () => {
+  test("returns integration branch for stale milestone branch in isolation:none", () => {
+    assert.equal(
+      resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", true),
+      "main",
+    );
   });
 
-  test('guard is wrapped in try-catch (non-fatal)', () => {
-    // Find the milestone/ check and verify it is inside a try block
-    const milestoneIdx = source.indexOf('startsWith("milestone/")');
-    assert.ok(milestoneIdx > 0, 'milestone/ check should exist');
-    const before = source.slice(Math.max(0, milestoneIdx - 500), milestoneIdx);
-    assert.match(before, /try\s*\{/,
-      'milestone branch guard should be inside a try block');
+  test("does nothing outside milestone branches, repos, or isolation:none", () => {
+    assert.equal(resolveIsolationNoneBranchCheckout("feature", "main", "none", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "worktree", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", false), null);
   });
 });