gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

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,65 +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)', () => {
-    // Pin to the specific guard usage (`currentBranch.startsWith(...)`) so
-    // unrelated occurrences of `startsWith("milestone/")` elsewhere in the
-    // file (e.g. branch-name iteration helpers added later) don't shift the
-    // index and break this structural assertion.
-    const milestoneIdx = source.indexOf('currentBranch.startsWith("milestone/")');
-    assert.ok(milestoneIdx > 0, 'isolation:none guard 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);
   });
 });

package/src/resources/extensions/gsd/tests/lazy-pi-tui-import.test.ts

@@ -1,15 +1,53 @@
-// Structural contract: shared/mod.ts must never import @gsd/pi-tui.
-// TUI-dependent exports live in shared/tui.ts instead.
+// GSD2 — Shared barrel import behavior without TUI dependency loading
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-test("shared/mod.ts has no import from @gsd/pi-tui", () => {
-  const src = readFileSync(join(__dirname, "../../shared/mod.ts"), "utf-8");
-  assert.ok(!src.includes("@gsd/pi-tui"), "mod.ts must not import @gsd/pi-tui");
+test("shared/mod.ts imports without resolving @gsd/pi-tui", () => {
+  const tmp = mkdtempSync(join(process.env.TMPDIR ?? "/tmp", "gsd-shared-mod-"));
+  const loaderPath = join(tmp, "block-pi-tui-loader.mjs");
+  writeFileSync(
+    loaderPath,
+    [
+      "export async function resolve(specifier, context, nextResolve) {",
+      "  if (specifier === '@gsd/pi-tui') throw new Error('unexpected @gsd/pi-tui import');",
+      "  return nextResolve(specifier, context);",
+      "}",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  try {
+    const sharedModPath = join(__dirname, "../../shared/mod.ts");
+    const resolveTsPath = join(__dirname, "resolve-ts.mjs");
+    const result = spawnSync(
+      process.execPath,
+      [
+        "--experimental-strip-types",
+        "--import",
+        resolveTsPath,
+        "--experimental-loader",
+        loaderPath,
+        "--input-type=module",
+        "--eval",
+        `await import(${JSON.stringify(sharedModPath)});`,
+      ],
+      { encoding: "utf-8" },
+    );
+
+    assert.equal(
+      result.status,
+      0,
+      `shared/mod.ts should import without @gsd/pi-tui; stderr:\n${result.stderr}`,
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 });

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -5,16 +5,11 @@
 
 import { describe, 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";
 
 import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { completeWorkflowIteration } from "../auto/workflow-iteration-completion.ts";
 import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
-
 describe("memory pressure monitoring (#3331)", () => {
   test("measureMemoryPressure reports pressure above threshold", () => {
     const snapshot = measureMemoryPressure({
@@ -41,10 +36,6 @@ describe("memory pressure monitoring (#3331)", () => {
     assert.equal(snapshot.pressured, true);
   });
 
-  test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
-    assert.match(loopSource, /iteration\s*%\s*MEMORY_CHECK_INTERVAL\s*===\s*0/);
-  });
-
   test("memory pressure triggers graceful stopAuto", () => {
     const decision = decideMemoryPressure({
       pressured: true,
@@ -60,34 +51,29 @@ describe("memory pressure monitoring (#3331)", () => {
 });
 
 describe("stuck detection persistence (#3704)", () => {
-  test("loadStuckState function exists", () => {
-    assert.match(loopSource, /function loadStuckState/);
-  });
-
-  test("saveStuckState function exists", () => {
-    assert.match(loopSource, /function saveStuckState/);
-  });
-
-  // Phase C: API changed from (basePath) to (session) — recentUnits is
-  // now reconstructed from unit_dispatches and stuckRecoveryAttempts
-  // persists in runtime_kv (worker scope).
-  test("loopState initialized from persisted state", () => {
-    assert.match(loopSource, /loadStuckState\(s\)/);
-  });
-
-  test("stuck state saved after each iteration", () => {
-    assert.match(loopSource, /saveStuckState\(s,\s*loopState\)/);
-  });
-
   // Phase C: stuck-state.json file IO deleted; persistence moved to
   // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
   // The stuck-state-via-db.test.ts suite covers the round-trip.
 
-  test("completeIteration centralizes stuck-state persistence for both loop paths (#4382)", () => {
-    assert.match(loopSource, /const completeIteration = \(\): void =>/);
-    assert.match(loopSource, /completeWorkflowIteration\(/);
-    assert.match(loopSource, /saveStuckState:\s*\(\)\s*=>\s*saveStuckState\(s,\s*loopState\)/);
-    assert.match(loopSource, /completeIteration,/);
-    assert.match(loopSource, /completeIteration\(\);/);
+  test("completeWorkflowIteration saves stuck state while clearing recovery counters (#4382)", () => {
+    const calls: string[] = [];
+    const state = {
+      consecutiveErrors: 2,
+      consecutiveCooldowns: 1,
+      recentErrorMessages: ["boom"],
+    };
+
+    completeWorkflowIteration(state, {
+      emitIterationEnd: () => calls.push("emit"),
+      saveStuckState: () => calls.push("save"),
+      logIterationComplete: () => calls.push("log"),
+    });
+
+    assert.deepEqual(calls, ["emit", "save", "log"]);
+    assert.deepEqual(state, {
+      consecutiveErrors: 0,
+      consecutiveCooldowns: 0,
+      recentErrorMessages: [],
+    });
   });
 });