@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/doctor-workspace.test.ts

@@ -0,0 +1,207 @@
+/**
+ * doctor-workspace.test.ts — Parent-workspace declared-repository probe (#818).
+ *
+ * Covers:
+ *   - declared child repo path missing on disk → workspace_repo_path_missing
+ *   - declared child repo path exists but is not a git repo → workspace_repo_not_a_repo
+ *   - valid child repos → no workspace issues
+ *   - single-repo (project-mode) project → probe is a no-op
+ *   - non-git parent root is handled gracefully (the common layout)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("doctor flags a declared child repo whose path is missing on disk", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-missing-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // `frontend` is declared but never created on disk.
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    const issue = report.issues.find((i) => i.code === "workspace_repo_path_missing");
+    assert.ok(issue, "expected a workspace_repo_path_missing issue");
+    assert.equal(issue?.unitId, "workspace.repositories.frontend");
+    assert.match(issue?.message ?? "", /does not exist on disk/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor flags a declared child repo path that is not a git repository", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-notrepo-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // `backend` exists as a plain directory but is not a git repo.
+    mkdirSync(join(base, "backend"), { recursive: true });
+    writeParentPrefs(base, { backend: { path: "backend" } });
+
+    const report = await runGSDDoctor(base);
+    const issue = report.issues.find((i) => i.code === "workspace_repo_not_a_repo");
+    assert.ok(issue, "expected a workspace_repo_not_a_repo issue");
+    assert.equal(issue?.unitId, "workspace.repositories.backend");
+    assert.match(issue?.message ?? "", /not a git repository/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor reports no workspace issues when declared child repos are valid", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-valid-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor workspace git probe uses safe env and canonical toplevel comparison", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("POSIX-only git shim regression");
+    return;
+  }
+
+  const originalProcessGitDir = process.env.GIT_DIR;
+  const originalProcessGitWorkTree = process.env.GIT_WORK_TREE;
+  const originalGitEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalGitEnvRealGit = GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+  const originalGitEnvFakeCwd = GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD;
+  const originalGitEnvFakeToplevel = GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL;
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-safeenv-"));
+
+  t.after(() => {
+    if (originalProcessGitDir === undefined) delete process.env.GIT_DIR;
+    else process.env.GIT_DIR = originalProcessGitDir;
+    if (originalProcessGitWorkTree === undefined) delete process.env.GIT_WORK_TREE;
+    else process.env.GIT_WORK_TREE = originalProcessGitWorkTree;
+    if (originalGitEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalGitEnvPath;
+    if (originalGitEnvRealGit === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_GIT = originalGitEnvRealGit;
+    if (originalGitEnvFakeCwd === undefined) delete GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD;
+    else GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD = originalGitEnvFakeCwd;
+    if (originalGitEnvFakeToplevel === undefined) delete GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL;
+    else GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL = originalGitEnvFakeToplevel;
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const realChild = join(base, "frontend-real");
+  const linkedChild = join(base, "frontend");
+  mkdirSync(realChild, { recursive: true });
+  gitInit(realChild);
+  symlinkSync(realChild, linkedChild, "dir");
+  writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+  const shimDir = join(base, "bin");
+  mkdirSync(shimDir, { recursive: true });
+  const realGit = execFileSync("which", ["git"], { encoding: "utf-8" }).trim();
+  const shim = join(shimDir, "git");
+  writeFileSync(
+    shim,
+    [
+      "#!/usr/bin/env bash",
+      "set -euo pipefail",
+      "if [ -n \"${GIT_DIR:-}\" ] || [ -n \"${GIT_WORK_TREE:-}\" ]; then",
+      "  echo \"leaked git env\" >&2",
+      "  exit 97",
+      "fi",
+      "if [ \"${1:-}\" = \"rev-parse\" ] && [ \"${2:-}\" = \"--show-toplevel\" ] && [ \"$(pwd -P)\" = \"$GSD_FAKE_TOPLEVEL_CWD\" ]; then",
+      "  printf '%s\\n' \"$GSD_FAKE_TOPLEVEL\"",
+      "  exit 0",
+      "fi",
+      "exec \"$GSD_REAL_GIT\" \"$@\"",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  chmodSync(shim, 0o755);
+
+  process.env.GIT_DIR = join(base, ".git");
+  process.env.GIT_WORK_TREE = base;
+  GIT_NO_PROMPT_ENV.PATH = `${shimDir}${delimiter}${process.env.PATH ?? ""}`;
+  GIT_NO_PROMPT_ENV.GSD_REAL_GIT = realGit;
+  GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD = realChild;
+  GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL = linkedChild;
+
+  const report = await runGSDDoctor(base);
+  const wsIssues = report.issues.filter(
+    (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+  );
+  assert.deepEqual(wsIssues, []);
+});
+
+test("doctor workspace probe is a no-op for single-repo (project-mode) projects", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-noproj-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const report = await runGSDDoctor(base);
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor runs cleanly when the parent root is itself not a git repo (common layout)", async () => {
+  // Regression guard (#818 cross-cutting): a parent folder holding child git
+  // repos need not be a git repo itself. Doctor must not crash and must not
+  // treat the parent as a missing/non-repo child.
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-nongitparent-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    // NOTE: no gitInit(base) — parent is a plain folder.
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    // The declared child repo is valid; the non-git parent must not produce a
+    // child-repo issue or crash the run.
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts

@@ -13,7 +13,7 @@ import { basename, join } from "node:path";
 import {
   fastForwardReusedMilestoneBranchIfSafe,
   _isBranchCheckedOutElsewhere,
-} from "../auto-worktree.js";
+} from "../auto-worktree-branch-lifecycle.js";
 
 const NO_PROMPT_ENV = {
   ...process.env,

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -2,17 +2,18 @@
 // File Purpose: Tests the one-time migration from nested to flat-phase layout.
 import test, { afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readdirSync, readFileSync, utimesSync } from "node:fs";
+import { mkdtempSync, mkdirSync, renameSync, rmSync, writeFileSync, existsSync, readdirSync, readFileSync, utimesSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import {
+  _setFlatPhaseMigrationFsOpsForTest,
   migrateToFlatPhase,
   needsFlatPhaseMigration,
   pruneStaleFlatPhaseBackups,
 } from "../flat-phase-migration.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertArtifact, insertMilestone, insertSlice, insertTask, getAllMilestones, getMilestoneSlices, getSliceTasks, _getAdapter } from "../gsd-db.ts";
 
 const tmpDirs: string[] = [];
 function makeTmp(options: { withTask?: boolean } = {}): string {
@@ -64,6 +65,42 @@ test("migrateToFlatPhase moves content from milestones/ to phases/", async () =>
   assert.ok(!existsSync(join(base, ".gsd", "milestones")), "milestones/ should be removed");
 });
 
+test("migrateToFlatPhase ignores and removes stale phase dirs from prior aborted runs", async () => {
+  const base = makeTmp();
+  const stalePhaseDir = join(base, ".gsd", "phases", "99-stale-aborted-run");
+  mkdirSync(stalePhaseDir, { recursive: true });
+
+  await migrateToFlatPhase(base);
+
+  assert.ok(existsSync(join(base, ".gsd", "phases", "01-foundation")), "current DB phase should render");
+  assert.equal(existsSync(stalePhaseDir), false, "stale pre-existing phase dir should be removed");
+});
+
+test("migrateToFlatPhase falls back to copy-delete when legacy rename is blocked", async (t) => {
+  const base = makeTmp();
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const migratingPath = join(base, ".gsd", "milestones.migrating");
+  let blockedRenameAttempts = 0;
+
+  const restoreFsOps = _setFlatPhaseMigrationFsOpsForTest({
+    renameSync(src, dst) {
+      if (src === milestonesPath && dst === migratingPath) {
+        blockedRenameAttempts++;
+        throw Object.assign(new Error("simulated busy handle"), { code: "EPERM" });
+      }
+      return renameSync(src, dst);
+    },
+  });
+  t.after(restoreFsOps);
+
+  await migrateToFlatPhase(base);
+
+  assert.equal(blockedRenameAttempts, 1, "test should exercise the rename fallback path");
+  assert.ok(existsSync(join(base, ".gsd", "phases", "01-foundation")), "flat phase should render");
+  assert.equal(existsSync(milestonesPath), false, "legacy milestones dir should be removed");
+  assert.equal(existsSync(migratingPath), false, "staging dir should be removed after success");
+});
+
 test("migrateToFlatPhase creates a backup", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);
@@ -72,6 +109,33 @@ test("migrateToFlatPhase creates a backup", async () => {
   assert.ok(backups.length >= 1, "at least one migrate-* backup dir should exist");
 });
 
+test("failed migration rolls back without leaking a .gsd-backups/migrate-* dir", async (t) => {
+  const base = makeTmp();
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const phasesPath = join(base, ".gsd", "phases");
+
+  // Fail the pre-render clear of phases/ to drive the rollback path, which by
+  // this point has already created the .gsd-backups/migrate-<ts>/ backup.
+  const restoreFsOps = _setFlatPhaseMigrationFsOpsForTest({
+    rmSync(target, opts) {
+      if (target === phasesPath) {
+        throw Object.assign(new Error("simulated locked phases/"), { code: "EPERM" });
+      }
+      return rmSync(target, opts as never);
+    },
+  });
+  t.after(restoreFsOps);
+
+  await assert.rejects(migrateToFlatPhase(base), /simulated locked/);
+
+  assert.ok(existsSync(milestonesPath), "legacy milestones/ should be restored on rollback");
+  const backupRoot = join(base, ".gsd-backups");
+  const leaked = existsSync(backupRoot)
+    ? readdirSync(backupRoot).filter((d) => d.startsWith("migrate-"))
+    : [];
+  assert.equal(leaked.length, 0, "rollback must delete the migrate-* backup it created");
+});
+
 test("migrateToFlatPhase preserves milestone/slice/task counts in DB", async () => {
   const base = makeTmp();
   const msBefore = getAllMilestones().length;
@@ -83,6 +147,49 @@ test("migrateToFlatPhase preserves milestone/slice/task counts in DB", async ()
   assert.equal(getSliceTasks("M001", "S01").length, tasksBefore);
 });
 
+test("migrateToFlatPhase prunes legacy milestones artifact rows after flat render", async () => {
+  const base = makeTmp();
+  insertArtifact({
+    path: "milestones/M001/M001-ROADMAP.md",
+    artifact_type: "ROADMAP",
+    milestone_id: "M001",
+    slice_id: null,
+    task_id: null,
+    full_content: "# M001: Foundation\n",
+  });
+  insertArtifact({
+    path: "milestones/M001/slices/S01/S01-PLAN.md",
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: null,
+    full_content: "# Plan\n",
+  });
+  insertArtifact({
+    path: "milestones/M001/slices/S01/tasks/T01-PLAN.md",
+    artifact_type: "PLAN",
+    milestone_id: "M001",
+    slice_id: "S01",
+    task_id: "T01",
+    full_content: "# Task Plan\n",
+  });
+
+  await migrateToFlatPhase(base);
+
+  const rows = _getAdapter()!
+    .prepare("SELECT path FROM artifacts ORDER BY path")
+    .all() as Array<{ path: string }>;
+  assert.equal(
+    rows.some((row) => row.path.startsWith("milestones/")),
+    false,
+    "legacy milestones/ artifact rows should be pruned after successful flat migration",
+  );
+  assert.ok(
+    rows.some((row) => row.path.startsWith("phases/")),
+    "flat-phase render should leave replacement projection rows in the artifacts table",
+  );
+});
+
 test("migrateToFlatPhase is idempotent (second run is a no-op)", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);

package/src/resources/extensions/gsd/tests/flat-phase-renderer.test.ts

@@ -7,7 +7,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { renderPlanFromDb, renderRoadmapFromDb } from "../markdown-renderer.ts";
+import { renderPlanFromDb, renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.ts";
+import { clearPathCache } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
 
 const tmpDirs: string[] = [];
@@ -81,3 +82,26 @@ test("renderPlanFromDb does NOT write per-task plan files", async () => {
   // taskPlanPaths should be empty — no per-task files written
   assert.equal(result.taskPlanPaths.length, 0);
 });
+
+// Regression for #1190: a stray slices/SID/ subdir inside a flat-phase milestone
+// must not divert the ASSESSMENT write into slices/SID/ (a hybrid path that
+// auto-mode verification cannot find). It must land at the phase root.
+test("renderAssessmentFromDb writes to the phase root even when a stray slices/SID/ dir exists", async () => {
+  const base = makeTmp();
+  const plan = await renderPlanFromDb(base, "M001", "S01");
+  const phaseDir = plan.planPath.slice(0, plan.planPath.lastIndexOf("01-01-PLAN.md"));
+
+  // Simulate the anomaly: an earlier planning step created slices/S01/ inside
+  // the flat-phase dir.
+  mkdirSync(join(phaseDir, "slices", "S01"), { recursive: true });
+  clearPathCache();
+
+  const result = await renderAssessmentFromDb(base, "M001", "S01", {
+    verdict: "on-track",
+    assessment: "Roadmap is on track.",
+  });
+
+  assert.match(result.assessmentPath, /phases[/\\]01-[^/\\]+[/\\]01-01-ASSESSMENT\.md$/);
+  assert.ok(!result.assessmentPath.includes(join("slices", "S01")), "must not write under slices/S01/");
+  assert.ok(existsSync(result.assessmentPath), "assessment file should exist at the phase root");
+});

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -1,7 +1,6 @@
 /**
- * Regression test for #3453: dynamic model routing must be disabled for
- * flat-rate providers like GitHub Copilot where all models cost the same
- * per request — routing only degrades quality with no cost benefit.
+ * Regression tests for flat-rate provider detection and the explicit opt-out
+ * that suppresses dynamic routing for subscription providers.
  */
 
 import { describe, test } from "node:test";
@@ -9,7 +8,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig, selectAndApplyModel } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -35,23 +34,18 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(isFlatRateProvider("openai"), false);
   });
 
-  test("resolvePreferredModelConfig returns undefined for copilot start model", () => {
+  test("resolvePreferredModelConfig synthesizes routing config for copilot start model when routing is enabled", () => {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
     const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
     const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
 
-    // When the user's start model is on a flat-rate provider,
-    // resolvePreferredModelConfig should not synthesize a routing
-    // config from tier_models — it should return undefined so the
-    // user's selected model is preserved.
     try {
       mkdirSync(join(tempProject, ".gsd"), { recursive: true });
       writeFileSync(
         join(tempProject, ".gsd", "PREFERENCES.md"),
         [
           "---",
-          "token_profile: burn-max",
           "dynamic_routing:",
           "  enabled: true",
           "  tier_models:",
@@ -70,10 +64,83 @@ describe("flat-rate provider routing guard (#3453)", () => {
         id: "claude-sonnet-4",
       });
 
-      // Should be undefined (no routing config created for flat-rate)
-      // Note: this only tests the synthesis guard — explicit per-unit config
-      // still takes precedence when the user configured one.
-      assert.equal(result, undefined, "Should not create routing config for copilot");
+      assert.deepEqual(result, {
+        primary: "claude-opus-4-6",
+        fallbacks: [],
+        source: "synthesized",
+      });
+    } 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("selectAndApplyModel runs synthesized dynamic routing for flat-rate start model", async () => {
+    const originalCwd = process.cwd();
+    const originalGsdHome = process.env.GSD_HOME;
+    const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
+    const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
+    const setModelCalls: string[] = [];
+
+    try {
+      mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+      writeFileSync(
+        join(tempProject, ".gsd", "PREFERENCES.md"),
+        [
+          "---",
+          "dynamic_routing:",
+          "  enabled: true",
+          "  hooks: false",
+          "  budget_pressure: false",
+          "  tier_models:",
+          "    light: claude-haiku-4-5",
+          "    standard: claude-sonnet-4-6",
+          "    heavy: claude-opus-4-6",
+          "---",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_HOME = tempGsdHome;
+      process.chdir(tempProject);
+
+      const availableModels = [
+        { id: "claude-haiku-4-5", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-sonnet-4-6", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-opus-4-6", provider: "claude-code", api: "anthropic-messages" },
+      ];
+
+      const result = await selectAndApplyModel(
+        {
+          modelRegistry: { getAvailable: () => availableModels },
+          sessionManager: { getSessionId: () => "test-session" },
+          ui: { notify: () => {} },
+          model: { provider: "claude-code", id: "claude-opus-4-6", api: "anthropic-messages" },
+        } as any,
+        {
+          setModel: async (model: { provider: string; id: string }) => {
+            setModelCalls.push(`${model.provider}/${model.id}`);
+            return true;
+          },
+          emitBeforeModelSelect: async () => undefined,
+          getActiveTools: () => [],
+          emitAdjustToolSet: async () => undefined,
+          setActiveTools: () => {},
+        } as any,
+        "execute-task",
+        "M001/S01/T01",
+        tempProject,
+        undefined,
+        false,
+        { provider: "claude-code", id: "claude-opus-4-6" },
+        undefined,
+        true,
+      );
+
+      assert.deepEqual(setModelCalls, ["claude-code/claude-sonnet-4-6"]);
+      assert.deepEqual(result.routing, { tier: "standard", modelDowngraded: true });
     } finally {
       process.chdir(originalCwd);
       if (originalGsdHome === undefined) delete process.env.GSD_HOME;
@@ -220,9 +287,9 @@ describe("buildFlatRateContext()", () => {
   });
 });
 
-// ─── #4386: allow_flat_rate_providers opt-in ────────────────────────────────
+// ─── #4386/#1115: allow_flat_rate_providers override ────────────────────────
 
-describe("flat-rate routing opt-in (#4386)", () => {
+describe("flat-rate routing override (#4386/#1115)", () => {
   function withPrefs(prefsYaml: string, fn: () => void): void {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
@@ -247,7 +314,7 @@ describe("flat-rate routing opt-in (#4386)", () => {
     }
   }
 
-  test("default (opt-in absent): flat-rate start model still returns undefined", () => {
+  test("default (allow absent): flat-rate start model still synthesizes routing config", () => {
     withPrefs(
       [
         "dynamic_routing:",
@@ -260,12 +327,13 @@ describe("flat-rate routing opt-in (#4386)", () => {
           provider: "claude-code",
           id: "claude-opus-4-6",
         });
-        assert.equal(result, undefined, "default must preserve #3453 bypass");
+        assert.ok(result, "routing config should be synthesized");
+        assert.equal(result!.primary, "claude-opus-4-6");
       },
     );
   });
 
-  test("opt-in: synthesizes a routing config for flat-rate start model", () => {
+  test("explicit allow: synthesizes a routing config for flat-rate start model", () => {
     withPrefs(
       [
         "dynamic_routing:",