gsd-pi 2.29.0-dev.77f06e2 → 2.29.0-dev.953d788

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -260,57 +260,27 @@ async function configureModels(ctx: ExtensionCommandContext, prefs: Record<strin
       group.push(m);
     }
     const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-    // Sort models within each provider
-    for (const group of byProvider.values()) {
-      group.sort((a, b) => a.id.localeCompare(b.id));
-    }
 
-    // Build provider menu with model counts
-    const providerOptions = providers.map(p => {
-      const count = byProvider.get(p)!.length;
-      return `${p} (${count} models)`;
-    });
-    providerOptions.push("(keep current)", "(clear)", "(type manually)");
+    const modelOptions: string[] = [];
+    for (const provider of providers) {
+      const group = byProvider.get(provider)!;
+      modelOptions.push(`─── ${provider} (${group.length}) ───`);
+      for (const m of group) {
+        modelOptions.push(`${m.id} · ${m.provider}`);
+      }
+    }
+    modelOptions.push("(keep current)", "(clear)");
 
     for (const phase of modelPhases) {
       const current = models[phase] ?? "";
-      const phaseLabel = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}`;
-
-      // Step 1: pick provider
-      const providerChoice = await ctx.ui.select(`${phaseLabel} — choose provider:`, providerOptions);
-      if (!providerChoice || typeof providerChoice !== "string" || providerChoice === "(keep current)") continue;
-
-      if (providerChoice === "(clear)") {
-        delete models[phase];
-        continue;
-      }
-
-      if (providerChoice === "(type manually)") {
-        const input = await ctx.ui.input(
-          `${phaseLabel} — enter model ID:`,
-          current || "e.g. claude-sonnet-4-20250514",
-        );
-        if (input !== null && input !== undefined) {
-          const val = input.trim();
-          if (val) models[phase] = val;
-        }
-        continue;
-      }
-
-      // Step 2: pick model within provider
-      const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
-      const group = byProvider.get(providerName);
-      if (!group) continue;
-
-      const modelOptions = group.map(m => m.id);
-      modelOptions.push("(keep current)", "(clear)");
+      const title = `Model for ${phase} phase${current ? ` (current: ${current})` : ""}:`;
+      const choice = await ctx.ui.select(title, modelOptions);
 
-      const modelChoice = await ctx.ui.select(`${phaseLabel} — ${providerName}:`, modelOptions);
-      if (modelChoice && typeof modelChoice === "string" && modelChoice !== "(keep current)") {
-        if (modelChoice === "(clear)") {
+      if (choice && typeof choice === "string" && choice !== "(keep current)") {
+        if (choice === "(clear)") {
           delete models[phase];
         } else {
-          models[phase] = modelChoice;
+          models[phase] = choice.split(" · ")[0];
         }
       }
     }

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

@@ -13,8 +13,7 @@ import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
 import { showQueue, showDiscuss, showHeadlessMilestoneCreation } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote } from "./auto.js";
-import { dispatchDirectPhase } from "./auto-direct-dispatch.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote, dispatchDirectPhase } from "./auto.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import {
@@ -22,6 +21,8 @@ import {
   getProjectGSDPreferencesPath,
   loadEffectiveGSDPreferences,
 } from "./preferences.js";
+import { loadPrompt } from "./prompt-loader.js";
+
 import { handleRemote } from "../remote-questions/mod.js";
 import { handleQuick } from "./quick.js";
 import { handleHistory } from "./history.js";
@@ -43,9 +44,26 @@ import { handleInspect } from "./commands-inspect.js";
 import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleDryRun } from "./commands-maintenance.js";
 import { handleDoctor, handleSteer, handleCapture, handleTriage, handleKnowledge, handleRunHook, handleUpdate, handleSkillHealth } from "./commands-handlers.js";
 import { handleLogs } from "./commands-logs.js";
-import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
 
 
+export function dispatchDoctorHeal(pi: ExtensionAPI, scope: string | undefined, reportText: string, structuredIssues: string): void {
+  const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+  const workflow = readFileSync(workflowPath, "utf-8");
+  const prompt = loadPrompt("doctor-heal", {
+    doctorSummary: reportText,
+    structuredIssues,
+    scopeLabel: scope ?? "active milestone / blocking scope",
+    doctorCommandSuffix: scope ? ` ${scope}` : "",
+  });
+
+  const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
+
+  pi.sendMessage(
+    { customType: "gsd-doctor-heal", content, display: false },
+    { triggerTurn: true },
+  );
+}
+
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot(): string {
   const root = resolveProjectRoot(process.cwd());
@@ -55,7 +73,7 @@ export function projectRoot(): string {
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
-    description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge|new-milestone|parallel|update",
+    description: "GSD — Get Shit Done: /gsd help|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|migrate|remote|steer|knowledge|new-milestone|parallel|update",
     getArgumentCompletions: (prefix: string) => {
       const subcommands = [
         { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -98,8 +116,6 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         { cmd: "park", desc: "Park a milestone — skip without deleting" },
         { cmd: "unpark", desc: "Reactivate a parked milestone" },
         { cmd: "update", desc: "Update GSD to the latest version" },
-        { cmd: "start", desc: "Start a workflow template (bugfix, spike, feature, etc.)" },
-        { cmd: "templates", desc: "List available workflow templates" },
       ];
       const parts = prefix.trim().split(/\s+/);
 
@@ -285,42 +301,6 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
           .map((s) => ({ value: `knowledge ${s.cmd}`, label: s.cmd, description: s.desc }));
       }
 
-      if (parts[0] === "start" && parts.length <= 2) {
-        const subPrefix = parts[1] ?? "";
-        const subs = [
-          { cmd: "bugfix", desc: "Triage, fix, test, and ship a bug fix" },
-          { cmd: "small-feature", desc: "Lightweight feature with optional discussion" },
-          { cmd: "spike", desc: "Research, prototype, and document findings" },
-          { cmd: "hotfix", desc: "Minimal: fix it, test it, ship it" },
-          { cmd: "refactor", desc: "Inventory, plan waves, migrate, verify" },
-          { cmd: "security-audit", desc: "Scan, triage, remediate, re-scan" },
-          { cmd: "dep-upgrade", desc: "Assess, upgrade, fix breaks, verify" },
-          { cmd: "full-project", desc: "Complete GSD workflow with full ceremony" },
-          { cmd: "resume", desc: "Resume an in-progress workflow" },
-          { cmd: "--list", desc: "List all available templates" },
-          { cmd: "--dry-run", desc: "Preview workflow without executing" },
-        ];
-        return subs
-          .filter((s) => s.cmd.startsWith(subPrefix))
-          .map((s) => ({ value: `start ${s.cmd}`, label: s.cmd, description: s.desc }));
-      }
-
-      if (parts[0] === "templates" && parts.length <= 2) {
-        const subPrefix = parts[1] ?? "";
-        const subs = [
-          { cmd: "info", desc: "Show detailed template info" },
-        ];
-        return subs
-          .filter((s) => s.cmd.startsWith(subPrefix))
-          .map((s) => ({ value: `templates ${s.cmd}`, label: s.cmd, description: s.desc }));
-      }
-
-      if (parts[0] === "templates" && parts[1] === "info" && parts.length <= 3) {
-        const namePrefix = parts[2] ?? "";
-        return getTemplateCompletions(namePrefix)
-          .map((c) => ({ value: `templates ${c.value}`, label: c.label, description: c.description }));
-      }
-
       if (parts[0] === "doctor") {
         const modePrefix = parts[1] ?? "";
         const modes = [
@@ -812,17 +792,6 @@ Examples:
         return;
       }
 
-      // ─── Workflow Templates ────────────────────────────────────────
-      if (trimmed === "start" || trimmed.startsWith("start ")) {
-        await handleStart(trimmed.replace(/^start\s*/, "").trim(), ctx, pi);
-        return;
-      }
-
-      if (trimmed === "templates" || trimmed.startsWith("templates ")) {
-        await handleTemplates(trimmed.replace(/^templates\s*/, "").trim(), ctx);
-        return;
-      }
-
       if (trimmed === "") {
         // Bare /gsd defaults to step mode
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
@@ -841,8 +810,6 @@ function showHelp(ctx: ExtensionCommandContext): void {
   const lines = [
     "GSD — Get Shit Done\n",
     "WORKFLOW",
-    "  /gsd start <tpl>   Start a workflow template (bugfix, spike, feature, hotfix, etc.)",
-    "  /gsd templates     List available workflow templates  [info <name>]",
     "  /gsd               Run next unit in step mode (same as /gsd next)",
     "  /gsd next           Execute next task, then pause  [--dry-run] [--verbose]",
     "  /gsd auto           Run all queued units continuously  [--verbose]",

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -11,8 +11,7 @@ import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 import { deriveState } from "./state.js";
 import { loadFile, parseRoadmap, parsePlan } from "./files.js";
 import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
-import { getAutoDashboardData } from "./auto.js";
-import type { AutoDashboardData } from "./auto-dashboard.js";
+import { getAutoDashboardData, type AutoDashboardData } from "./auto.js";
 import {
   getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice,
   aggregateByModel, aggregateCacheHitRate, formatCost, formatTokenCount, formatCostProjection,

package/src/resources/extensions/gsd/json-persistence.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
 /**
@@ -50,18 +50,3 @@ export function saveJsonFile<T>(filePath: string, data: T): void {
     // Non-fatal — don't let persistence failures break operation
   }
 }
-
-/**
- * Write a JSON file atomically (write to .tmp, then rename).
- * Creates parent directories as needed. Non-fatal on error.
- */
-export function writeJsonFileAtomic<T>(filePath: string, data: T): void {
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    const tmp = filePath + ".tmp";
-    writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-    renameSync(tmp, filePath);
-  } catch {
-    // Non-fatal — don't let persistence failures break operation
-  }
-}

package/src/resources/extensions/gsd/queue-order.ts

@@ -9,10 +9,10 @@
  * survives branch switches and is shared across sessions.
  */
 
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { milestoneIdSort } from "./milestone-ids.js";
-import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -45,12 +45,6 @@ function queueOrderPath(basePath: string): string {
   return join(gsdRoot(basePath), "QUEUE-ORDER.json");
 }
 
-// ─── Type Guards ─────────────────────────────────────────────────────────────
-
-function isQueueOrderFile(data: unknown): data is QueueOrderFile {
-  return data !== null && typeof data === "object" && "order" in data! && Array.isArray((data as QueueOrderFile).order);
-}
-
 // ─── Read / Write ────────────────────────────────────────────────────────────
 
 /**
@@ -58,8 +52,15 @@ function isQueueOrderFile(data: unknown): data is QueueOrderFile {
  * the file is corrupt/unreadable.
  */
 export function loadQueueOrder(basePath: string): string[] | null {
-  const data = loadJsonFileOrNull(queueOrderPath(basePath), isQueueOrderFile);
-  return data?.order ?? null;
+  const p = queueOrderPath(basePath);
+  if (!existsSync(p)) return null;
+  try {
+    const data: QueueOrderFile = JSON.parse(readFileSync(p, "utf-8"));
+    if (!Array.isArray(data.order)) return null;
+    return data.order;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -70,7 +71,7 @@ export function saveQueueOrder(basePath: string, order: string[]): void {
     order,
     updatedAt: new Date().toISOString(),
   };
-  saveJsonFile(queueOrderPath(basePath), data);
+  writeFileSync(queueOrderPath(basePath), JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 
 // ─── Sorting ─────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/session-status-io.ts

@@ -11,6 +11,9 @@
  */
 
 import {
+  writeFileSync,
+  readFileSync,
+  renameSync,
   unlinkSync,
   readdirSync,
   mkdirSync,
@@ -18,7 +21,6 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
-import { loadJsonFileOrNull, writeJsonFileAtomic } from "./json-persistence.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -47,16 +49,9 @@ export interface SignalMessage {
 const PARALLEL_DIR = "parallel";
 const STATUS_SUFFIX = ".status.json";
 const SIGNAL_SUFFIX = ".signal.json";
+const TMP_SUFFIX = ".tmp";
 const DEFAULT_STALE_TIMEOUT_MS = 30_000;
 
-function isSessionStatus(data: unknown): data is SessionStatus {
-  return data !== null && typeof data === "object" && "milestoneId" in data && "pid" in data;
-}
-
-function isSignalMessage(data: unknown): data is SignalMessage {
-  return data !== null && typeof data === "object" && "signal" in data && "sentAt" in data;
-}
-
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
 function parallelDir(basePath: string): string {
@@ -91,13 +86,25 @@ function isPidAlive(pid: number): boolean {
 
 /** Write session status atomically (write to .tmp, then rename). */
 export function writeSessionStatus(basePath: string, status: SessionStatus): void {
-  ensureParallelDir(basePath);
-  writeJsonFileAtomic(statusPath(basePath, status.milestoneId), status);
+  try {
+    ensureParallelDir(basePath);
+    const dest = statusPath(basePath, status.milestoneId);
+    const tmp = dest + TMP_SUFFIX;
+    writeFileSync(tmp, JSON.stringify(status, null, 2), "utf-8");
+    renameSync(tmp, dest);
+  } catch { /* non-fatal */ }
 }
 
 /** Read a specific milestone's session status. */
 export function readSessionStatus(basePath: string, milestoneId: string): SessionStatus | null {
-  return loadJsonFileOrNull(statusPath(basePath, milestoneId), isSessionStatus);
+  try {
+    const p = statusPath(basePath, milestoneId);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw) as SessionStatus;
+  } catch {
+    return null;
+  }
 }
 
 /** Read all session status files from .gsd/parallel/. */
@@ -107,10 +114,13 @@ export function readAllSessionStatuses(basePath: string): SessionStatus[] {
 
   const results: SessionStatus[] = [];
   try {
-    for (const entry of readdirSync(dir)) {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
       if (!entry.endsWith(STATUS_SUFFIX)) continue;
-      const status = loadJsonFileOrNull(join(dir, entry), isSessionStatus);
-      if (status) results.push(status);
+      try {
+        const raw = readFileSync(join(dir, entry), "utf-8");
+        results.push(JSON.parse(raw) as SessionStatus);
+      } catch { /* skip corrupt files */ }
     }
   } catch { /* non-fatal */ }
   return results;
@@ -128,19 +138,27 @@ export function removeSessionStatus(basePath: string, milestoneId: string): void
 
 /** Write a signal file for a worker to consume. */
 export function sendSignal(basePath: string, milestoneId: string, signal: SessionSignal): void {
-  ensureParallelDir(basePath);
-  const msg: SignalMessage = { signal, sentAt: Date.now(), from: "coordinator" };
-  writeJsonFileAtomic(signalPath(basePath, milestoneId), msg);
+  try {
+    ensureParallelDir(basePath);
+    const dest = signalPath(basePath, milestoneId);
+    const tmp = dest + TMP_SUFFIX;
+    const msg: SignalMessage = { signal, sentAt: Date.now(), from: "coordinator" };
+    writeFileSync(tmp, JSON.stringify(msg, null, 2), "utf-8");
+    renameSync(tmp, dest);
+  } catch { /* non-fatal */ }
 }
 
 /** Read and delete a signal file (atomic consume). Returns null if no signal pending. */
 export function consumeSignal(basePath: string, milestoneId: string): SignalMessage | null {
-  const p = signalPath(basePath, milestoneId);
-  const msg = loadJsonFileOrNull(p, isSignalMessage);
-  if (msg) {
-    try { unlinkSync(p); } catch { /* non-fatal */ }
+  try {
+    const p = signalPath(basePath, milestoneId);
+    if (!existsSync(p)) return null;
+    const raw = readFileSync(p, "utf-8");
+    unlinkSync(p);
+    return JSON.parse(raw) as SignalMessage;
+  } catch {
+    return null;
   }
-  return msg;
 }
 
 // ─── Stale Detection ───────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/auto-budget-alerts.test.ts

@@ -5,7 +5,7 @@ import {
   getBudgetAlertLevel,
   getBudgetEnforcementAction,
   getNewBudgetAlertLevel,
-} from "../auto-budget.js";
+} from "../auto.js";
 
 test("getBudgetAlertLevel returns the expected threshold bucket", () => {
   assert.equal(getBudgetAlertLevel(0.10), 0);

package/src/resources/extensions/gsd/tests/auto-skip-loop.test.ts

@@ -17,8 +17,8 @@ import { tmpdir } from "node:os";
 import {
   _getUnitConsecutiveSkips,
   _resetUnitConsecutiveSkips,
+  MAX_CONSECUTIVE_SKIPS,
 } from "../auto.ts";
-import { MAX_CONSECUTIVE_SKIPS } from "../auto/session.ts";
 import { persistCompletedKey, removePersistedKey, loadPersistedKeys } from "../auto-recovery.ts";
 import { createTestContext } from "./test-helpers.ts";
 

package/src/resources/extensions/gsd/tests/extension-selector-separator.test.ts

@@ -1,6 +1,4 @@
-// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent
-// and the two-step provider→model picker in configureModels.
-//
+// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent.
 // We cannot import the component directly in node:test because its transitive
 // dependency (countdown-timer.ts) uses TypeScript parameter properties which
 // are unsupported under --experimental-strip-types. Instead we duplicate the
@@ -71,17 +69,16 @@ describe("separator detection", () => {
 	});
 });
 
-describe("two-step provider→model picker", () => {
-	// Simulate the grouping logic from configureModels
-	const availableModels = [
-		{ id: "claude-opus-4-6", provider: "anthropic" },
-		{ id: "gpt-4o", provider: "openai" },
-		{ id: "claude-sonnet-4-5", provider: "anthropic" },
-		{ id: "o3-mini", provider: "openai" },
-		{ id: "claude-haiku-4-5", provider: "anthropic" },
-	];
+describe("model grouping", () => {
+	test("groups models by provider with separator headers", () => {
+		// Simulate the grouping logic from configureModels
+		const availableModels = [
+			{ id: "claude-opus-4-6", provider: "anthropic" },
+			{ id: "gpt-4o", provider: "openai" },
+			{ id: "claude-sonnet-4-5", provider: "anthropic" },
+			{ id: "o3-mini", provider: "openai" },
+		];
 
-	function buildProviderGroups() {
 		const byProvider = new Map<string, typeof availableModels>();
 		for (const m of availableModels) {
 			let group = byProvider.get(m.provider);
@@ -92,53 +89,34 @@ describe("two-step provider→model picker", () => {
 			group.push(m);
 		}
 		const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-		for (const group of byProvider.values()) {
-			group.sort((a, b) => a.id.localeCompare(b.id));
-		}
-		return { byProvider, providers };
-	}
-
-	test("provider menu lists providers with model counts", () => {
-		const { providers, byProvider } = buildProviderGroups();
-		const providerOptions = providers.map(p => {
-			const count = byProvider.get(p)!.length;
-			return `${p} (${count} models)`;
-		});
-		providerOptions.push("(keep current)", "(clear)", "(type manually)");
-
-		assert.strictEqual(providerOptions[0], "anthropic (3 models)");
-		assert.strictEqual(providerOptions[1], "openai (2 models)");
-		assert.strictEqual(providerOptions[2], "(keep current)");
-		assert.strictEqual(providerOptions[3], "(clear)");
-		assert.strictEqual(providerOptions[4], "(type manually)");
-	});
-
-	test("model menu for a provider is sorted alphabetically", () => {
-		const { byProvider } = buildProviderGroups();
-		const anthropicModels = byProvider.get("anthropic")!;
-		const modelOptions = anthropicModels.map(m => m.id);
-
-		assert.strictEqual(modelOptions[0], "claude-haiku-4-5");
-		assert.strictEqual(modelOptions[1], "claude-opus-4-6");
-		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5");
-	});
-
-	test("provider name is extracted correctly from choice string", () => {
-		const choice = "anthropic (3 models)";
-		const providerName = choice.replace(/ \(\d+ models?\)$/, "");
-		assert.strictEqual(providerName, "anthropic");
-
-		const singleChoice = "ollama (1 model)";
-		const singleProvider = singleChoice.replace(/ \(\d+ models?\)$/, "");
-		assert.strictEqual(singleProvider, "ollama");
-	});
 
-	test("openai models are sorted within their group", () => {
-		const { byProvider } = buildProviderGroups();
-		const openaiModels = byProvider.get("openai")!;
-		const modelOptions = openaiModels.map(m => m.id);
-
-		assert.strictEqual(modelOptions[0], "gpt-4o");
-		assert.strictEqual(modelOptions[1], "o3-mini");
+		const modelOptions: string[] = [];
+		for (const provider of providers) {
+			const group = byProvider.get(provider)!;
+			modelOptions.push(`${SEPARATOR_PREFIX} ${provider} (${group.length}) ${SEPARATOR_PREFIX}`);
+			for (const m of group) {
+				modelOptions.push(`${m.id} · ${m.provider}`);
+			}
+		}
+		modelOptions.push("(keep current)", "(clear)");
+
+		// Verify structure
+		assert.strictEqual(modelOptions[0], `${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`);
+		assert.strictEqual(modelOptions[1], "claude-opus-4-6 · anthropic");
+		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5 · anthropic");
+		assert.strictEqual(modelOptions[3], `${SEPARATOR_PREFIX} openai (2) ${SEPARATOR_PREFIX}`);
+		assert.strictEqual(modelOptions[4], "gpt-4o · openai");
+		assert.strictEqual(modelOptions[5], "o3-mini · openai");
+		assert.strictEqual(modelOptions[6], "(keep current)");
+		assert.strictEqual(modelOptions[7], "(clear)");
+
+		// Verify separators are correctly detected
+		assert.ok(isSeparator(modelOptions, 0));
+		assert.ok(!isSeparator(modelOptions, 1));
+		assert.ok(isSeparator(modelOptions, 3));
+		assert.ok(!isSeparator(modelOptions, 6));
+
+		// Verify first selectable is index 1, not the separator at 0
+		assert.strictEqual(nextSelectable(modelOptions, 0, 1), 1);
 	});
 });

package/src/resources/extensions/gsd/tests/parallel-workers-multi-milestone-e2e.test.ts

@@ -30,7 +30,7 @@ import {
   getBudgetAlertLevel,
   getNewBudgetAlertLevel,
   getBudgetEnforcementAction,
-} from '../auto-budget.ts';
+} from '../auto.ts';
 import {
   type UnitMetrics,
   type MetricsLedger,