gsd-pi 2.80.0-dev.488219eb6 → 2.80.0-dev.4edec4620

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -1,3 +1,4 @@
+// GSD2 - Claude Code CLI provider stream adapter
 /**
  * Stream adapter: bridges the Claude Agent SDK into GSD's streamSimple contract.
  *
@@ -61,6 +62,11 @@ interface ClaudeCodeStreamOptions extends SimpleStreamOptions {
 	extensionUIContext?: ExtensionUIContext;
 }
 
+/** Resolve the workspace root for local Claude Code process execution. */
+export function resolveClaudeCodeCwd(options?: SimpleStreamOptions): string {
+	return options?.cwd && options.cwd.trim().length > 0 ? options.cwd : process.cwd();
+}
+
 /** A single selectable option within an SDK elicitation schema field. */
 interface SdkElicitationRequestOption {
 	const?: string;
@@ -1307,8 +1313,9 @@ export function buildSdkOptions(
 	overrides?: { permissionMode?: "bypassPermissions" | "acceptEdits" | "default" | "plan" },
 	extraOptions: Record<string, unknown> & { reasoning?: ThinkingLevel } = {},
 ): Record<string, unknown> {
-	const { reasoning, ...sdkExtraOptions } = extraOptions;
-	const mcpServers = buildWorkflowMcpServers();
+	const { reasoning, cwd, ...sdkExtraOptions } = extraOptions;
+	const sdkCwd = typeof cwd === "string" && cwd.trim().length > 0 ? cwd : process.cwd();
+	const mcpServers = buildWorkflowMcpServers(sdkCwd);
 	const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
 	// Globally unblock the tools GSD expects Claude Code to run. When the
 	// workflow MCP server is available, prefer its `ask_user_questions` tool over
@@ -1349,7 +1356,7 @@ export function buildSdkOptions(
 		model: modelId,
 		includePartialMessages: true,
 		persistSession: true,
-		cwd: process.cwd(),
+		cwd: sdkCwd,
 		permissionMode,
 		allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
 		settingSources: ["project"],
@@ -1661,6 +1668,7 @@ async function pumpSdkMessages(
 		const queryPrompt = buildSdkQueryPrompt(context, prompt);
 		const permissionMode = await resolveClaudePermissionMode();
 		const uiContext = (options as ClaudeCodeStreamOptions | undefined)?.extensionUIContext;
+		const cwd = resolveClaudeCodeCwd(options);
 		const canUseToolHandler = createClaudeCodeCanUseToolHandler(uiContext);
 		// When no UI is available (headless / auto-mode), auto-approve all
 		// tool requests. This replaces the old bypassPermissions workaround.
@@ -1672,6 +1680,7 @@ async function pumpSdkMessages(
 			prompt,
 			{ permissionMode },
 			{
+				cwd,
 				reasoning: options?.reasoning,
 				canUseTool: canUseToolFallback,
 				...(uiContext

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -1,3 +1,4 @@
+// GSD2 - Claude Code stream adapter regression tests
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
@@ -15,6 +16,7 @@ import {
 	buildPromptFromContext,
 	buildSdkQueryPrompt,
 	buildSdkOptions,
+	resolveClaudeCodeCwd,
 	createClaudeCodeCanUseToolHandler,
 	buildBashPermissionPattern,
 	buildBashPermissionPatternOptions,
@@ -671,6 +673,45 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal(options.model, "claude-sonnet-4-20250514");
 	});
 
+	test("buildSdkOptions prefers explicit cwd over process cwd for local SDK execution", () => {
+		const explicitCwd = "/tmp/gsd-session-root";
+		const options = buildSdkOptions("claude-sonnet-4-20250514", "hello world", undefined, { cwd: explicitCwd });
+		assert.equal(options.cwd, explicitCwd);
+	});
+
+	test("buildSdkOptions uses explicit cwd when auto-detecting workflow MCP launch config", () => {
+		const explicitCwd = realpathSync(mkdtempSync(join(tmpdir(), "claude-sdk-cwd-")));
+		const restore = setWorkflowMcpEnv({});
+		try {
+			delete process.env.GSD_WORKFLOW_MCP_COMMAND;
+			delete process.env.GSD_WORKFLOW_MCP_NAME;
+			delete process.env.GSD_WORKFLOW_MCP_ARGS;
+			delete process.env.GSD_WORKFLOW_MCP_ENV;
+			delete process.env.GSD_WORKFLOW_MCP_CWD;
+
+			const distDir = join(explicitCwd, "packages", "mcp-server", "dist");
+			mkdirSync(distDir, { recursive: true });
+			writeFileSync(join(distDir, "cli.js"), "#!/usr/bin/env node\n");
+
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "hello world", undefined, { cwd: explicitCwd });
+			const mcpServers = options.mcpServers as Record<string, any>;
+			assert.equal(mcpServers["gsd-workflow"].cwd, explicitCwd);
+			assert.equal(mcpServers["gsd-workflow"].env.GSD_WORKFLOW_PROJECT_ROOT, explicitCwd);
+		} finally {
+			restore();
+			rmSync(explicitCwd, { recursive: true, force: true });
+		}
+	});
+
+	test("resolveClaudeCodeCwd falls back to process cwd when no stream cwd is provided", () => {
+		assert.equal(resolveClaudeCodeCwd(), process.cwd());
+		assert.equal(resolveClaudeCodeCwd({ cwd: "   " }), process.cwd());
+	});
+
+	test("resolveClaudeCodeCwd returns stream cwd when provided", () => {
+		assert.equal(resolveClaudeCodeCwd({ cwd: "/tmp/current-session" }), "/tmp/current-session");
+	});
+
 	test("buildSdkOptions enables betas for sonnet models", () => {
 		const sonnetOpts = buildSdkOptions("claude-sonnet-4-20250514", "test");
 		assert.ok(

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

@@ -602,6 +602,21 @@ export function updateProgressWidget(
 ): void {
   if (!ctx.hasUI) return;
 
+  // Welcome header is a startup-only banner — permanently suppress it once
+  // auto-mode activates. The dashboard widget owns all status from here.
+  // Note: setHeader(undefined) restores the built-in header (logo +
+  // instructions). To actually render zero lines, install an empty header.
+  if (typeof ctx.ui?.setHeader === "function") {
+    ctx.ui.setHeader(() => ({
+      render(): string[] { return []; },
+      invalidate(): void {},
+    }));
+  }
+  // Clear wizard step badge — auto-mode owns the UI from this point
+  if (typeof ctx.ui?.setStatus === "function") {
+    ctx.ui.setStatus("gsd-step", undefined);
+  }
+
   const verb = unitVerb(unitType);
   const phaseLabel = unitPhaseLabel(unitType);
   const mid = state.activeMilestone;
@@ -1028,6 +1043,11 @@ export function updateProgressWidget(
             ? lastCommit.message.slice(0, maxCommitLen - 1) + "…"
             : lastCommit.message
           : "";
+        // Step-mode guidance — shown above keyboard hints when auto is paused
+        if (accessors.isStepMode()) {
+          lines.push(`${pad}${theme.fg("accent", "→")} ${theme.fg("dim", "Ctrl+N to advance to next step  ·  /gsd status for overview")}`);
+        }
+
         // Hints line
         const hintParts: string[] = [];
         hintParts.push("esc pause");

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

@@ -84,16 +84,26 @@ async function installWelcomeHeader(ctx: ExtensionContext): Promise<void> {
       if (rc) remoteChannel = rc.channel;
     } catch { /* non-fatal */ }
 
-    ctx.ui.setHeader(() => ({
-      render(width: number): string[] {
-        return welcome.buildWelcomeScreenLines({
-          version: process.env.GSD_VERSION || "0.0.0",
-          remoteChannel,
-          width,
-        });
-      },
-      invalidate(): void {},
-    }));
+    ctx.ui.setHeader(() => {
+      let cachedLines: string[] | undefined;
+      let cachedWidth: number | undefined;
+      return {
+        render(width: number): string[] {
+          if (cachedLines !== undefined && cachedWidth === width) return cachedLines;
+          cachedLines = welcome.buildWelcomeScreenLines({
+            version: process.env.GSD_VERSION || "0.0.0",
+            remoteChannel,
+            width,
+          });
+          cachedWidth = width;
+          return cachedLines;
+        },
+        invalidate(): void {
+          cachedLines = undefined;
+          cachedWidth = undefined;
+        },
+      };
+    });
   } catch {
     /* non-fatal */
   }

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -1,4 +1,5 @@
-import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+// GSD2 - Write gate runtime persistence and policy guards.
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import { minimatch } from "minimatch";
@@ -147,6 +148,22 @@ function writeGateSnapshotPath(basePath: string): string {
   return join(basePath, ".gsd", "runtime", "write-gate-state.json");
 }
 
+function ensureWriteGateSnapshotDirectory(basePath: string): void {
+  const gsdPath = join(basePath, ".gsd");
+  if (!existsSync(gsdPath)) {
+    try {
+      const stat = lstatSync(gsdPath);
+      if (stat.isSymbolicLink()) {
+        const target = readlinkSync(gsdPath);
+        mkdirSync(isAbsolute(target) ? target : resolve(basePath, target), { recursive: true });
+      }
+    } catch {
+      // If .gsd truly does not exist, the runtime mkdir below will create it.
+    }
+  }
+  mkdirSync(join(gsdPath, "runtime"), { recursive: true });
+}
+
 function currentWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSnapshot {
   const state = getWriteGateState(basePath);
   return {
@@ -160,7 +177,7 @@ function currentWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSn
 function persistWriteGateSnapshot(basePath: string): void {
   if (!shouldPersistWriteGateSnapshot()) return;
   const path = writeGateSnapshotPath(basePath);
-  mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+  ensureWriteGateSnapshotDirectory(basePath);
   const tempPath = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(basePath), null, 2), "utf-8");
   try {

package/src/resources/extensions/gsd/guided-flow.ts

@@ -2218,6 +2218,7 @@ export async function showSmartEntry(
 
     if (isFirst) {
       // First ever — skip wizard, just ask directly
+      ctx.ui.setStatus("gsd-step", "New Milestone · answer the questions above to plan");
       setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
       await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId,
         `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`,
@@ -2246,6 +2247,7 @@ export async function showSmartEntry(
       if (choice === "quick_task") {
         await runQuickTaskChoice(ctx, pi);
       } else if (choice === "new_milestone") {
+        ctx.ui.setStatus("gsd-step", "New Milestone · answer the questions above to plan");
         setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode });
         await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId,
           `New milestone ${nextId}.`,
@@ -2447,6 +2449,7 @@ export async function showSmartEntry(
       if (choice === "quick_task") {
         await runQuickTaskChoice(ctx, pi);
       } else if (choice === "plan") {
+        ctx.ui.setStatus("gsd-step", "Planning Milestone · decomposing into slices");
         setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
         await dispatchWorkflow(
           pi,
@@ -2579,6 +2582,7 @@ export async function showSmartEntry(
     });
 
     if (choice === "plan") {
+      ctx.ui.setStatus("gsd-step", "Slice Planning · answer the questions above");
       await dispatchWorkflow(
         pi,
         await buildPlanSlicePrompt(milestoneId, milestoneTitle, sliceId, sliceTitle, basePath),
@@ -2641,6 +2645,7 @@ export async function showSmartEntry(
     });
 
     if (choice === "complete") {
+      ctx.ui.setStatus("gsd-step", "Completing Slice · review changes above");
       await dispatchWorkflow(
         pi,
         await buildCompleteSlicePrompt(milestoneId, milestoneTitle, sliceId, sliceTitle, basePath),
@@ -2709,6 +2714,7 @@ export async function showSmartEntry(
     }
 
     if (choice === "execute") {
+      ctx.ui.setStatus("gsd-step", "Executing Task · follow progress above");
       if (hasInterrupted) {
         await dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
           milestoneId,

package/src/resources/extensions/gsd/health-widget.ts

@@ -135,6 +135,9 @@ export function initHealthWidget(ctx: ExtensionContext): void {
       render(width: number): string[] {
         if (!cachedLines || cachedWidth !== width) {
           cachedLines = buildHealthLines(data, width);
+          if (data.projectState === "active") {
+            cachedLines = [...cachedLines, _theme.fg("dim", "  /gsd auto to run  ·  /gsd status for overview  ·  /gsd help")];
+          }
           cachedWidth = width;
         }
         return cachedLines;

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -0,0 +1,210 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for the TUI header lifecycle fixes —
+// header is suppressed (zero lines) when auto-mode activates, the wizard
+// step status badge is cleared, the NEXT-mode footer hint renders when
+// step mode is active, and the health widget appends guidance for active
+// projects.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { updateProgressWidget } from "../auto-dashboard.ts";
+import type { GSDState } from "../types.ts";
+
+interface CapturedSetHeader {
+  factory: ((tui: unknown, theme: unknown) => { render(width: number): string[]; invalidate(): void }) | undefined;
+}
+
+function makeTempDir(prefix: string): string {
+  return join(
+    tmpdir(),
+    `gsd-tui-lifecycle-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+}
+
+const baseState: GSDState = {
+  phase: "executing",
+  activeMilestone: { id: "M001", title: "Milestone" },
+  activeSlice: { id: "S01", title: "Slice" },
+  activeTask: { id: "T01", title: "Task" },
+} as unknown as GSDState;
+
+const baseAccessors = {
+  getAutoStartTime: () => 0,
+  isStepMode: () => false,
+  getCmdCtx: () => null,
+  getBasePath: () => "/tmp",
+  isVerbose: () => false,
+  isSessionSwitching: () => false,
+  getCurrentDispatchedModelId: () => null,
+};
+
+// ── Header lifecycle ────────────────────────────────────────────────────
+
+test("updateProgressWidget installs an EMPTY-rendering header (not undefined) — addresses codex P1 finding that setHeader(undefined) restores the built-in logo+instructions header", (t) => {
+  const dir = makeTempDir("empty-header");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  const captured: CapturedSetHeader = { factory: undefined };
+  let setHeaderCallCount = 0;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget() {},
+        setHeader(factory: any) {
+          setHeaderCallCount++;
+          captured.factory = factory;
+        },
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.equal(setHeaderCallCount, 1, "setHeader must be called exactly once when widget installs");
+  assert.notEqual(captured.factory, undefined, "factory must NOT be undefined — undefined restores the built-in logo+instructions header (codex P1)");
+  assert.equal(typeof captured.factory, "function", "factory must be a component-creating function");
+
+  const component = captured.factory!(null, null);
+  const rendered = component.render(80);
+  assert.deepEqual(rendered, [], "empty header component must render zero lines so auto-mode actually suppresses the welcome banner");
+});
+
+test("updateProgressWidget clears the gsd-step wizard badge when auto-mode activates", (t) => {
+  const dir = makeTempDir("step-badge");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  const statusCalls: Array<[string, string | undefined]> = [];
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget() {},
+        setHeader() {},
+        setStatus(key: string, value: string | undefined) { statusCalls.push([key, value]); },
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.ok(
+    statusCalls.some(([key, value]) => key === "gsd-step" && value === undefined),
+    `expected setStatus("gsd-step", undefined) to be called; got ${JSON.stringify(statusCalls)}`,
+  );
+});
+
+test("updateProgressWidget gracefully no-ops when ctx.ui lacks setHeader/setStatus (RPC mode)", (t) => {
+  const dir = makeTempDir("rpc-mode");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  // ctx.ui without setHeader / setStatus — must not throw.
+  assert.doesNotThrow(() => {
+    updateProgressWidget(
+      {
+        hasUI: true,
+        ui: { setWidget() {} },
+      } as any,
+      "execute-task",
+      "M001/S01/T01",
+      baseState,
+      { ...baseAccessors, getBasePath: () => dir },
+    );
+  });
+});
+
+// ── NEXT-mode footer guidance ───────────────────────────────────────────
+
+test("auto-dashboard widget render output includes Ctrl+N guidance when isStepMode is true", (t) => {
+  const dir = makeTempDir("step-hint");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir, isStepMode: () => true },
+  );
+
+  assert.ok(widgetFactory, "widget factory must be installed");
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const lines = component.render(120);
+
+  const hasStepHint = lines.some((line: string) => line.includes("Ctrl+N to advance"));
+  assert.ok(hasStepHint, `expected step-mode hint in render output; got:\n${lines.join("\n")}`);
+
+  if (component.dispose) component.dispose();
+});
+
+test("auto-dashboard widget render output omits Ctrl+N guidance when isStepMode is false", (t) => {
+  const dir = makeTempDir("no-step-hint");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir, isStepMode: () => false },
+  );
+
+  assert.ok(widgetFactory);
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const lines = component.render(120);
+
+  const hasStepHint = lines.some((line: string) => line.includes("Ctrl+N to advance"));
+  assert.equal(hasStepHint, false, "step-mode hint must NOT appear when isStepMode is false");
+
+  if (component.dispose) component.dispose();
+});

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -1,3 +1,4 @@
+// GSD2 - Write gate regression tests.
 /**
  * Unit tests for the CONTEXT.md write-gate (D031 guard chain).
  *
@@ -11,7 +12,7 @@
 
 import test, { afterEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdirSync, writeFileSync, unlinkSync, existsSync, rmSync } from 'node:fs';
+import { mkdirSync, writeFileSync, unlinkSync, existsSync, rmSync, symlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
@@ -685,3 +686,41 @@ test('write-gate: loadWriteGateSnapshot returns empty default when persist file
     } catch { /* swallow */ }
   }
 });
+
+// ─── Scenario 30: write-gate persistence recreates dangling external .gsd target ──
+
+test('write-gate: resetWriteGateState persists through dangling .gsd symlink', () => {
+  const base = join(tmpdir(), `gsd-write-gate-dangling-${randomUUID()}`);
+  const externalState = join(tmpdir(), `gsd-write-gate-external-${randomUUID()}`);
+  const stateFilePath = join(base, '.gsd', 'runtime', 'write-gate-state.json');
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+
+  try {
+    process.env.GSD_PERSIST_WRITE_GATE_STATE = '1';
+    mkdirSync(base, { recursive: true });
+    symlinkSync(externalState, join(base, '.gsd'), 'junction');
+    assert.strictEqual(existsSync(join(base, '.gsd')), false, 'precondition: .gsd symlink target is missing');
+
+    resetWriteGateState(base);
+
+    assert.ok(existsSync(externalState), 'missing external state target was recreated');
+    assert.ok(existsSync(stateFilePath), 'write-gate snapshot persisted under .gsd/runtime');
+    assert.deepEqual(loadWriteGateSnapshot(base), {
+      verifiedDepthMilestones: [],
+      verifiedApprovalGates: [],
+      activeQueuePhase: false,
+      pendingGateId: null,
+    });
+  } finally {
+    if (originalEnv === undefined) {
+      delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    } else {
+      process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+    }
+    clearDiscussionFlowState(base);
+    try {
+      rmSync(base, { recursive: true, force: true });
+      rmSync(externalState, { recursive: true, force: true });
+    } catch { /* swallow */ }
+  }
+});