gsd-pi 2.78.1-dev.8a893322c → 2.78.1-dev.8e0e96cfc

package/src/resources/extensions/shared/tests/next-action-ui-hasui.test.ts

@@ -0,0 +1,112 @@
+// GSD2 — Regression test for next-action-ui ctx.hasUI short-circuit (bare /gsd lockup)
+
+/**
+ * Regression test for the bare /gsd lockup investigated in
+ * .planning/reports/2026-04-30-gsd-bare-and-new-project-investigation.md.
+ *
+ * showNextAction() awaits ctx.ui.custom() to render a TUI prompt. In a
+ * headless context (no UI bound, ctx.hasUI === false), both ctx.ui.custom
+ * and ctx.ui.select resolve to undefined, but the call still pays for two
+ * sequential awaits before reaching the safe "not_yet" default. This test
+ * asserts the proactive short-circuit: when ctx.hasUI is false,
+ * showNextAction returns "not_yet" immediately without touching either
+ * UI method.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { showNextAction } from "../next-action-ui.js";
+
+describe("showNextAction ctx.hasUI guard (#5125 lockup root protection)", () => {
+  it("returns 'not_yet' immediately when ctx.hasUI is false (no UI calls)", async () => {
+    let customCalled = 0;
+    let selectCalled = 0;
+
+    const ctx = {
+      hasUI: false,
+      ui: {
+        custom: async () => {
+          customCalled++;
+          return undefined as never;
+        },
+        select: async () => {
+          selectCalled++;
+          return undefined;
+        },
+      },
+    };
+
+    const result = await showNextAction(ctx as any, {
+      title: "GSD — test",
+      actions: [
+        { id: "a", label: "Option A", description: "first", recommended: true },
+        { id: "b", label: "Option B", description: "second" },
+      ],
+    });
+
+    assert.equal(result, "not_yet", "should short-circuit to safe default");
+    assert.equal(customCalled, 0, "ctx.ui.custom must not be called when hasUI is false");
+    assert.equal(selectCalled, 0, "ctx.ui.select must not be called when hasUI is false");
+  });
+
+  it("uses ctx.ui.select fallback when ctx.hasUI is true and custom returns undefined", async () => {
+    let customCalled = 0;
+    let selectCalled = 0;
+
+    const ctx = {
+      hasUI: true,
+      ui: {
+        custom: async () => {
+          customCalled++;
+          return undefined as never;
+        },
+        select: async (_title: string, options: string[]) => {
+          selectCalled++;
+          return options[0];
+        },
+      },
+    };
+
+    const result = await showNextAction(ctx as any, {
+      title: "GSD — test",
+      actions: [
+        { id: "alpha", label: "Alpha", description: "first", recommended: true },
+        { id: "beta", label: "Beta", description: "second" },
+      ],
+    });
+
+    assert.equal(customCalled, 1, "ctx.ui.custom must be tried first when hasUI is true");
+    assert.equal(selectCalled, 1, "ctx.ui.select must run as fallback when custom returns undefined");
+    assert.equal(result, "alpha", "fallback should map the picked label back to the chosen action id");
+  });
+
+  it("returns the resolved id when ctx.ui.custom completes normally", async () => {
+    let selectCalled = 0;
+
+    const ctx = {
+      hasUI: true,
+      ui: {
+        custom: async (_factory: any) => {
+          // Simulate user selecting action "beta" via the TUI widget.
+          return "beta" as never;
+        },
+        select: async () => {
+          selectCalled++;
+          return undefined;
+        },
+      },
+    };
+
+    const result = await showNextAction(ctx as any, {
+      title: "GSD — test",
+      actions: [
+        { id: "alpha", label: "Alpha", description: "first", recommended: true },
+        { id: "beta", label: "Beta", description: "second" },
+      ],
+    });
+
+    assert.equal(result, "beta", "TUI selection should be returned verbatim");
+    assert.equal(selectCalled, 0, "ctx.ui.select fallback must NOT fire when custom returns a value");
+  });
+});

package/src/resources/extensions/subagent/index.ts

@@ -261,13 +261,15 @@ function writePromptToTempFile(agentName: string, prompt: string): { dir: string
 	return { dir: tmpDir, filePath };
 }
 
-function buildSubagentProcessArgs(
+export function buildSubagentProcessArgs(
 	agent: AgentConfig,
 	task: string,
 	tmpPromptPath: string | null,
+	modelOverride?: string,
 ): string[] {
 	const args: string[] = ["--mode", "json", "-p", "--no-session"];
-	if (agent.model) args.push("--model", agent.model);
+	const effectiveModel = modelOverride ?? agent.model;
+	if (effectiveModel) args.push("--model", effectiveModel);
 	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
 	if (tmpPromptPath) args.push("--append-system-prompt", tmpPromptPath);
 	args.push(`Task: ${task}`);
@@ -337,6 +339,7 @@ async function runSingleAgent(
 	signal: AbortSignal | undefined,
 	onUpdate: OnUpdateCallback | undefined,
 	makeDetails: (results: SingleResult[]) => SubagentDetails,
+	modelOverride?: string,
 ): Promise<SingleResult> {
 	const agent = agents.find((a) => a.name === agentName);
 
@@ -382,7 +385,7 @@ async function runSingleAgent(
 		messages: [],
 		stderr: "",
 		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-		model: agent.model,
+		model: modelOverride ?? agent.model,
 		step,
 	};
 
@@ -401,7 +404,7 @@ async function runSingleAgent(
 			tmpPromptDir = tmp.dir;
 			tmpPromptPath = tmp.filePath;
 		}
-		const args = buildSubagentProcessArgs(agent, task, tmpPromptPath);
+		const args = buildSubagentProcessArgs(agent, task, tmpPromptPath, modelOverride);
 		let wasAborted = false;
 
 		const exitCode = await new Promise<number>((resolve) => {
@@ -481,10 +484,11 @@ async function runSingleAgentInCmuxSplit(
 	signal: AbortSignal | undefined,
 	onUpdate: OnUpdateCallback | undefined,
 	makeDetails: (results: SingleResult[]) => SubagentDetails,
+	modelOverride?: string,
 ): Promise<SingleResult> {
 	const agent = agents.find((a) => a.name === agentName);
 	if (!agent) {
-		return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+		return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride);
 	}
 
 	let tmpPromptDir: string | null = null;
@@ -499,7 +503,7 @@ async function runSingleAgentInCmuxSplit(
 		messages: [],
 		stderr: "",
 		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-		model: agent.model,
+		model: modelOverride ?? agent.model,
 		step,
 	};
 
@@ -529,12 +533,12 @@ async function runSingleAgentInCmuxSplit(
 			? await cmuxClient.createSplit(directionOrSurfaceId as "right" | "down" | "left" | "up")
 			: directionOrSurfaceId;
 		if (!cmuxSurfaceId) {
-			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride);
 		}
 
 		const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
 		const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
-		const processArgs = [process.env.GSD_BIN_PATH!, ...extensionArgs, ...buildSubagentProcessArgs(agent, task, tmpPromptPath)];
+		const processArgs = [process.env.GSD_BIN_PATH!, ...extensionArgs, ...buildSubagentProcessArgs(agent, task, tmpPromptPath, modelOverride)];
 		// Normalize all paths to forward slashes before embedding in bash strings.
 		// On Windows, backslashes are interpreted as escape characters by bash,
 		// mangling paths like C:\Users\user into C:Useruser (#1436).
@@ -549,7 +553,7 @@ async function runSingleAgentInCmuxSplit(
 
 		const sent = await cmuxClient.sendSurface(cmuxSurfaceId, `bash -lc ${shellEscape(innerScript)}`);
 		if (!sent) {
-			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
+			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails, modelOverride);
 		}
 
 		const finished = await waitForFile(exitPath, signal);
@@ -596,12 +600,14 @@ const TaskItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task to delegate to the agent" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
+	model: Type.Optional(Type.String({ description: "Model override for this task (e.g. 'claude-sonnet-4-6')" })),
 });
 
 const ChainItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task with optional {previous} placeholder for prior output" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
+	model: Type.Optional(Type.String({ description: "Model override for this step (e.g. 'claude-sonnet-4-6')" })),
 });
 
 const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
@@ -619,6 +625,7 @@ const SubagentParams = Type.Object({
 		Type.Boolean({ description: "Prompt before running project-local agents. Default: false.", default: false }),
 	),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
+	model: Type.Optional(Type.String({ description: "Model override for the subagent (e.g. 'claude-sonnet-4-6'). Takes precedence over the agent's frontmatter model." })),
 	isolated: Type.Optional(
 		Type.Boolean({
 			description:
@@ -908,6 +915,7 @@ export default function (pi: ExtensionAPI) {
 						signal,
 						chainUpdate,
 						makeDetails("chain"),
+						step.model || params.model,
 					);
 					results.push(result);
 
@@ -985,6 +993,7 @@ export default function (pi: ExtensionAPI) {
 					: [];
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
+					const taskModel = t.model || params.model;
 					const runTask = () => cmuxSplitsEnabled
 						? runSingleAgentInCmuxSplit(
 							cmuxClient,
@@ -1003,6 +1012,7 @@ export default function (pi: ExtensionAPI) {
 								}
 							},
 							makeDetails("parallel"),
+							taskModel,
 						)
 						: runSingleAgent(
 							ctx.cwd,
@@ -1019,6 +1029,7 @@ export default function (pi: ExtensionAPI) {
 								}
 							},
 							makeDetails("parallel"),
+							taskModel,
 						);
 					let result = await runTask();
 
@@ -1079,6 +1090,7 @@ export default function (pi: ExtensionAPI) {
 							signal,
 							onUpdate,
 							makeDetails("single"),
+							params.model,
 						)
 						: await runSingleAgent(
 							ctx.cwd,
@@ -1090,6 +1102,7 @@ export default function (pi: ExtensionAPI) {
 							signal,
 							onUpdate,
 							makeDetails("single"),
+							params.model,
 						);
 					finalResults = [result];
 

package/src/resources/extensions/subagent/isolation.ts

@@ -13,6 +13,7 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 
 const execFile = promisify(execFileCb);
+import { gsdHome } from "../gsd/gsd-home.js";
 
 // ============================================================================
 // Types
@@ -59,10 +60,9 @@ export function encodeCwd(cwd: string): string {
 	return Buffer.from(cwd, "utf8").toString("base64url");
 }
 
-const gsdHome = process.env.GSD_HOME || path.join(os.homedir(), ".gsd");
 
 function getIsolationBaseDir(cwd: string, taskId: string): string {
-	return path.join(gsdHome, "wt", encodeCwd(cwd), taskId);
+	return path.join(gsdHome(), "wt", encodeCwd(cwd), taskId);
 }
 
 // Track active isolation dirs for cleanup on exit

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

@@ -0,0 +1,55 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildSubagentProcessArgs } from "../index.js";
+import type { AgentConfig } from "../agents.js";
+
+function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
+	return {
+		name: "test-agent",
+		description: "A test agent",
+		systemPrompt: "You are a test agent",
+		source: "project" as const,
+		filePath: "test-agent.md",
+		tools: [],
+		...overrides,
+	};
+}
+
+describe("buildSubagentProcessArgs model override", () => {
+	it("uses modelOverride when provided", () => {
+		const agent = makeAgent({ model: "claude-haiku-4-5-20251001" });
+		const args = buildSubagentProcessArgs(agent, "do something", null, "claude-sonnet-4-6");
+		const modelIndex = args.indexOf("--model");
+		assert.notEqual(modelIndex, -1, "should include --model flag");
+		assert.equal(args[modelIndex + 1], "claude-sonnet-4-6");
+	});
+
+	it("falls back to agent.model when no override provided", () => {
+		const agent = makeAgent({ model: "claude-haiku-4-5-20251001" });
+		const args = buildSubagentProcessArgs(agent, "do something", null);
+		const modelIndex = args.indexOf("--model");
+		assert.notEqual(modelIndex, -1, "should include --model flag");
+		assert.equal(args[modelIndex + 1], "claude-haiku-4-5-20251001");
+	});
+
+	it("omits --model when neither override nor agent.model is set", () => {
+		const agent = makeAgent({ model: undefined });
+		const args = buildSubagentProcessArgs(agent, "do something", null);
+		assert.equal(args.indexOf("--model"), -1, "should not include --model flag");
+	});
+
+	it("override takes precedence over agent.model", () => {
+		const agent = makeAgent({ model: "model-a" });
+		const args = buildSubagentProcessArgs(agent, "task", null, "model-b");
+		const modelIndex = args.indexOf("--model");
+		assert.equal(args[modelIndex + 1], "model-b");
+	});
+
+	it("uses override even when agent has no model", () => {
+		const agent = makeAgent({ model: undefined });
+		const args = buildSubagentProcessArgs(agent, "task", null, "model-override");
+		const modelIndex = args.indexOf("--model");
+		assert.notEqual(modelIndex, -1);
+		assert.equal(args[modelIndex + 1], "model-override");
+	});
+});

package/src/resources/extensions/ttsr/rule-loader.ts

@@ -7,11 +7,10 @@
  */
 import { readdirSync, readFileSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
-import { homedir } from "node:os";
 
-const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import type { Rule } from "./ttsr-manager.js";
 import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
+import { gsdHome } from "../gsd/gsd-home.js";
 
 function parseRuleFile(filePath: string): Rule | null {
 	let content: string;
@@ -61,7 +60,7 @@ function scanDir(dir: string): Rule[] {
  * Project rules override global rules with the same name.
  */
 export function loadRules(cwd: string): Rule[] {
-	const globalDir = join(gsdHome, "agent", "rules");
+	const globalDir = join(gsdHome(), "agent", "rules");
 	const projectDir = join(cwd, ".gsd", "rules");
 
 	const globalRules = scanDir(globalDir);

package/src/resources/extensions/voice/index.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { linuxPython, diagnoseSounddeviceError, ensureVoiceVenv, VOICE_VENV_PYTHON } from "./linux-ready.js";
+import { homedir } from "node:os";
 
 const __extensionDir = import.meta.dirname!;
 const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
@@ -110,8 +111,8 @@ export default function (pi: ExtensionAPI) {
 				render(width: number): string[] {
 					// Row 1: pwd (branch) ... ● transcribing
 					let pwd = process.cwd();
-					const home = process.env.HOME || process.env.USERPROFILE;
-					if (home && pwd.startsWith(home)) pwd = `~${pwd.slice(home.length)}`;
+					const home = homedir();
+					if (pwd.startsWith(home)) pwd = `~${pwd.slice(home.length)}`;
 					const branch = footerData.getGitBranch();
 					if (branch) pwd = `${pwd} (${branch})`;
 

package/src/resources/extensions/voice/linux-ready.ts

@@ -9,12 +9,11 @@
 
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { gsdHome } from "../gsd/gsd-home.js";
 
 export const VOICE_VENV_DIR = path.join(
-	process.env.HOME || process.env.USERPROFILE || os.homedir(),
-	".gsd",
+	gsdHome(),
 	"voice-venv",
 );
 export const VOICE_VENV_PYTHON = path.join(VOICE_VENV_DIR, "bin", "python3");

package/src/resources/skills/lint/SKILL.md

@@ -7,6 +7,10 @@ description: Lint and format code. Auto-detects ESLint, Biome, Prettier, or lang
 Lint and format code in the current project. Auto-detect the project's linter and formatter toolchain, run them against the target files, and report results grouped by severity with actionable fix suggestions.
 </objective>
 
+<working_directory_awareness>
+**Before running any `git` or build command:** check whether your dispatch context specifies a working directory (look for "Working directory:" in your initial prompt). If it does and `pwd` does not match it, prefix every git invocation with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only`) and run linters/formatters with the explicit path argument. Linting the wrong directory is a silent failure mode.
+</working_directory_awareness>
+
 <arguments>
 This skill accepts optional arguments after `/lint`:
 

package/src/resources/skills/review/SKILL.md

@@ -23,6 +23,10 @@ The reviewer reads both the diff and the surrounding source files to understand
 The purpose is to review and report findings. Making changes during review conflates the reviewer and author roles. Present findings and let the user decide what to act on.
 </analysis_only_rule>
 
+<working_directory_awareness>
+**Before running any `git` command:** check whether your dispatch context specifies a working directory (look for "Working directory:" in your initial prompt). If it does and `pwd` does not match it, prefix every git invocation with `-C <that path>` (e.g. `git -C /path/to/worktree diff --cached`). Reviewing the wrong directory's diff is a silent failure mode — the review will look correct but cover the wrong code.
+</working_directory_awareness>
+
 <quick_start>
 
 <determine_review_scope>

package/src/resources/skills/test/SKILL.md

@@ -151,6 +151,9 @@ Failures:
 **Suggest what to test when no arguments are given.**
 
 **A. Check recent changes:**
+
+> **Working directory check:** if your dispatch context specifies a working directory and `pwd` does not match it, prefix the git commands below with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only HEAD~5`).
+
 - Run `git diff --name-only HEAD~5` to find recently changed files
 - Run `git diff --name-only --cached` for staged files
 - Filter to source files (exclude configs, docs, lockfiles)

package/src/resources/skills/verify-before-complete/SKILL.md

@@ -9,7 +9,7 @@ Enforce the GSD "work is not done when code compiles; work is done when verifica
 </objective>
 
 <context>
-GSD's system prompt sets the expectation; `guided-complete-slice.md` and `auto-verification.ts` enforce it at the slice boundary. But between slice boundaries — mid-task, mid-debug, mid-review — an agent can drift into "I think it works" mode and ship broken work. This skill is the ritual to break that pattern at any completion point.
+GSD's system prompt sets the expectation; `complete-slice.md` and `auto-verification.ts` enforce it at the slice boundary. But between slice boundaries — mid-task, mid-debug, mid-review — an agent can drift into "I think it works" mode and ship broken work. This skill is the ritual to break that pattern at any completion point.
 
 Invocation points:
 - About to toggle a checkbox from `[ ]` to `[x]` via a `gsd_*` tool

package/dist/resources/extensions/gsd/auto-loop.js

@@ -1,13 +0,0 @@
-/**
- * auto-loop.ts — Barrel re-export for the auto-loop pipeline modules.
- *
- * The implementation has been split into focused modules under auto/.
- * This file preserves the original public API so external consumers
- * (auto.ts, auto-timeout-recovery.ts, agent-end-recovery.ts, tests)
- * continue to work without changes.
- */
-export { autoLoop, runUokKernelLoop, runLegacyAutoLoop } from "./auto/loop.js";
-export { isInfrastructureError, INFRA_ERROR_CODES } from "./auto/infra-errors.js";
-export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _hasPendingResolveForTest, _resetPendingResolve, _setActiveSession } from "./auto/resolve.js";
-export { detectStuck } from "./auto/detect-stuck.js";
-export { runUnit } from "./auto/run-unit.js";

package/dist/resources/extensions/gsd/home-dir.js

@@ -1,16 +0,0 @@
-/**
- * Cross-platform home directory resolution.
- *
- * `process.env.HOME` is not set on Windows (CMD/PowerShell).
- * Falls back to USERPROFILE, then os.homedir(), then throws.
- *
- * @see https://github.com/gsd-build/gsd-2/issues/5015
- */
-import { homedir } from "node:os";
-export function getHomeDir() {
-    const home = process.env.HOME || process.env.USERPROFILE || homedir();
-    if (!home) {
-        throw new Error("Cannot resolve home directory. Set HOME or USERPROFILE environment variable.");
-    }
-    return home;
-}

package/dist/resources/extensions/gsd/prompts/guided-complete-slice.md

@@ -1,3 +0,0 @@
-Complete slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Your working directory is `{{workingDirectory}}` — all file operations must use this path. All tasks are done. Your slice summary is the primary record of what was built — downstream agents (reassess-roadmap, future slice researchers) read it to understand what this slice delivered and what to watch out for. Use the **Slice Summary** and **UAT** output templates below to understand the expected structure. {{skillActivation}} Call `gsd_slice_complete` to record completion — the tool writes `{{sliceId}}-SUMMARY.md`, `{{sliceId}}-UAT.md`, and toggles the roadmap checkbox atomically. Fill the `UAT Type` plus `Not Proven By This UAT` sections explicitly in `uatContent` so the artifact states what class of acceptance it covers and what still remains unproven. Review task summaries for `key_decisions` and ensure any significant ones are in `.gsd/DECISIONS.md`. If the slice involved runtime behavior, fill the Operational Readiness section (Q8) in the summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit for simple slices. Do not commit or merge manually — the system handles this after the unit completes.
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-execute-task.md

@@ -1,3 +0,0 @@
-Execute the next task: {{taskId}} ("{{taskTitle}}") in slice {{sliceId}} of milestone {{milestoneId}}. Read the task plan (`{{taskId}}-PLAN.md`), load relevant summaries from prior tasks, and execute each step. Verify must-haves when done. If the task touches UI, browser flows, DOM behavior, or user-visible web state, exercise the real flow in the browser, prefer `browser_batch` for obvious sequences, prefer `browser_assert` for explicit pass/fail verification, use `browser_diff` when an action's effect is ambiguous, and use browser diagnostics when validating async or failure-prone UI. If you made an architectural, pattern, or library decision, append it to `.gsd/DECISIONS.md`. Use the **Task Summary** output template below. Call `gsd_task_complete` to record completion (it writes the summary, toggles the checkbox, and persists to DB atomically). {{skillActivation}} If running long and not all steps are finished, stop implementing and prioritize writing a clean partial summary over attempting one more step — a recoverable handoff is more valuable than a half-finished step with no documentation. If verification fails, debug methodically: form a hypothesis and test that specific theory before changing anything, change one variable at a time, read entire functions not just the suspect line, distinguish observable facts from assumptions, and if 3+ fixes fail without progress stop and reassess your mental model — list what you know for certain, what you've ruled out, and form fresh hypotheses. Don't fix symptoms — understand why something fails before changing code. If the task plan includes Failure Modes, Load Profile, or Negative Tests sections, implement and verify them: handle each dependency's error/timeout/malformed paths (Q5), protect against identified 10x breakpoints (Q6), and write specified negative test cases (Q7).
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-plan-milestone.md

@@ -1,30 +0,0 @@
-Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists and treat Active requirements as the capability contract. If `REQUIREMENTS.md` is missing, continue in legacy compatibility mode but explicitly note missing requirement coverage. Use the **Roadmap** output template below to shape the milestone planning payload you send to `gsd_plan_milestone`. Call `gsd_plan_milestone` to persist the milestone planning fields and render `{{milestoneId}}-ROADMAP.md` from DB state. Do **not** write `{{milestoneId}}-ROADMAP.md`, `ROADMAP.md`, or other planning artifacts manually. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. {{skillActivation}} Fill the Horizontal Checklist section with cross-cutting concerns considered during planning (requirements re-read, decisions re-evaluated, graceful shutdown, revenue paths, auth boundary, shared resources, reconnection). Omit for trivial milestones.
-
-## Requirement Rules
-
-- Every relevant Active requirement must be mapped to a slice, deferred, blocked with reason, or moved out of scope.
-- Each requirement gets one primary owner and may have supporting slices.
-- Surface orphaned Active requirements instead of silently ignoring them.
-- Product-facing milestones should cover launchability, primary user loop, continuity, and failure visibility when relevant.
-
-## Planning Doctrine
-
-- **Risk-first means proof-first.** The earliest slices should prove the hardest thing works by shipping the real feature through the uncertain path. If auth is the risk, the first slice ships a real login page with real session handling that a user can actually use — not a CLI command that returns "authenticated: true". Proof is the shipped feature working. There is no separate "proof" artifact. Do not plan spikes, proof-of-concept slices, or validation-only slices — the proof is the real feature, built through the risky path.
-- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means the intended user can exercise the capability through its real interface — for a web app that's the UI, for a CLI tool that's the terminal, for an API that's a consuming client or curl. The test is: can someone *use* it, not just *assert* it passes. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
-- **Brownfield bias.** When planning against an existing codebase, ground slices in existing modules, conventions, and seams. Prefer extending real patterns over inventing new ones.
-- **Each slice should establish something downstream slices can depend on.** Think about what stable surface this slice creates for later work — an API, a data shape, a proven integration path.
-- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it. Exception: if the infrastructure *is* the product surface (a new protocol, extension API, or provider interface), the slice is vertical by definition — the downstream consumer is the demo.
-- **Verification-first.** When planning slices, know what "done" looks like before detailing implementation. Each slice's demo line should describe concrete, verifiable evidence — not vague "it works" claims.
-- **Plan for integrated reality, not just local proof.** Distinguish contract proof from live integration proof. If the milestone involves multiple runtime boundaries, one slice must explicitly prove the assembled system through the real entrypoint or runtime path.
-- **Truthful demo lines only.** If a slice is proven by fixtures or tests only, say so. Do not phrase harness-level proof as if the user can already perform the live end-to-end behavior unless that has actually been exercised.
-- **Completion must imply capability.** If every slice in this roadmap were completed exactly as written, the milestone's promised outcome should actually work at the proof level claimed. Do not write slices that can all be checked off while the user-visible capability still does not exist.
-- **Don't invent risks.** If the project is straightforward, skip the proof strategy and just ship value in smart order. Not everything has major unknowns.
-- **Ship features, not proofs.** A completed slice should leave the product in a state where the new capability is actually usable through its real interface. A login flow slice ends with a working login page, not a middleware function. An API slice ends with endpoints that return real data from a real store, not hardcoded fixtures. A dashboard slice ends with a real dashboard rendering real data, not a component that renders mock props. If a slice can't ship the real thing yet because a dependency isn't built, it should ship with realistic stubs that are clearly marked for replacement — but the user-facing surface must be real.
-- **Ambition matches the milestone.** The number and depth of slices should match the milestone's ambition. A milestone promising "core platform with auth, data model, and primary user loop" should have enough slices to actually deliver all three as working features — not two proof-of-concept slices and a note that "the rest will come in the next milestone." If the milestone's context promises an outcome, the roadmap must deliver it.
-
-## Secret Forecasting
-
-After writing the roadmap, analyze the slices and their boundary maps for external service dependencies (third-party APIs, SaaS platforms, cloud providers, databases requiring credentials, OAuth providers, etc.). If this milestone requires any external API keys or secrets, use the **Secrets Manifest** output template below for the expected format and write `{{secretsOutputPath}}` listing every predicted secret as an H3 section with the Service name, a direct Dashboard URL to the console page where the key is created, a Format hint showing what the key looks like, Status set to `pending`, and Destination (`dotenv`, `vercel`, or `convex`). Include numbered step-by-step guidance for obtaining each key. If this milestone does not require any external API keys or secrets, skip this step entirely — do not create an empty manifest.
-
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-plan-slice.md

@@ -1,3 +0,0 @@
-Plan slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements the roadmap says this slice owns or supports, and ensure the plan delivers them. Read the roadmap boundary map, any existing context/research files, and dependency summaries. Use the **Slice Plan** and **Task Plan** output templates below. Decompose into tasks with must-haves. Fill the `Proof Level` and `Integration Closure` sections truthfully so the plan says what class of proof this slice really delivers and what end-to-end wiring still remains. Call `gsd_plan_slice` to persist the slice plan — the tool writes `{{sliceId}}-PLAN.md` and individual `T##-PLAN.md` files to disk and persists to DB. Do **not** write plan files manually — use the DB-backed tool so state stays consistent. If planning produces structural decisions, call `gsd_decision_save` for each — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically. {{skillActivation}} Before finishing, self-audit the plan: every must-have maps to at least one task, every task has complete sections (steps, must-haves, verification, observability impact, inputs, and expected output), task ordering is consistent with no circular references, every pair of artifacts that must connect has an explicit wiring step, task scope targets 2–5 steps and 3–8 files (6–8 steps or 8–10 files — consider splitting; 10+ steps or 12+ files — must split), the plan honors locked decisions from context/research/decisions artifacts, the proof-level wording does not overclaim live integration if only fixture/contract proof is planned, every Active requirement this slice owns has at least one task with verification that proves it is met, and every task produces real user-facing progress — if the slice has a UI surface at least one task builds the real UI, if it has an API at least one task connects it to a real data source, and showing the completed result to a non-technical stakeholder would demonstrate real product progress rather than developer artifacts, and quality gate coverage — for non-trivial slices, Threat Surface (Q3: abuse, data exposure, input trust) and Requirement Impact (Q4: requirements touched, re-verify, decisions revisited) sections are present. For non-trivial tasks, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) are filled in task plans.
-
-{{inlinedTemplates}}

package/dist/web/standalone/.next/server/chunks/1926.js

@@ -1 +0,0 @@
-exports.id=1926,exports.ids=[1926],exports.modules={1926:(a,b,c)=>{"use strict";c.d(b,{isOnboardingComplete:()=>l,readOnboardingRecord:()=>k});var d=c(3024),e=c(8161),f=c(6760);c(7598);var g=c(6698);c(1421),process.env.GSD_ENABLE_NATIVE_GSD_PARSER,Symbol("native-unavailable"),new g.AsyncLocalStorage,c(9134),Object.values({Q3:{id:"Q3",scope:"slice",ownerTurn:"gate-evaluate",question:"How can this be exploited?",guidance:"Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.\nMap data exposure risks: PII, tokens, secrets accessible through this slice.\nDefine input trust boundaries: untrusted user input reaching DB, API, or filesystem.\nIf none apply, return verdict 'omitted' with rationale explaining why.",promptSection:"Abuse Surface"},Q4:{id:"Q4",scope:"slice",ownerTurn:"gate-evaluate",question:"Which existing requirements (R-IDs) does this slice touch, and which must be re-tested?",guidance:"List the R-IDs (e.g. R001, R003) touched by this slice; see the milestone requirements artifact at .gsd/milestones/<id>/REQUIREMENTS.md.\nIdentify what must be re-tested after shipping.\nFlag decisions that should be revisited given the new scope.\nIf no existing requirements are affected, return verdict 'omitted'.",promptSection:"Broken Promises"},Q5:{id:"Q5",scope:"task",ownerTurn:"execute-task",question:"What breaks when dependencies fail?",guidance:"Enumerate the task's external dependencies (APIs, filesystem, network, subprocesses).\nDescribe the failure path for each: timeout, malformed response, connection loss.\nVerify the implementation handles each failure or explicitly bubbles the error.\nReturn verdict 'omitted' only if the task has no external dependencies.",promptSection:"Failure Modes"},Q6:{id:"Q6",scope:"task",ownerTurn:"execute-task",question:"What is the 10x load breakpoint?",guidance:"Identify the resource that saturates first at 10x the expected load.\nDescribe the protection applied (pool sizing, rate limiting, pagination, caching).\nReturn verdict 'omitted' if the task has no runtime load dimension.",promptSection:"Load Profile"},Q7:{id:"Q7",scope:"task",ownerTurn:"execute-task",question:"What negative tests protect this task?",guidance:"List malformed inputs, error paths, and boundary conditions the tests cover.\nPoint to the specific test files or cases that assert each negative scenario.\nReturn verdict 'omitted' only if the task has no meaningful negative surface.",promptSection:"Negative Tests"},Q8:{id:"Q8",scope:"slice",ownerTurn:"complete-slice",question:"How will ops know this slice is healthy or broken?",guidance:"Describe the health signal (metric, log line, dashboard) that proves the slice works.\nDescribe the failure signal that triggers an alert or paging.\nDocument the recovery procedure and any monitoring gaps.\nReturn verdict 'omitted' only for slices with no runtime behavior at all.",promptSection:"Operational Readiness"},MV01:{id:"MV01",scope:"milestone",ownerTurn:"validate-milestone",question:"Is every success criterion in the milestone roadmap satisfied?",guidance:"Walk the success-criteria checklist from the milestone roadmap.\nFor each criterion, point to the slice / assessment / verification evidence that proves it.\nReturn verdict 'flag' if any criterion is unmet or unverifiable.",promptSection:"Success Criteria Checklist"},MV02:{id:"MV02",scope:"milestone",ownerTurn:"validate-milestone",question:"Does every slice have a SUMMARY.md and a passing assessment?",guidance:"Confirm every slice listed in the roadmap has a SUMMARY.md.\nConfirm each slice has an ASSESSMENT verdict of 'pass' (or justified 'omitted').\nFlag missing artifacts and slices with outstanding follow-ups or known limitations.",promptSection:"Slice Delivery Audit"},MV03:{id:"MV03",scope:"milestone",ownerTurn:"validate-milestone",question:"Do the slices integrate end-to-end?",guidance:"Trace at least one cross-slice flow proving the pieces compose.\nFlag gaps where two slices were built in isolation with no integration evidence.",promptSection:"Cross-Slice Integration"},MV04:{id:"MV04",scope:"milestone",ownerTurn:"validate-milestone",question:"Are all touched requirements covered and still coherent?",guidance:"For each requirement advanced, validated, surfaced, or invalidated across the milestone's slices, confirm the milestone-level evidence matches.\nFlag requirements that slices claim to advance but no artifact proves.",promptSection:"Requirement Coverage"}});let h=process.env.GSD_CODING_AGENT_DIR||(0,f.join)(process.env.GSD_HOME||(0,f.join)((0,e.homedir)(),".gsd"),"agent"),i=(0,f.join)(h,"onboarding.json"),j={version:1,flowVersion:1,completedAt:null,completedSteps:[],skippedSteps:[],lastResumePoint:null};function k(){if(!(0,d.existsSync)(i))return{...j};try{let a=JSON.parse((0,d.readFileSync)(i,"utf-8"));return{version:"number"==typeof a.version?a.version:1,flowVersion:"number"==typeof a.flowVersion?a.flowVersion:0,completedAt:"string"==typeof a.completedAt?a.completedAt:null,completedSteps:Array.isArray(a.completedSteps)?a.completedSteps.filter(a=>"string"==typeof a):[],skippedSteps:Array.isArray(a.skippedSteps)?a.skippedSteps.filter(a=>"string"==typeof a):[],lastResumePoint:"string"==typeof a.lastResumePoint?a.lastResumePoint:null}}catch{return{...j}}}function l(){let a=k();return null!==a.completedAt&&1===a.flowVersion}},5168:a=>{function b(a){var b=Error("Cannot find module '"+a+"'");throw b.code="MODULE_NOT_FOUND",b}b.keys=()=>[],b.resolve=b,b.id=5168,a.exports=b},9134:(a,b,c)=>{"use strict";c.d(b,{DZ:()=>e,rs:()=>d});let d="GSD_GIT_ERROR";class e extends Error{constructor(a,b,c){super(b,c),this.name="GSDError",this.code=a}}}};

package/dist/web/standalone/.next/server/edge-runtime-webpack.js

@@ -1,2 +0,0 @@
-(()=>{"use strict";var a,b,c,d,e={},f={};function g(a){var b=f[a];if(void 0!==b)return b.exports;var c=f[a]={exports:{}},d=!0;try{e[a](c,c.exports,g),d=!1}finally{d&&delete f[a]}return c.exports}g.m=e,g.amdO={},a=[],g.O=(b,c,d,e)=>{if(c){e=e||0;for(var f=a.length;f>0&&a[f-1][2]>e;f--)a[f]=a[f-1];a[f]=[c,d,e];return}for(var h=1/0,f=0;f<a.length;f++){for(var[c,d,e]=a[f],i=!0,j=0;j<c.length;j++)(!1&e||h>=e)&&Object.keys(g.O).every(a=>g.O[a](c[j]))?c.splice(j--,1):(i=!1,e<h&&(h=e));if(i){a.splice(f--,1);var k=d();void 0!==k&&(b=k)}}return b},g.n=a=>{var b=a&&a.__esModule?()=>a.default:()=>a;return g.d(b,{a:b}),b},g.d=(a,b)=>{for(var c in b)g.o(b,c)&&!g.o(a,c)&&Object.defineProperty(a,c,{enumerable:!0,get:b[c]})},g.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||Function("return this")()}catch(a){if("object"==typeof window)return window}}(),g.o=(a,b)=>Object.prototype.hasOwnProperty.call(a,b),g.r=a=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(a,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(a,"__esModule",{value:!0})},b={149:0},g.O.j=a=>0===b[a],c=(a,c)=>{var d,e,[f,h,i]=c,j=0;if(f.some(a=>0!==b[a])){for(d in h)g.o(h,d)&&(g.m[d]=h[d]);if(i)var k=i(g)}for(a&&a(c);j<f.length;j++)e=f[j],g.o(b,e)&&b[e]&&b[e][0](),b[e]=0;return g.O(k)},(d=self.webpackChunk_N_E=self.webpackChunk_N_E||[]).forEach(c.bind(null,0)),d.push=c.bind(null,d.push.bind(d))})();
-//# sourceMappingURL=edge-runtime-webpack.js.map