gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

package/src/resources/extensions/gsd/tests/integration/commands-eval-review.integration.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Integration tests for the /gsd eval-review helper chain.
 /**
  * Integration test for `/gsd eval-review` .
  *
@@ -10,7 +12,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -119,7 +121,7 @@ describe("integration: /gsd eval-review helper chain on a real on-disk slice", (
     );
     assert.equal(ctx.truncated, false);
     assert.equal(ctx.sliceId, "S07");
-    assert.equal(ctx.outputPath, evalReviewWritePath(layout.sliceDir, "S07"));
+    assert.equal(ctx.outputPath, evalReviewWritePath(realpathSync(layout.sliceDir), "S07"));
 
     const prompt = buildEvalReviewPrompt(ctx);
 

package/src/resources/extensions/gsd/tests/integration/git-locale.test.ts

@@ -7,13 +7,13 @@ import assert from 'node:assert/strict';
  * English output, and that nativeMergeSquash passes the env to execFileSync.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
 import { GIT_NO_PROMPT_ENV } from "../../git-constants.ts";
-import { nativeAddAllWithExclusions } from "../../native-git-bridge.ts";
+import { nativeAddAllWithExclusions, nativeMergeSquash } from "../../native-git-bridge.ts";
 import { RUNTIME_EXCLUSION_PATHS } from "../../git-service.ts";
 function git(cwd: string, ...args: string[]): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -97,23 +97,34 @@ describe('git-locale', async () => {
 
   // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
 
-  test('nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV', () => {
-    // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
-    // Read the source and check for the pattern. This is a static check.
-    const src = readFileSync(
-      join(import.meta.dirname, "../..", "native-git-bridge.ts"),
-      "utf-8"
-    );
-
-    // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
-    const fnStart = src.indexOf("export function nativeMergeSquash");
-    assert.ok(fnStart !== -1, "nativeMergeSquash function exists in source");
-
-    const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
-    const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
-    assert.ok(
-      hasEnv,
-      "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
-    );
+  test('nativeMergeSquash succeeds under non-English locale env', () => {
+    const repo = initTempRepo();
+    try {
+      const mainBranch = git(repo, "branch", "--show-current");
+      git(repo, "checkout", "-b", "feature");
+      createFile(repo, "src/feature.ts", "export const feature = true;");
+      git(repo, "add", "-A");
+      git(repo, "commit", "-m", "feat: add feature");
+      git(repo, "checkout", mainBranch);
+
+      const origLcAll = process.env.LC_ALL;
+      const origLang = process.env.LANG;
+      process.env.LANG = "de_DE.UTF-8";
+      delete process.env.LC_ALL;
+      try {
+        const result = nativeMergeSquash(repo, "feature");
+        assert.equal(result.success, true);
+      } finally {
+        if (origLcAll !== undefined) process.env.LC_ALL = origLcAll;
+        else delete process.env.LC_ALL;
+        if (origLang !== undefined) process.env.LANG = origLang;
+        else delete process.env.LANG;
+      }
+
+      const staged = git(repo, "diff", "--cached", "--name-only");
+      assert.ok(staged.includes("src/feature.ts"));
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Git service integration and commit-message tests.
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
@@ -211,7 +213,12 @@ describe('git-service', async () => {
   test('buildTaskCommitMessage', () => {
     const msg = buildTaskCommitMessage({
       taskId: "S01/T02",
+      taskDisplayId: "T02",
       taskTitle: "implement user authentication",
+      milestoneId: "M001",
+      milestoneTitle: "User management",
+      sliceId: "S01",
+      sliceTitle: "Authentication",
       oneLiner: "Added JWT-based auth with refresh token rotation",
       keyFiles: ["src/auth.ts", "src/middleware/jwt.ts"],
     });
@@ -220,7 +227,12 @@ describe('git-service', async () => {
     assert.ok(msg.includes("JWT-based auth"), "message includes one-liner content");
     assert.ok(msg.includes("- src/auth.ts"), "message body includes key files");
     assert.ok(msg.includes("- src/middleware/jwt.ts"), "message body includes second key file");
+    assert.ok(msg.includes("GSD context:"), "message includes human GSD context block");
+    assert.ok(msg.includes("- Milestone: M001 - User management"), "message includes milestone name");
+    assert.ok(msg.includes("- Slice: S01 - Authentication"), "message includes slice name");
+    assert.ok(msg.includes("- Task: T02 - implement user authentication"), "message includes task name");
     assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer in body");
+    assert.ok(!msg.includes("chore: auto-commit after execute-task"), "message does not use generic fallback");
   });
 
   test('buildTaskCommitMessage sanitizes subject text', () => {
@@ -542,6 +554,60 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // Regression: #5500. The LLM occasionally hallucinates files in
+  // task.keyFiles that were never written. Pre-existing scoped-stage code
+  // ran `git add -- <every keyFile>` and failed the entire commit on the
+  // first missing path. Verify that valid paths still commit and missing
+  // ones are dropped silently.
+  test('GitServiceImpl: scoped staging drops missing keyFiles and commits the rest', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/index.ts", "export const ok = true;");
+    // Note: src/commands/list.ts is intentionally NOT created — the LLM
+    // claimed it wrote this file but didn't.
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T02", [], {
+      taskId: "S01/T02",
+      taskTitle: "wire up command list",
+      oneLiner: "Added list command stub",
+      keyFiles: ["src/index.ts", "src/commands/list.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit succeeds when at least one keyFile exists");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/index.ts"), "existing key file is committed");
+    assert.ok(!committed.includes("src/commands/list.ts"), "missing key file is silently dropped");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  // Regression: #5500. When ALL keyFiles are bogus, scopedStageTaskFiles
+  // must return false so autoCommit falls back to smartStage. The commit
+  // still goes out (using `git add -A` semantics) instead of failing.
+  test('GitServiceImpl: all missing keyFiles falls back to smartStage', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, "src/actually-changed.ts", "export const real = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T03", [], {
+      taskId: "S01/T03",
+      taskTitle: "fix path handling",
+      oneLiner: "Hardened path resolution",
+      keyFiles: ["src/wrong/path-1.ts", "src/wrong/path-2.ts"],
+    });
+    assert.ok(msg !== null, "autoCommit falls back to smartStage when all keyFiles are missing");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(
+      committed.includes("src/actually-changed.ts"),
+      "smartStage fallback stages real dirty files when scoped staging finds nothing",
+    );
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── GitServiceImpl: empty-after-staging guard ─────────────────────────
 
   test('GitServiceImpl: empty-after-staging guard', () => {

package/src/resources/extensions/gsd/tests/integration/milestone-transition-worktree.test.ts

@@ -4,8 +4,6 @@
  * Verifies that when auto-mode transitions between milestones, the
  * worktree lifecycle is handled: old worktree merged, new worktree created.
  *
- * Uses source-level checks since the full auto-mode dispatch loop
- * requires the @gsd/pi-coding-agent runtime.
  */
 
 import test from "node:test";
@@ -119,48 +117,3 @@ test("worktree swap on milestone transition: merge old, create new", () => {
     }
   }
 });
-
-// ─── Verify the transition code path exists in auto.ts ──────────────────────
-
-test("auto/phases.ts milestone transition block contains worktree lifecycle", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "../..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // The resolver handles worktree merge + enter inside the milestone transition block
-  assert.ok(
-    phasesSrc.includes("Worktree lifecycle on milestone transition"),
-    "auto/phases.ts should contain the worktree lifecycle comment marker",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.mergeAndExit") && phasesSrc.includes("mid !== s.currentMilestoneId"),
-    "auto/phases.ts should call resolver.mergeAndExit during milestone transition",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.enterMilestone"),
-    "auto/phases.ts should call resolver.enterMilestone for incoming milestone",
-  );
-});
-
-// ─── Verify worktree-resolver mergeAndExit preserves branch on missing roadmap (#1573) ──
-
-test("worktree-resolver mergeAndExit preserves branch when roadmap is missing (#1573)", () => {
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // The fallback teardown must pass preserveBranch: true to prevent orphaning commits
-  assert.ok(
-    resolverSrc.includes("preserveBranch: true"),
-    "worktree-resolver.ts should pass preserveBranch: true in the no-roadmap fallback",
-  );
-
-  // The worktree path should be tried as a fallback for roadmap resolution
-  assert.ok(
-    resolverSrc.includes("this.s.basePath !== originalBase") ||
-      resolverSrc.includes("roadmap-fallback"),
-    "worktree-resolver.ts should try resolving roadmap from worktree path as fallback",
-  );
-});

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