gsd-pi 2.71.0-dev.7a61d89 → 2.71.0-dev.e17e0ce

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/login-dialog.test.ts

@@ -0,0 +1,24 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { buildAuthUrlPresentation } from "../login-dialog.js";
+
+describe("LoginDialogComponent", () => {
+	test("shows the full OAuth URL when the hyperlink label is truncated", () => {
+		const presentation = buildAuthUrlPresentation(
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			52,
+		);
+
+		assert.notEqual(
+			presentation.displayUrl,
+			"https://auth.example.com/device?code=ABCD-1234&callback=oauth&state=needs-full-visibility",
+			"narrow terminals should still truncate the hyperlink label",
+		);
+		assert.ok(presentation.fullUrlLines.length > 1, "truncated URLs should expose wrapped full-url lines");
+		assert.match(presentation.fullUrlLines[0] ?? "", /https:\/\/auth\.example\.com\/device\?code=ABCD-1234&/);
+		assert.match(
+			presentation.fullUrlLines[presentation.fullUrlLines.length - 1] ?? "",
+			/state=needs-full-visibility/,
+		);
+	});
+});

package/packages/pi-coding-agent/src/modes/interactive/components/login-dialog.ts

@@ -7,6 +7,27 @@ import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint } from "./keybinding-hints.js";
 
+function wrapPlainText(text: string, width: number): string[] {
+	const lines: string[] = [];
+	const safeWidth = Math.max(1, width);
+	for (let idx = 0; idx < text.length; idx += safeWidth) {
+		lines.push(text.slice(idx, idx + safeWidth));
+	}
+	return lines.length > 0 ? lines : [""];
+}
+
+export function buildAuthUrlPresentation(url: string, terminalColumns: number): {
+	displayUrl: string;
+	fullUrlLines: string[];
+} {
+	const maxUrlWidth = Math.max(20, terminalColumns - 4);
+	const displayUrl = truncateToWidth(url, maxUrlWidth);
+	return {
+		displayUrl,
+		fullUrlLines: displayUrl === url ? [] : wrapPlainText(url, maxUrlWidth),
+	};
+}
+
 /**
  * Login dialog component - replaces editor during OAuth login flow.
  *
@@ -124,14 +145,21 @@ export class LoginDialogComponent extends Container implements Focusable {
 
 		// Truncate the visible URL text so it never wraps (which would break
 		// the OSC 8 hyperlink). The full URL is still the link target.
-		const maxUrlWidth = Math.max(20, this.tui.terminal.columns - 4);
-		const displayUrl = truncateToWidth(url, maxUrlWidth);
+		const { displayUrl, fullUrlLines } = buildAuthUrlPresentation(url, this.tui.terminal.columns);
 		const urlLink = `\x1b]8;;${url}\x07${theme.fg("accent", displayUrl)}\x1b]8;;\x07`;
 		this.contentContainer.addChild(new Text(urlLink, 1, 0));
 
 		const clickHint = process.platform === "darwin" ? "Cmd+click to open" : "Ctrl+click to open";
 		this.contentContainer.addChild(new Text(theme.fg("dim", clickHint), 1, 0));
 
+		if (fullUrlLines.length > 0) {
+			this.contentContainer.addChild(new Spacer(1));
+			this.contentContainer.addChild(new Text(theme.fg("dim", "Full URL:"), 1, 0));
+			for (const line of fullUrlLines) {
+				this.contentContainer.addChild(new Text(theme.fg("dim", line), 1, 0));
+			}
+		}
+
 		if (instructions) {
 			this.contentContainer.addChild(new Spacer(1));
 			this.contentContainer.addChild(new Text(theme.fg("warning", instructions), 1, 0));

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -211,6 +211,8 @@ export interface LoopDeps {
     verbose: boolean,
     startModel: { provider: string; id: string } | null,
     retryContext?: { isRetry: boolean; previousTier?: string },
+    isAutoMode?: boolean,
+    sessionModelOverride?: { provider: string; id: string } | null,
   ) => Promise<{
     routing: { tier: string; modelDowngraded: boolean } | null;
     appliedModel: { provider: string; id: string } | null;

package/src/resources/extensions/gsd/auto/phases.ts

@@ -1183,6 +1183,8 @@ export async function runUnitPhase(
     s.verbose,
     s.autoModeStartModel,
     sidecarItem ? undefined : { isRetry, previousTier },
+    undefined,
+    s.manualSessionModelOverride,
   );
   s.currentUnitRouting =
     modelResult.routing as AutoSession["currentUnitRouting"];

package/src/resources/extensions/gsd/auto/session.ts

@@ -111,6 +111,8 @@ export class AutoSession {
 
   // ── Model state ──────────────────────────────────────────────────────────
   autoModeStartModel: StartModel | null = null;
+  /** Explicit /gsd model pin captured at bootstrap (session-scoped policy override). */
+  manualSessionModelOverride: StartModel | null = null;
   currentUnitModel: Model<Api> | null = null;
   /** Fully-qualified model ID (provider/id) set after selectAndApplyModel + hook overrides (#2899). */
   currentDispatchedModelId: string | null = null;
@@ -222,6 +224,7 @@ export class AutoSession {
 
     // Model
     this.autoModeStartModel = null;
+    this.manualSessionModelOverride = null;
     this.currentUnitModel = null;
     this.currentDispatchedModelId = null;
     this.originalModelId = null;

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -14,6 +14,7 @@ import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet, filterToolsForProvider } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
+import { getSessionModelOverride } from "./session-model-override.js";
 
 export interface ModelSelectionResult {
   /** Routing metadata for metrics recording */
@@ -72,8 +73,15 @@ export async function selectAndApplyModel(
   /** When false (interactive/guided-flow), skip dynamic routing and use the session model.
    *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
   isAutoMode = true,
+  /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
+  sessionModelOverride?: { provider: string; id: string } | null,
 ): Promise<ModelSelectionResult> {
-  const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+  const effectiveSessionModelOverride = sessionModelOverride === undefined
+    ? getSessionModelOverride(ctx.sessionManager.getSessionId())
+    : (sessionModelOverride ?? undefined);
+  const modelConfig = effectiveSessionModelOverride
+    ? undefined
+    : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
   let appliedModel: Model<Api> | null = null;
 

package/src/resources/extensions/gsd/auto-start.ts

@@ -85,6 +85,7 @@ import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { resolveDefaultSessionModel, resolveDynamicRoutingConfig } from "./preferences-models.js";
 import type { WorktreeResolver } from "./worktree-resolver.js";
+import { getSessionModelOverride } from "./session-model-override.js";
 
 export interface BootstrapDeps {
   shouldUseWorktreeIsolation: () => boolean;
@@ -266,12 +267,17 @@ export async function bootstrapAutoSession(
   // Capture the user's session model before guided-flow dispatch can apply a
   // phase-specific planning model for a discuss turn (#2829).
   //
-  // GSD PREFERENCES.md takes priority over the session model from settings.json
-  // (#3517).  The session model (ctx.model) comes from findInitialModel() which
-  // reads defaultProvider/defaultModel from ~/.gsd/agent/settings.json.  When
-  // the user has explicit model preferences in PREFERENCES.md, those should win.
+  // Precedence:
+  // 1) Explicit session override via /gsd model (this session)
+  // 2) GSD model preferences from PREFERENCES.md
+  // 3) Current session model from settings/session restore
+  //
+  // This preserves #3517 defaults while honoring explicit runtime model
+  // selection for subsequent /gsd runs in the same session.
+  const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
   const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
-  const startModelSnapshot = preferredModel
+  const startModelSnapshot = manualSessionOverride
+    ?? preferredModel
     ?? (ctx.model
       ? { provider: ctx.model.provider, id: ctx.model.id }
       : null);
@@ -731,6 +737,7 @@ export async function bootstrapAutoSession(
         id: startModelSnapshot.id,
       };
     }
+    s.manualSessionModelOverride = manualSessionOverride ?? null;
 
     // Apply worker model override from parallel orchestrator (#worker-model).
     // GSD_WORKER_MODEL is injected by the coordinator when parallel.worker_model

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -2043,7 +2043,7 @@ export function mergeMilestoneToMain(
   // 12. Remove worktree directory first (must happen before branch deletion)
   try {
     removeWorktree(originalBasePath_, milestoneId, {
-      branch: null as unknown as string,
+      branch: milestoneBranch,
       deleteBranch: false,
     });
   } catch (err) {

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -8,6 +8,7 @@ import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
+import { setSessionModelOverride } from "../../session-model-override.js";
 import { projectRoot } from "../context.js";
 import { formattedShortcutPair } from "../../shortcut-defs.js";
 
@@ -336,6 +337,17 @@ async function handleModel(trimmedArgs: string, ctx: ExtensionCommandContext, pi
     return;
   }
 
+  // /gsd model is an explicit per-session pin for GSD dispatches.
+  // This is captured at auto bootstrap so it survives internal session
+  // switches during /gsd auto and /gsd next runs.
+  const sessionId = ctx.sessionManager?.getSessionId?.();
+  if (sessionId) {
+    setSessionModelOverride(sessionId, {
+      provider: targetModel.provider,
+      id: targetModel.id,
+    });
+  }
+
   ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}`, "info");
 }
 

package/src/resources/extensions/gsd/session-model-override.ts

@@ -0,0 +1,36 @@
+export interface SessionModelOverride {
+  provider: string;
+  id: string;
+}
+
+const sessionOverrides = new Map<string, SessionModelOverride>();
+
+function normalizeSessionId(sessionId: string): string {
+  return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+
+export function setSessionModelOverride(
+  sessionId: string,
+  override: SessionModelOverride,
+): void {
+  const key = normalizeSessionId(sessionId);
+  if (!key) return;
+  sessionOverrides.set(key, {
+    provider: override.provider,
+    id: override.id,
+  });
+}
+
+export function getSessionModelOverride(
+  sessionId: string,
+): SessionModelOverride | undefined {
+  const key = normalizeSessionId(sessionId);
+  if (!key) return undefined;
+  return sessionOverrides.get(key);
+}
+
+export function clearSessionModelOverride(sessionId: string): void {
+  const key = normalizeSessionId(sessionId);
+  if (!key) return;
+  sessionOverrides.delete(key);
+}

package/src/resources/extensions/gsd/tests/auto-start-model-capture.test.ts

@@ -7,9 +7,8 @@ const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
 const source = readFileSync(sourcePath, "utf-8");
 
 test("bootstrapAutoSession snapshots ctx.model before guided-flow entry (#2829)", () => {
-  // #3517 changed the snapshot to prefer GSD preferences, but the ordering
-  // guarantee still holds: the snapshot must be built before guided-flow.
-  const snapshotIdx = source.indexOf("const startModelSnapshot = preferredModel");
+  // The snapshot ordering guarantee still holds: build snapshot before guided-flow.
+  const snapshotIdx = source.indexOf("const startModelSnapshot = manualSessionOverride");
   assert.ok(snapshotIdx > -1, "auto-start.ts should snapshot model at bootstrap start");
 
   const firstDiscussIdx = source.indexOf('await showSmartEntry(ctx, pi, base, { step: requestedStepMode });');
@@ -29,8 +28,11 @@ test("bootstrapAutoSession restores autoModeStartModel from the early snapshot (
   assert.ok(snapshotRefIdx > -1, "autoModeStartModel should be restored from startModelSnapshot");
 });
 
-test("bootstrapAutoSession prefers GSD PREFERENCES.md over settings.json for start model (#3517)", () => {
-  // resolveDefaultSessionModel() should be called before the snapshot is built
+test("bootstrapAutoSession checks manual session override before preferences", () => {
+  const manualIdx = source.indexOf("const manualSessionOverride = getSessionModelOverride(");
+  assert.ok(manualIdx > -1, "auto-start.ts should read session model override first");
+
+  // resolveDefaultSessionModel() should still be called for fallback behavior
   const preferredIdx = source.indexOf("const preferredModel = resolveDefaultSessionModel(");
   assert.ok(preferredIdx > -1, "auto-start.ts should call resolveDefaultSessionModel()");
 
@@ -38,11 +40,11 @@ test("bootstrapAutoSession prefers GSD PREFERENCES.md over settings.json for sta
   const withProviderIdx = source.indexOf("resolveDefaultSessionModel(ctx.model?.provider)");
   assert.ok(withProviderIdx > -1, "auto-start.ts should pass ctx.model?.provider for bare ID resolution");
 
-  const snapshotIdx = source.indexOf("const startModelSnapshot = preferredModel");
-  assert.ok(snapshotIdx > -1, "startModelSnapshot should use preferredModel when available");
+  const snapshotIdx = source.indexOf("const startModelSnapshot = manualSessionOverride");
+  assert.ok(snapshotIdx > -1, "startModelSnapshot should prefer manual session override");
 
   assert.ok(
-    preferredIdx < snapshotIdx,
-    "resolveDefaultSessionModel() must be called before building startModelSnapshot",
+    manualIdx < snapshotIdx && preferredIdx < snapshotIdx,
+    "manual override and preference fallback must be resolved before building startModelSnapshot",
   );
 });

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

@@ -12,7 +12,7 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, readFileSync, symlinkSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -44,6 +44,27 @@ function createTempRepo(): string {
   return dir;
 }
 
+function createTempRepoWithExternalGsd(): { repo: string; externalState: string } {
+  const realTmp = realpathSync(tmpdir());
+  const repo = realpathSync(mkdtempSync(join(realTmp, "wt-ms-merge-ext-test-")));
+  const externalState = realpathSync(mkdtempSync(join(realTmp, "wt-ms-merge-ext-state-")));
+
+  run("git init", repo);
+  run("git config user.email test@test.com", repo);
+  run("git config user.name Test", repo);
+
+  mkdirSync(join(externalState, "worktrees"), { recursive: true });
+  symlinkSync(externalState, join(repo, ".gsd"));
+
+  writeFileSync(join(repo, "README.md"), "# test\n");
+  writeFileSync(join(externalState, "STATE.md"), "# State\n");
+  run("git add .", repo);
+  run("git commit -m init", repo);
+  run("git branch -M main", repo);
+
+  return { repo, externalState };
+}
+
 /** Minimal roadmap content for mergeMilestoneToMain. */
 function makeRoadmap(milestoneId: string, title: string, slices: Array<{ id: string; title: string }>): string {
   const sliceLines = slices.map(s => `- [x] **${s.id}: ${s.title}**`).join("\n");
@@ -87,6 +108,12 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     return d;
   }
 
+  function freshRepoWithExternalGsd(): { repo: string; externalState: string } {
+    const { repo, externalState } = createTempRepoWithExternalGsd();
+    tempDirs.push(repo, externalState);
+    return { repo, externalState };
+  }
+
   afterEach(() => {
     process.chdir(savedCwd);
     for (const d of tempDirs) {
@@ -638,6 +665,44 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be false when only .gsd/ files were merged");
   });
 
+  test("#2156: mergeMilestoneToMain removes external-state worktrees using the milestone branch name", () => {
+    const { repo, externalState } = freshRepoWithExternalGsd();
+    const wtPath = createAutoWorktree(repo, "M215");
+
+    addSliceToMilestone(repo, wtPath, "M215", "S01", "External cleanup", [
+      { file: "external-cleanup.ts", content: "export const externalCleanup = true;\n", message: "add external cleanup" },
+    ]);
+
+    const realWtPath = realpathSync(wtPath);
+    assert.ok(
+      realWtPath.startsWith(externalState),
+      `worktree should be registered under external .gsd state, got ${realWtPath}`,
+    );
+
+    // Recreate the exact divergence from #1852: local .gsd/ is replaced with a
+    // stale real directory, so worktreePath() no longer matches git's record.
+    unlinkSync(join(repo, ".gsd"));
+    mkdirSync(join(repo, ".gsd", "worktrees", "M215"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "STATE.md"), "# Local stale state\n");
+    writeFileSync(join(repo, ".gsd", "worktrees", "M215", "stale.txt"), "stale local artifact\n");
+
+    const roadmap = makeRoadmap("M215", "External cleanup", [
+      { id: "S01", title: "External cleanup" },
+    ]);
+
+    mergeMilestoneToMain(repo, "M215", roadmap);
+
+    assert.ok(
+      !run("git worktree list", repo).includes("M215"),
+      "merged milestone worktree should be removed from git worktree list",
+    );
+    assert.ok(!existsSync(realWtPath), "real external worktree directory should be removed");
+    assert.ok(
+      !run("git branch", repo).includes("milestone/M215"),
+      "milestone branch should be deleted after merge cleanup",
+    );
+  });
+
   test("#2912: MERGE_HEAD cleaned up after squash-merge conflict", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M291");

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -1,6 +1,6 @@
 /**
  * Tests for model config isolation between concurrent instances (#650, #1065)
- * and GSD preferences override of settings.json defaults (#3517).
+ * and session-scoped model precedence behavior.
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -157,75 +157,60 @@ describe("session model recovery on error (#1065)", () => {
   });
 });
 
-// ─── GSD Preferences override settings.json (#3517) ─────────────────────────
+// ─── Manual session model override precedence ───────────────────────────────
 
-describe("GSD preferences override settings.json for session model (#3517)", () => {
-  it("preferredModel takes priority over ctx.model when both are available", () => {
-    // Simulates auto-start.ts logic: preferredModel ?? ctx.model snapshot
-    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" };
-    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+describe("manual session model override precedence", () => {
+  it("manual session override takes priority over preferences and ctx.model", () => {
+    const manualSessionOverride = { provider: "openai-codex", id: "gpt-5.4" };
+    const preferredModel = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? { provider: ctxModel.provider, id: ctxModel.id };
 
-    assert.equal(startModelSnapshot.provider, "openai-codex",
-      "preferredModel provider should win over ctx.model");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "preferredModel id should win over ctx.model");
+    assert.equal(startModelSnapshot.provider, "openai-codex");
+    assert.equal(startModelSnapshot.id, "gpt-5.4");
+  });
+
+  it("falls back to preferences when no manual override is active", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
+    const preferredModel = { provider: "anthropic", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
+
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
+      ?? { provider: ctxModel.provider, id: ctxModel.id };
+
+    assert.equal(startModelSnapshot.provider, "anthropic");
+    assert.equal(startModelSnapshot.id, "claude-sonnet-4-6");
   });
 
-  it("falls back to ctx.model when no GSD preferences are configured", () => {
+  it("falls back to ctx.model when no manual override or preferences are configured", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
     const preferredModel: { provider: string; id: string } | undefined = undefined;
-    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+    const ctxModel = { provider: "claude-code", id: "claude-opus-4-6" };
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? { provider: ctxModel.provider, id: ctxModel.id };
 
-    assert.equal(startModelSnapshot.provider, "claude-code",
-      "should fall back to ctx.model provider when no preferences");
-    assert.equal(startModelSnapshot.id, "claude-sonnet-4-6",
-      "should fall back to ctx.model id when no preferences");
+    assert.equal(startModelSnapshot.provider, "claude-code");
+    assert.equal(startModelSnapshot.id, "claude-opus-4-6");
   });
 
-  it("handles null ctx.model with no preferences gracefully", () => {
+  it("handles null ctx.model with no override or preferences gracefully", () => {
+    const manualSessionOverride: { provider: string; id: string } | undefined = undefined;
     const preferredModel: { provider: string; id: string } | undefined = undefined;
     // Use a function to prevent TS from narrowing to `never` in the ternary
     function getCtxModel(): { provider: string; id: string } | null { return null; }
     const ctxModel = getCtxModel();
 
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+      ?? preferredModel
       ?? (ctxModel ? { provider: ctxModel.provider, id: ctxModel.id } : null);
 
     assert.equal(startModelSnapshot, null,
-      "should be null when neither preferences nor ctx.model exist");
-  });
-
-  it("bare model ID uses session provider when available", () => {
-    // Simulates: PREFERENCES.md has "gpt-5.4" (no provider), session is openai-codex
-    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" }; // from resolveDefaultSessionModel("openai-codex")
-    const ctxModel = { provider: "openai-codex", id: "claude-sonnet-4-6" };
-
-    const startModelSnapshot = preferredModel
-      ?? { provider: ctxModel.provider, id: ctxModel.id };
-
-    assert.equal(startModelSnapshot.provider, "openai-codex");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "bare model ID from preferences should still override ctx.model");
-  });
-
-  it("stale settings.json does not leak when preferences are set", () => {
-    // Scenario: settings.json has claude-code, PREFERENCES.md has openai-codex
-    const settingsJsonDefault = { provider: "claude-code", id: "claude-sonnet-4-6" };
-    const preferencesModel = { provider: "openai-codex", id: "gpt-5.4" };
-
-    // auto-start.ts captures preferredModel first, which preempts settingsJsonDefault
-    const startModelSnapshot = preferencesModel ?? settingsJsonDefault;
-
-    assert.equal(startModelSnapshot.provider, "openai-codex",
-      "PREFERENCES.md must override stale settings.json provider");
-    assert.equal(startModelSnapshot.id, "gpt-5.4",
-      "PREFERENCES.md must override stale settings.json model");
-    assert.notEqual(startModelSnapshot.provider, settingsJsonDefault.provider,
-      "settings.json provider must NOT leak through");
+      "should be null when no model source is available");
   });
 });

package/src/resources/extensions/gsd/tests/session-model-override.test.ts

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  clearSessionModelOverride,
+  getSessionModelOverride,
+  setSessionModelOverride,
+} from "../session-model-override.js";
+
+const phasesSource = readFileSync(join(import.meta.dirname, "..", "auto", "phases.ts"), "utf-8");
+
+test("setSessionModelOverride stores provider/model for the session", () => {
+  const sessionId = `session-override-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "openai-codex", id: "gpt-5.4" });
+
+  const override = getSessionModelOverride(sessionId);
+  assert.equal(override?.provider, "openai-codex");
+  assert.equal(override?.id, "gpt-5.4");
+});
+
+test("clearSessionModelOverride removes the session override", () => {
+  const sessionId = `session-clear-${Date.now()}`;
+  setSessionModelOverride(sessionId, { provider: "anthropic", id: "claude-sonnet-4-6" });
+  clearSessionModelOverride(sessionId);
+  assert.equal(getSessionModelOverride(sessionId), undefined);
+});
+
+test("auto dispatch threads manual session model override into selectAndApplyModel", () => {
+  assert.ok(
+    phasesSource.includes("s.manualSessionModelOverride"),
+    "auto/phases.ts should pass s.manualSessionModelOverride into selectAndApplyModel",
+  );
+});