gsd-pi 2.70.0 → 2.70.1-dev.bef631a

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

@@ -0,0 +1,207 @@
+// 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";
+
+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 = modelSelectionSrc.slice(fnIdx, fnIdx + 600);
+    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"),
+      "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 closing brace pattern
+    const block = modelSelectionSrc.slice(escalatedIdx, escalatedIdx + 400);
+    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",
+    );
+  });
+
+  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",
+    );
+  });
+
+  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",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -12,7 +12,7 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import { normalizeFilePath, checkFilePathConsistency } from '../pre-execution-checks.ts'
-import { readFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 const src = readFileSync(
@@ -25,6 +25,11 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('`src/foo.ts`'), 'src/foo.ts')
   })
 
+  it('strips doubled backticks and trailing notes from file paths', () => {
+    assert.equal(normalizeFilePath('``src/foo.ts`` - current state'), 'src/foo.ts')
+    assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })
@@ -66,3 +71,45 @@ describe('checkFilePathConsistency checks task.inputs not task.files (#3626)', (
     )
   })
 })
+
+describe('checkFilePathConsistency handles doubled-backtick annotations (#3892)', () => {
+  it('accepts existing files when task.inputs include doubled-backtick notes', () => {
+    const task = {
+      milestone_id: 'M001',
+      slice_id: 'S01',
+      id: 'T01',
+      title: 'Test Task',
+      status: 'pending',
+      one_liner: '',
+      narrative: '',
+      verification_result: '',
+      duration: '',
+      completed_at: null,
+      blocker_discovered: false,
+      deviations: '',
+      known_issues: '',
+      key_files: [],
+      key_decisions: [],
+      full_summary_md: '',
+      description: '',
+      estimate: '',
+      files: [],
+      verify: '',
+      inputs: ['``src/foo.ts`` (current state)'],
+      expected_output: [],
+      observability_impact: '',
+      full_plan_md: '',
+      sequence: 0,
+    }
+
+    const tmp = resolve(process.cwd(), '.tmp-pre-exec-3892')
+    try {
+      mkdirSync(resolve(tmp, 'src'), { recursive: true })
+      writeFileSync(resolve(tmp, 'src', 'foo.ts'), '// ok')
+      const results = checkFilePathConsistency([task as any], tmp)
+      assert.deepEqual(results, [])
+    } finally {
+      rmSync(tmp, { recursive: true, force: true })
+    }
+  })
+})

package/src/resources/extensions/gsd/tests/resource-loader-import-path.test.ts

@@ -22,16 +22,17 @@ describe("resource-loader import path", () => {
     );
   });
 
-  test("uses createRequire to resolve resource-loader from package root", () => {
-    // The fix uses createRequire to find gsd-pi/package.json, then imports
-    // dist/resource-loader.js from there — works in both source and deployed.
+  test("uses GSD_PKG_ROOT to resolve resource-loader from package root", () => {
+    // The fix uses GSD_PKG_ROOT (set by loader.ts) to construct an absolute
+    // file URL to dist/resource-loader.js — works in both source and deployed,
+    // and on Windows where raw paths fail with ERR_UNSUPPORTED_ESM_URL_SCHEME.
     assert.ok(
-      autoSrc.includes('createRequire(import.meta.url)'),
-      "auto.ts should use createRequire to resolve resource-loader",
+      autoSrc.includes('process.env.GSD_PKG_ROOT'),
+      "auto.ts should use GSD_PKG_ROOT to resolve resource-loader",
     );
     assert.ok(
-      autoSrc.includes('resolve("gsd-pi/package.json")'),
-      "auto.ts should resolve gsd-pi package root via package.json",
+      autoSrc.includes('pathToFileURL'),
+      "auto.ts should convert path to file URL for cross-platform import()",
     );
   });
 });

package/src/resources/extensions/gsd/tests/validate-directory.test.ts

@@ -74,6 +74,27 @@ test("validateDirectory: C:\\Windows is blocked", { skip: !isWindows ? "Windows-
   assert.equal(result.severity, "blocked");
 });
 
+test("validateDirectory: D:\\Windows is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("D:\\Windows");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: E:\\Program Files is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("E:\\Program Files");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
+test("validateDirectory: any Windows drive root is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
+  const result = validateDirectory("D:\\");
+  assert.equal(result.safe, false);
+  assert.equal(result.severity, "blocked");
+  assert.ok(result.reason?.includes("system directory"));
+});
+
 // ─── Home directory (cross-platform) ─────────────────────────────────────────────
 
 test("validateDirectory: home directory itself is blocked", () => {
@@ -104,7 +125,13 @@ test("validateDirectory: subdirectory of home is NOT blocked", () => {
 // Regression test for #1317: GSD worktree inside $HOME must not be blocked even
 // when the resolved project root equals $HOME (e.g. home dir is a git repo).
 test("validateDirectory: GSD worktree path nested under home is NOT blocked (#1317)", () => {
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  const fakeHome = makeTempDir("fake-home");
+  process.env.HOME = fakeHome;
+  process.env.USERPROFILE = fakeHome;
   const worktreePath = join(homedir(), ".gsd", "worktrees", "M001");
+  const worktreeRoot = join(fakeHome, ".gsd", "worktrees", "M001");
   mkdirSync(worktreePath, { recursive: true });
   try {
     // The worktree CWD itself is a valid location — it must pass.
@@ -112,7 +139,12 @@ test("validateDirectory: GSD worktree path nested under home is NOT blocked (#13
     assert.equal(result.safe, true, "GSD worktree path should be safe to run in");
     assert.equal(result.severity, "ok");
   } finally {
-    rmSync(join(homedir(), ".gsd", "worktrees", "M001"), { recursive: true, force: true });
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+    rmSync(worktreeRoot, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
   }
 });
 

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -9,10 +9,11 @@ import { deriveState, isValidationTerminal } from "../state.ts";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact } from "../auto-artifact-paths.ts";
 import { verifyExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
 import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
-import { buildValidateMilestonePrompt } from "../auto-prompts.ts";
+import { buildCompleteMilestonePrompt, buildValidateMilestonePrompt } from "../auto-prompts.ts";
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";
 import { clearParseCache } from "../files.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
@@ -25,9 +26,15 @@ function makeTmpBase(): string {
 function cleanup(base: string): void {
   clearPathCache();
   clearParseCache();
+  closeDatabase();
   try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
 }
 
+function openTestDb(base: string): void {
+  const dbPath = join(base, ".gsd", "gsd.db");
+  assert.equal(openDatabase(dbPath), true, "test DB should open");
+}
+
 function writeRoadmap(base: string, mid: string, content: string): void {
   const dir = join(base, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -218,6 +225,85 @@ test("buildValidateMilestonePrompt inlines ASSESSMENT evidence instead of UAT sp
   }
 });
 
+test("buildCompleteMilestonePrompt skips skipped slices from DB-backed summary inlining", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > Done
+- [ ] **S02: Skipped slice** \`risk:low\` \`depends:[]\`
+  > Intentionally skipped
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`);
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
+
+    const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+    assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
+    assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
+    assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildValidateMilestonePrompt skips skipped slices from DB-backed summary inlining", async () => {
+  const base = makeTmpBase();
+  try {
+    writeRoadmap(base, "M001", `# M001: Test Milestone
+
+## Vision
+Test
+
+## Success Criteria
+- It works
+
+## Slices
+
+- [x] **S01: First slice** \`risk:low\` \`depends:[]\`
+  > Done
+- [ ] **S02: Skipped slice** \`risk:low\` \`depends:[]\`
+  > Intentionally skipped
+
+## Boundary Map
+
+| From | To | Produces | Consumes |
+|------|-----|----------|----------|
+| S01  | terminal | output | nothing |
+`);
+    openTestDb(base);
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First slice", status: "complete", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Skipped slice", status: "skipped", depends: [], sequence: 2 });
+    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDelivered.");
+    writeSliceAssessment(base, "M001", "S01", "---\nverdict: PASS\n---\n# Assessment\nEvidence captured.");
+
+    const prompt = await buildValidateMilestonePrompt("M001", "Test Milestone", base);
+    assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
+    assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
+    assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Dispatch rule ────────────────────────────────────────────────────────
 
 test("dispatch rule matches validating-milestone phase", async () => {

package/src/resources/extensions/gsd/tests/workflow-mcp-auto-prep.test.ts

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { prepareWorkflowMcpForProject, shouldAutoPrepareWorkflowMcp } from "../workflow-mcp-auto-prep.ts";
+
+test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "claude-code", baseUrl: "local://claude-code" },
+    modelRegistry: {
+      getProviderAuthMode: () => "externalCli",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is ready", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: (provider: string) => provider === "claude-code",
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp enables prep when claude-code provider is registered", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: (provider: string) => provider === "claude-code" ? "externalCli" : "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, true);
+});
+
+test("shouldAutoPrepareWorkflowMcp stays disabled when neither transport nor provider readiness match", () => {
+  const result = shouldAutoPrepareWorkflowMcp({
+    model: { provider: "openai", baseUrl: "https://api.openai.com" },
+    modelRegistry: {
+      getProviderAuthMode: () => "apiKey",
+      isProviderRequestReady: () => false,
+    },
+  });
+
+  assert.equal(result, false);
+});
+
+test("prepareWorkflowMcpForProject warns with /gsd mcp init guidance when prep fails", () => {
+  const notifications: Array<{ message: string; level: "info" | "warning" | "error" | "success" }> = [];
+  const result = prepareWorkflowMcpForProject(
+    {
+      model: { provider: "claude-code", baseUrl: "local://claude-code" },
+      modelRegistry: {
+        getProviderAuthMode: () => "externalCli",
+        isProviderRequestReady: () => true,
+      },
+      ui: {
+        notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+          notifications.push({ message, level: level ?? "info" });
+        },
+      },
+    },
+    "/",
+  );
+
+  assert.equal(result, null);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0].level, "warning");
+  assert.match(notifications[0].message, /Please run \/gsd mcp init \./);
+});