gsd-pi 2.53.0-dev.a67436f → 2.54.0-dev.16631ca

package/packages/pi-coding-agent/src/modes/interactive/components/provider-manager.ts

@@ -14,6 +14,7 @@ import {
 import type { AuthStorage } from "../../../core/auth-storage.js";
 import { getDiscoverableProviders } from "../../../core/model-discovery.js";
 import type { ModelRegistry } from "../../../core/model-registry.js";
+import { ModelsJsonWriter } from "../../../core/models-json-writer.js";
 import { theme } from "../theme/theme.js";
 import { rawKeyHint } from "./keybinding-hints.js";
 
@@ -39,6 +40,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 	private tui: TUI;
 	private authStorage: AuthStorage;
 	private modelRegistry: ModelRegistry;
+	private modelsJsonWriter: ModelsJsonWriter;
 	private onDone: () => void;
 	private onDiscover: (provider: string) => void;
 
@@ -54,6 +56,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 		this.tui = tui;
 		this.authStorage = authStorage;
 		this.modelRegistry = modelRegistry;
+		this.modelsJsonWriter = new ModelsJsonWriter(this.modelRegistry.modelsJsonPath);
 		this.onDone = onDone;
 		this.onDiscover = onDiscover;
 
@@ -64,7 +67,7 @@ export class ProviderManagerComponent extends Container implements Focusable {
 		// Hints
 		const hints = [
 			rawKeyHint("d", "discover"),
-			rawKeyHint("r", "remove auth"),
+			rawKeyHint("r", "remove"),
 			rawKeyHint("esc", "close"),
 		].join("  ");
 		this.addChild(new Text(hints, 0, 0));
@@ -102,6 +105,15 @@ export class ProviderManagerComponent extends Container implements Focusable {
 				supportsDiscovery: discoverableSet.has(name),
 				modelCount: providerModelCounts.get(name) ?? 0,
 			}));
+		this.clampSelectedIndex();
+	}
+
+	private clampSelectedIndex(): void {
+		if (this.providers.length === 0) {
+			this.selectedIndex = 0;
+			return;
+		}
+		this.selectedIndex = Math.min(this.selectedIndex, this.providers.length - 1);
 	}
 
 	private updateList(): void {
@@ -152,8 +164,10 @@ export class ProviderManagerComponent extends Container implements Focusable {
 			}
 		} else if (keyData === "r" || keyData === "R") {
 			const provider = this.providers[this.selectedIndex];
-			if (provider?.hasAuth) {
+			if (provider) {
 				this.authStorage.remove(provider.name);
+				this.modelsJsonWriter.removeProvider(provider.name);
+				this.modelRegistry.refresh();
 				this.loadProviders();
 				this.updateList();
 				this.tui.requestRender();

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.53.0",
+  "version": "2.54.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/bg-shell/bg-shell-lifecycle.ts

@@ -22,7 +22,7 @@ import {
 	loadManifest,
 	pruneDeadProcesses,
 } from "./process-manager.js";
-import { formatUptime, resolveBgShellPersistenceCwd } from "./utilities.js";
+import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from "./utilities.js";
 import { formatTokenCount } from "../shared/format-utils.js";
 
 import type { BgShellSharedState } from "./index.js";
@@ -213,7 +213,7 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 			return {
 				render(width: number): string[] {
 					// ── Line 1: pwd (branch) [session]  ...  bg status ──
-					let pwd = process.cwd();
+					let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
 					const home = process.env.HOME || process.env.USERPROFILE;
 					if (home && pwd.startsWith(home)) {
 						pwd = `~${pwd.slice(home.length)}`;

package/src/resources/extensions/bg-shell/utilities.ts

@@ -42,16 +42,51 @@ export function formatTimeAgo(timestamp: number): string {
 	return formatDuration(Date.now() - timestamp) + " ago";
 }
 
+function deriveProjectRootFromAutoWorktree(cachedCwd?: string): string | undefined {
+	if (!cachedCwd) return undefined;
+	const match = cachedCwd.match(/^(.*?)[\\/]\.gsd[\\/]worktrees[\\/][^\\/]+(?:[\\/].*)?$/);
+	return match?.[1];
+}
+
+export function getBgShellLiveCwd(
+	cachedCwd?: string,
+	pathExists: (path: string) => boolean = existsSync,
+	getCwd: () => string = () => process.cwd(),
+	chdir: (path: string) => void = (path) => process.chdir(path),
+): string {
+	try {
+		return getCwd();
+	} catch {
+		const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
+		const home = process.env.HOME || process.env.USERPROFILE;
+		const fallbacks = [projectRoot, cachedCwd, home, "/"].filter(
+			(candidate): candidate is string => Boolean(candidate),
+		);
+
+		for (const candidate of fallbacks) {
+			if (candidate !== "/" && !pathExists(candidate)) continue;
+			try {
+				chdir(candidate);
+			} catch {
+				// Best-effort only. Returning a known-good fallback is enough to avoid crashes.
+			}
+			return candidate;
+		}
+
+		return "/";
+	}
+}
 
 export function resolveBgShellPersistenceCwd(
 	cachedCwd: string,
-	liveCwd = process.cwd(),
+	liveCwd: string | undefined = undefined,
 	pathExists: (path: string) => boolean = existsSync,
 ): string {
+	const resolvedLiveCwd = liveCwd ?? getBgShellLiveCwd(cachedCwd, pathExists);
 	const cachedIsAutoWorktree = /(?:^|[\\/])\.gsd[\\/]worktrees[\\/]/.test(cachedCwd);
 	if (!cachedIsAutoWorktree) return cachedCwd;
-	if (cachedCwd === liveCwd && pathExists(cachedCwd)) return cachedCwd;
-	if (!pathExists(cachedCwd)) return liveCwd;
-	if (liveCwd !== cachedCwd) return liveCwd;
+	if (cachedCwd === resolvedLiveCwd && pathExists(cachedCwd)) return cachedCwd;
+	if (!pathExists(cachedCwd)) return resolvedLiveCwd;
+	if (resolvedLiveCwd !== cachedCwd) return resolvedLiveCwd;
 	return cachedCwd;
 }

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

@@ -45,6 +45,17 @@ export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" |
   return s.originalBasePath || s.basePath;
 }
 
+/**
+ * Resolve the authoritative project base for dispatch guards.
+ * Prior-milestone completion lives at the project root, even when the active
+ * unit is running inside an auto worktree.
+ */
+export function _resolveDispatchGuardBasePath(
+  s: Pick<AutoSession, "originalBasePath" | "basePath">,
+): string {
+  return s.originalBasePath || s.basePath;
+}
+
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -667,9 +678,10 @@ export async function runDispatch(
     prompt = preDispatchResult.prompt;
   }
 
+  const guardBasePath = _resolveDispatchGuardBasePath(s);
   const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(
-    s.basePath,
-    deps.getMainBranch(s.basePath),
+    guardBasePath,
+    deps.getMainBranch(guardBasePath),
     unitType,
     unitId,
   );

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

@@ -200,7 +200,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           uatContent ?? "",
           basePath,
         ),
-        pauseAfterDispatch: uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
+        pauseAfterDispatch: !process.env.GSD_HEADLESS && uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
       };
     },
   },

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

@@ -18,6 +18,26 @@ export interface ModelSelectionResult {
   routing: { tier: string; modelDowngraded: boolean } | null;
 }
 
+export function resolvePreferredModelConfig(
+  unitType: string,
+  autoModeStartModel: { provider: string; id: string } | null,
+) {
+  const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+  if (explicitConfig) return explicitConfig;
+
+  const routingConfig = resolveDynamicRoutingConfig();
+  if (!routingConfig.enabled || !routingConfig.tier_models) return undefined;
+
+  const ceilingModel = routingConfig.tier_models.heavy
+    ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+  if (!ceilingModel) return undefined;
+
+  return {
+    primary: ceilingModel,
+    fallbacks: [],
+  };
+}
+
 /**
  * Select and apply the appropriate model for a unit dispatch.
  * Handles: per-unit-type model preferences, dynamic complexity routing,
@@ -36,7 +56,7 @@ export async function selectAndApplyModel(
   autoModeStartModel: { provider: string; id: string } | null,
   retryContext?: { isRetry: boolean; previousTier?: string },
 ): Promise<ModelSelectionResult> {
-  const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+  const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
   let routing: { tier: string; modelDowngraded: boolean } | null = null;
 
   if (modelConfig) {

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

@@ -87,6 +87,11 @@ function buildSourceFilePaths(
     paths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
   }
 
+  const queuePath = resolveGsdRootFile(base, "QUEUE");
+  if (existsSync(queuePath)) {
+    paths.push(`- **Queue**: \`${relGsdRootFile("QUEUE")}\``);
+  }
+
   const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
   if (contextPath) {
     paths.push(`- **Milestone Context**: \`${relMilestoneFile(base, mid, "CONTEXT")}\``);
@@ -915,6 +920,16 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
     const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
     if (decisionsInline) inlined.push(decisionsInline);
   }
+  const queuePath = resolveGsdRootFile(base, "QUEUE");
+  if (existsSync(queuePath)) {
+    const queueInline = await inlineFileSmart(
+      queuePath,
+      relGsdRootFile("QUEUE"),
+      "Project Queue",
+      `${mid} ${midTitle}`,
+    );
+    inlined.push(queueInline);
+  }
   const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlinePM) inlined.push(knowledgeInlinePM);
   inlined.push(inlineTemplate("roadmap", "Roadmap"));

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -9,14 +9,28 @@ import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 
+export function handleRecoverableExtensionProcessError(err: Error): boolean {
+  if ((err as NodeJS.ErrnoException).code === "EPIPE") {
+    process.exit(0);
+  }
+  if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+    const syscall = (err as NodeJS.ErrnoException).syscall;
+    if (syscall?.startsWith("spawn")) {
+      process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
+      return true;
+    }
+    if (syscall === "uv_cwd") {
+      process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+      return true;
+    }
+  }
+  return false;
+}
+
 function installEpipeGuard(): void {
   if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
     const _gsdEpipeGuard = (err: Error): void => {
-      if ((err as NodeJS.ErrnoException).code === "EPIPE") {
-        process.exit(0);
-      }
-      if ((err as NodeJS.ErrnoException).code === "ENOENT" && (err as any).syscall?.startsWith("spawn")) {
-        process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
+      if (handleRecoverableExtensionProcessError(err)) {
         return;
       }
       throw err;
@@ -45,4 +59,3 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
   registerShortcuts(pi);
   registerHooks(pi);
 }
-

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

@@ -0,0 +1,139 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolvePreferredModelConfig } from "../auto-model-selection.js";
+
+function makeTempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models section is absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  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 config = resolvePreferredModelConfig("plan-slice", {
+      provider: "anthropic",
+      id: "claude-sonnet-4-6",
+    });
+
+    assert.deepEqual(config, {
+      primary: "claude-opus-4-6",
+      fallbacks: [],
+    });
+  } 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("resolvePreferredModelConfig falls back to auto start model when heavy tier is absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: claude-haiku-4-5",
+        "    standard: claude-sonnet-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig("execute-task", {
+      provider: "openai",
+      id: "gpt-5.4",
+    });
+
+    assert.deepEqual(config, {
+      primary: "openai/gpt-5.4",
+      fallbacks: [],
+    });
+  } 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("resolvePreferredModelConfig keeps explicit phase models as the ceiling", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  planning: claude-sonnet-4-6",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig("plan-slice", {
+      provider: "anthropic",
+      id: "claude-opus-4-6",
+    });
+
+    assert.deepEqual(config, {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+    });
+  } 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 });
+  }
+});

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -260,6 +260,61 @@ test("runDispatch emits dispatch-stop when dispatch returns stop action", async
   assert.equal(stopEvents[0].flowId, ic.flowId);
 });
 
+test("runDispatch checks prior-slice completion against the project root in worktree mode", async () => {
+  const capture = createEventCapture();
+  const guardCalls: Array<{ fn: string; args: unknown[] }> = [];
+  const deps = makeMockDeps(capture, {
+    getMainBranch: (basePath: string) => {
+      guardCalls.push({ fn: "getMainBranch", args: [basePath] });
+      return "main";
+    },
+    getPriorSliceCompletionBlocker: (
+      basePath: string,
+      mainBranch: string,
+      unitType: string,
+      unitId: string,
+    ) => {
+      guardCalls.push({
+        fn: "getPriorSliceCompletionBlocker",
+        args: [basePath, mainBranch, unitType, unitId],
+      });
+      return null;
+    },
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: "/tmp/project/.gsd/worktrees/M029-xoklo9",
+      originalBasePath: "/tmp/project",
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M029-xoklo9", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice 1" },
+      registry: [{ id: "M029-xoklo9", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M029-xoklo9",
+    midTitle: "Test Milestone",
+  };
+
+  const result = await runDispatch(ic, preData, {
+    recentUnits: [],
+    stuckRecoveryAttempts: 0,
+  });
+
+  assert.equal(result.action, "next");
+  assert.deepEqual(guardCalls, [
+    { fn: "getMainBranch", args: ["/tmp/project"] },
+    {
+      fn: "getPriorSliceCompletionBlocker",
+      args: ["/tmp/project", "main", "execute-task", "M001/S01/T01"],
+    },
+  ]);
+});
+
 test("runUnitPhase emits unit-start and unit-end with causedBy reference", async () => {
   const capture = createEventCapture();
 

package/src/resources/extensions/gsd/tests/plan-milestone-queue-context.test.ts

@@ -0,0 +1,48 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildPlanMilestonePrompt } from "../auto-prompts.ts";
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-queue-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M010"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+describe("plan-milestone queue context", () => {
+  test("includes queue brief when planning milestone without roadmap context", async () => {
+    const base = createBase();
+    try {
+      writeFileSync(
+        join(base, ".gsd", "QUEUE.md"),
+        [
+          "# Queue",
+          "",
+          "### M010: Analytics Dashboard — Interactivity, Intelligence & Demo Readiness",
+          "**Vision:** Ship a polished analytics dashboard with drilldowns and AI assistance.",
+          "",
+          "## Scope",
+          "- Interactivity",
+          "- Intelligence",
+          "- Demo readiness",
+          "",
+        ].join("\n"),
+      );
+
+      const prompt = await buildPlanMilestonePrompt("M010", "M010", base);
+
+      assert.match(prompt, /Source: `\.gsd\/QUEUE\.md`/);
+      assert.match(prompt, /Analytics Dashboard — Interactivity, Intelligence & Demo Readiness/);
+      assert.match(prompt, /Ship a polished analytics dashboard/);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { handleRecoverableExtensionProcessError } from "../bootstrap/register-extension.ts";
+
+test("handleRecoverableExtensionProcessError swallows spawn ENOENT", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("missing binary"), {
+        code: "ENOENT",
+        syscall: "spawn npm",
+        path: "npm",
+      }),
+    );
+    assert.equal(handled, true);
+    assert.match(stderr, /spawn ENOENT: npm/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError swallows uv_cwd ENOENT", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("process.cwd failed"), {
+        code: "ENOENT",
+        syscall: "uv_cwd",
+      }),
+    );
+    assert.equal(handled, true);
+    assert.match(stderr, /ENOENT \(uv_cwd\): process\.cwd failed/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError leaves unrelated errors unhandled", () => {
+  const handled = handleRecoverableExtensionProcessError(
+    Object.assign(new Error("permission denied"), {
+      code: "EPERM",
+      syscall: "open",
+    }),
+  );
+  assert.equal(handled, false);
+});