@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -49,6 +49,8 @@ import {
 import { loadEffectiveGSDPreferences, getIsolationMode } from "./preferences.js";
 import { invalidateAllCaches } from "./cache.js";
 import { resolveMilestoneFile } from "./paths.js";
+import { getMilestone, insertMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import type { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 // ADR-016 phase 2 / C1 (#5624): file-system + git-CLI leaf primitives
@@ -85,6 +87,28 @@ export function resetRecentWorktreeMergeFailuresForTest(): void {
   recentWorktreeMergeFailures.clear();
 }
 
+function markMilestoneClosedAfterMerge(milestoneId: string, completedAt: string): void {
+  if (!isDbAvailable()) return;
+  try {
+    const existing = getMilestone(milestoneId);
+    if (!existing) {
+      insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
+      updateMilestoneStatus(milestoneId, "complete", completedAt);
+      invalidateAllCaches();
+      return;
+    }
+    if (!isClosedStatus(existing.status)) {
+      updateMilestoneStatus(milestoneId, "complete", completedAt);
+      invalidateAllCaches();
+    }
+  } catch (err) {
+    logWarning(
+      "worktree",
+      `Merged ${milestoneId} but failed to mark milestone complete in DB: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
 // ─── Types ───────────────────────────────────────────────────────────────
 
 export interface NotifyCtx {
@@ -1716,6 +1740,8 @@ export class WorktreeLifecycle {
 
     // #4764 — record merge completion. Only reaches here when an actual
     // merge ran; failure paths throw out before this point.
+    const mergeCompletedAt = new Date().toISOString();
+    markMilestoneClosedAfterMerge(milestoneId, mergeCompletedAt);
     try {
       emitWorktreeMerged(
         this.s.originalBasePath || this.s.basePath,

package/src/resources/extensions/mcp-client/manager.ts

@@ -103,6 +103,8 @@ const CHILD_ENV_ALLOWLIST = new Set([
 	"XDG_CACHE_HOME",
 ]);
 
+const MCP_STDERR_MAX_BYTES = 4096;
+
 let cachedStatus: ManagedMcpStatus | null = null;
 let cachedStatusKey = "";
 
@@ -231,6 +233,34 @@ export function resolveMcpString(value: string): string {
 	);
 }
 
+function captureTransportStderr(transport: StdioClientTransport): () => string {
+	const chunks: Buffer[] = [];
+	let totalBytes = 0;
+	const stderr = transport.stderr;
+	stderr?.on("data", (chunk: Buffer | string) => {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		totalBytes += buffer.byteLength;
+		chunks.push(buffer);
+		while (chunks.reduce((sum, entry) => sum + entry.byteLength, 0) > MCP_STDERR_MAX_BYTES) {
+			chunks.shift();
+		}
+	});
+
+	return () => {
+		const captured = Buffer.concat(chunks).toString("utf-8").trim();
+		if (!captured) return "";
+		return totalBytes > MCP_STDERR_MAX_BYTES
+			? `[stderr truncated to last ${MCP_STDERR_MAX_BYTES} bytes]\n${captured}`
+			: captured;
+	};
+}
+
+function formatConnectionError(error: unknown, stderr: string): string {
+	const message = error instanceof Error ? error.message : String(error);
+	if (!stderr) return message;
+	return `${message}\nStderr:\n${stderr}`;
+}
+
 export function upsertProjectLocalMcpServer(
 	input: ManagedMcpServerInput,
 	options: { projectDir?: string; previousName?: string } = {},
@@ -348,6 +378,7 @@ export async function testMcpServerConnection(
 
 	const client = new Client({ name: "gsd", version: "1.0.0" });
 	let transport: StdioClientTransport | StreamableHTTPClientTransport | undefined;
+	let readCapturedStderr: (() => string) | undefined;
 	const timeout = options.timeoutMs ?? 30_000;
 	try {
 		if (config.transport === "stdio") {
@@ -358,6 +389,7 @@ export async function testMcpServerConnection(
 				cwd: config.cwd,
 				stderr: "pipe",
 			});
+			readCapturedStderr = captureTransportStderr(transport);
 		} else {
 			const resolvedUrl = resolveMcpString(config.url ?? "");
 			transport = new StreamableHTTPClientTransport(
@@ -385,7 +417,7 @@ export async function testMcpServerConnection(
 			toolCount: 0,
 			tools: [],
 			warnings: config.envWarnings,
-			error: error instanceof Error ? error.message : String(error),
+			error: formatConnectionError(error, readCapturedStderr?.() ?? ""),
 		};
 	} finally {
 		if (transport) {

package/src/resources/extensions/mcp-client/tests/manager.test.ts

@@ -163,3 +163,38 @@ test("MCP connection test performs handshake and tools/list without invoking too
 		cleanup();
 	}
 });
+
+test("MCP connection test includes stdio stderr when discovery fails", async () => {
+	const { projectDir, cleanup } = makeProject();
+	try {
+		const serverPath = join(projectDir, "crashing-mcp-server.mjs");
+		writeFileSync(
+			serverPath,
+			[
+				'console.error("fatal browser bootstrap failed");',
+				'console.error("missing browser profile");',
+				"process.exit(1);",
+			].join("\n"),
+			"utf-8",
+		);
+
+		const result = await testMcpServerConnection({
+			name: "crashing",
+			transport: "stdio",
+			sourcePath: join(projectDir, ".gsd", "mcp.json"),
+			sourceKind: "project-local",
+			disabled: false,
+			command: process.execPath,
+			args: [serverPath],
+			envWarnings: [],
+		} satisfies ManagedMcpServerConfig, { projectDir, timeoutMs: 10_000 });
+
+		assert.equal(result.ok, false);
+		assert.match(result.error ?? "", /Connection closed|closed|exit/i);
+		assert.match(result.error ?? "", /Stderr:/);
+		assert.match(result.error ?? "", /fatal browser bootstrap failed/);
+		assert.match(result.error ?? "", /missing browser profile/);
+	} finally {
+		cleanup();
+	}
+});

package/src/resources/extensions/shared/gsd-browser-cli.ts

@@ -0,0 +1,172 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const GSD_BROWSER_MCP_SERVER_NAME = "gsd-browser";
+
+export interface GsdBrowserMcpLaunchConfig {
+  serverName: string;
+  command: string;
+  args: string[];
+  cwd: string;
+  env?: Record<string, string>;
+  projectRoot: string;
+  sessionName: string;
+}
+
+export interface GsdBrowserMcpLaunchOptions {
+  sessionName?: string;
+  sessionSuffix?: string;
+}
+
+function parseJsonEnv<T>(env: NodeJS.ProcessEnv, name: string): T | undefined {
+  const raw = env[name];
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    throw new Error(`Invalid JSON in ${name}`);
+  }
+}
+
+function sanitizeSessionSegment(value: string): string {
+  return value
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+}
+
+function compareSemverLocal(a: string, b: string): number {
+  const left = a.split(".").map(Number);
+  const right = b.split(".").map(Number);
+  for (let index = 0; index < Math.max(left.length, right.length); index++) {
+    const leftValue = left[index] || 0;
+    const rightValue = right[index] || 0;
+    if (leftValue > rightValue) return 1;
+    if (leftValue < rightValue) return -1;
+  }
+  return 0;
+}
+
+function parseGsdBrowserVersion(output: string): string | null {
+  return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+}
+
+function resolveBundledGsdBrowserPackageVersion(): string | null {
+  try {
+    const requireFromHere = createRequire(import.meta.url);
+    const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { version?: unknown };
+    return typeof pkg.version === "string" ? parseGsdBrowserVersion(pkg.version) : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolvePathGsdBrowserVersion(env: NodeJS.ProcessEnv): string | null {
+  const explicit = env.GSD_BROWSER_PATH_VERSION?.trim();
+  if (explicit) return parseGsdBrowserVersion(explicit);
+
+  try {
+    return parseGsdBrowserVersion(execFileSync("gsd-browser", ["--version"], {
+      encoding: "utf-8",
+      env,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2000,
+    }));
+  } catch {
+    return null;
+  }
+}
+
+function shouldPreferPathGsdBrowser(env: NodeJS.ProcessEnv): boolean {
+  const pathVersion = resolvePathGsdBrowserVersion(env);
+  if (!pathVersion) return false;
+
+  const bundledVersion = resolveBundledGsdBrowserPackageVersion();
+  return !bundledVersion || compareSemverLocal(pathVersion, bundledVersion) > 0;
+}
+
+export function resolveBundledGsdBrowserCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
+  const explicit = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+  if (explicit) return explicit;
+
+  try {
+    const requireFromHere = createRequire(import.meta.url);
+    const packageJsonPath = requireFromHere.resolve("@opengsd/gsd-browser/package.json");
+    const candidate = resolve(packageJsonPath, "..", "bin", "gsd-browser");
+    if (existsSync(candidate)) return candidate;
+  } catch {
+    // Fall through to path candidates for source/dist layouts.
+  }
+
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../node_modules/@opengsd/gsd-browser/bin/gsd-browser", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../node_modules/.bin/gsd-browser", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+export function buildGsdBrowserSessionName(projectRoot: string, suffix?: string): string {
+  const resolvedProjectRoot = resolve(projectRoot);
+  const base = sanitizeSessionSegment(basename(resolvedProjectRoot)) || "project";
+  const hash = createHash("sha1").update(resolvedProjectRoot).digest("hex").slice(0, 8);
+  const cleanSuffix = suffix ? sanitizeSessionSegment(suffix) : "";
+  return cleanSuffix ? `gsd-${base}-${hash}-${cleanSuffix}` : `gsd-${base}-${hash}`;
+}
+
+export function resolveGsdBrowserMcpLaunchConfig(
+  projectRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+  options: GsdBrowserMcpLaunchOptions = {},
+): GsdBrowserMcpLaunchConfig {
+  const resolvedProjectRoot = resolve(projectRoot);
+  const serverName = env.GSD_BROWSER_MCP_NAME?.trim() || GSD_BROWSER_MCP_SERVER_NAME;
+  const explicitArgs = parseJsonEnv<unknown>(env, "GSD_BROWSER_MCP_ARGS");
+  const explicitEnv = parseJsonEnv<Record<string, string>>(env, "GSD_BROWSER_MCP_ENV");
+  const explicitCommand = env.GSD_BROWSER_MCP_COMMAND?.trim();
+  const explicitCliPath = env.GSD_BROWSER_CLI_PATH?.trim() || env.GSD_BROWSER_BIN_PATH?.trim();
+  const preferPathCli = !explicitCommand && !explicitCliPath && shouldPreferPathGsdBrowser(env);
+  const bundledCliPath = !explicitCommand && !explicitCliPath && !preferPathCli
+    ? resolveBundledGsdBrowserCliPath(env)
+    : null;
+  const sessionName =
+    options.sessionName?.trim() || buildGsdBrowserSessionName(resolvedProjectRoot, options.sessionSuffix);
+  const command =
+    explicitCommand
+    || explicitCliPath
+    || (preferPathCli ? "gsd-browser" : undefined)
+    || (bundledCliPath ? process.execPath : undefined)
+    || "gsd-browser";
+  const args = Array.isArray(explicitArgs) && explicitArgs.length > 0
+    ? explicitArgs.map(String)
+    : [
+        ...(bundledCliPath ? [bundledCliPath] : []),
+        "mcp",
+        "--session",
+        sessionName,
+        "--identity-scope",
+        "project",
+        "--identity-project",
+        resolvedProjectRoot,
+      ];
+  const cwd = env.GSD_BROWSER_MCP_CWD?.trim() || resolvedProjectRoot;
+
+  return {
+    serverName,
+    command,
+    args,
+    cwd,
+    ...(explicitEnv ? { env: explicitEnv } : {}),
+    projectRoot: resolvedProjectRoot,
+    sessionName,
+  };
+}

package/src/resources/extensions/gsd/tests/gate-1b-recovery-bound-corrections.test.ts

@@ -1,246 +0,0 @@
-// gsd-pi + Gate 1b recovery bound corrections — regression tests for the two bugs
-// found in peer review of the H1 fix (commit f0e1d42a2):
-//   1. Escalation message must describe /gsd (counter reset) AND /gsd-debug (diagnose).
-//   2. planBlockedRecoveryCount must NOT increment when pi.sendMessage throws.
-
-import { describe, test, beforeEach, afterEach } 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 {
-  checkAutoStartAfterDiscuss,
-  setPendingAutoStart,
-  clearPendingAutoStart,
-  _getPendingAutoStart,
-} from "../guided-flow.ts";
-import { drainLogs } from "../workflow-logger.ts";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-} from "../gsd-db.ts";
-
-// ─── Harness ───────────────────────────────────────────────────────────────
-
-interface MockCapture {
-  notifies: Array<{ msg: string; level: string }>;
-  messages: Array<{ payload: any; options: any }>;
-}
-
-function mkCapture(): MockCapture {
-  return { notifies: [], messages: [] };
-}
-
-function mkCtx(cap: MockCapture): any {
-  return {
-    ui: {
-      notify: (msg: string, level: string) => {
-        cap.notifies.push({ msg, level });
-      },
-    },
-  };
-}
-
-/** Returns a pi stub whose sendMessage throws on the first call, succeeds after. */
-function mkPiThrowOnce(cap: MockCapture): any {
-  let callCount = 0;
-  return {
-    sendMessage: (payload: any, options: any) => {
-      callCount += 1;
-      if (callCount === 1) {
-        throw new Error("transient network error");
-      }
-      cap.messages.push({ payload, options });
-    },
-    setActiveTools: () => undefined,
-    getActiveTools: () => [],
-  };
-}
-
-function mkPi(cap: MockCapture): any {
-  return {
-    sendMessage: (payload: any, options: any) => {
-      cap.messages.push({ payload, options });
-    },
-    setActiveTools: () => undefined,
-    getActiveTools: () => [],
-  };
-}
-
-function mkBase(): string {
-  const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-corrections-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(
-    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
-    "# M001: Corrections Test\n\nContext written by discuss phase.\n",
-  );
-  return base;
-}
-
-// ─── Tests ─────────────────────────────────────────────────────────────────
-
-describe("Gate 1b recovery bound corrections", () => {
-  let base: string;
-  let cap: MockCapture;
-
-  beforeEach(() => {
-    clearPendingAutoStart();
-    drainLogs();
-  });
-
-  afterEach(() => {
-    closeDatabase();
-    clearPendingAutoStart();
-    if (base) {
-      rmSync(base, { recursive: true, force: true });
-    }
-  });
-
-  // ── Fix 1: escalation message ──────────────────────────────────────────
-
-  test("escalation message describes /gsd for reset AND /gsd-debug for diagnosis", () => {
-    base = mkBase();
-    openDatabase(":memory:");
-    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
-
-    cap = mkCapture();
-    setPendingAutoStart(base, {
-      basePath: base,
-      milestoneId: "M001",
-      ctx: mkCtx(cap),
-      pi: mkPi(cap),
-    });
-
-    // Exhaust the recovery budget (MAX = 3)
-    checkAutoStartAfterDiscuss(); // count → 1
-    checkAutoStartAfterDiscuss(); // count → 2
-    checkAutoStartAfterDiscuss(); // count → 3
-
-    cap.notifies = [];
-    drainLogs();
-
-    // This call hits the cap and must escalate
-    const result = checkAutoStartAfterDiscuss();
-    assert.equal(result, false, "escalation call must return false");
-
-    const errorNotify = cap.notifies.find((n) => n.level === "error");
-    assert.ok(errorNotify, "escalation must emit a notify with level 'error'");
-
-    // Must mention /gsd with reset semantics
-    assert.match(
-      errorNotify.msg,
-      /\/gsd\b/,
-      "escalation message must reference /gsd (the command that resets the counter)",
-    );
-    assert.match(
-      errorNotify.msg,
-      /reset/i,
-      "escalation message must use the word 'reset' so users know /gsd resets the counter",
-    );
-
-    // Must also mention /gsd-debug
-    assert.match(
-      errorNotify.msg,
-      /\/gsd-debug/i,
-      "escalation message must also reference /gsd-debug for diagnosis",
-    );
-
-    // Must NOT suggest /gsd-debug alone as the sole remediation
-    assert.doesNotMatch(
-      errorNotify.msg,
-      /^[^/]*\/gsd-debug[^/]*$/,
-      "escalation message must not mention /gsd-debug as the only option",
-    );
-  });
-
-  // ── Fix 2: counter ordering ────────────────────────────────────────────
-
-  test("counter stays at 0 when sendMessage throws on the first call", () => {
-    base = mkBase();
-    openDatabase(":memory:");
-    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
-
-    cap = mkCapture();
-    setPendingAutoStart(base, {
-      basePath: base,
-      milestoneId: "M001",
-      ctx: mkCtx(cap),
-      pi: mkPiThrowOnce(cap),
-    });
-
-    // First call: sendMessage throws — counter must NOT increment
-    const result = checkAutoStartAfterDiscuss();
-    assert.equal(result, false, "must return false even when sendMessage throws");
-
-    const entry = _getPendingAutoStart(base);
-    assert.ok(entry, "entry must still exist after a failed sendMessage");
-    assert.equal(
-      entry.planBlockedRecoveryCount,
-      0,
-      "counter must remain 0 when sendMessage throws — no budget burned by transient failure",
-    );
-  });
-
-  test("counter increments to 1 on the second call when first sendMessage threw", () => {
-    base = mkBase();
-    openDatabase(":memory:");
-    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
-
-    cap = mkCapture();
-    setPendingAutoStart(base, {
-      basePath: base,
-      milestoneId: "M001",
-      ctx: mkCtx(cap),
-      pi: mkPiThrowOnce(cap),
-    });
-
-    checkAutoStartAfterDiscuss(); // sendMessage throws → count stays 0
-
-    const entryAfterThrow = _getPendingAutoStart(base);
-    assert.equal(entryAfterThrow!.planBlockedRecoveryCount, 0, "count is 0 after throw");
-
-    checkAutoStartAfterDiscuss(); // sendMessage succeeds → count becomes 1
-    assert.equal(cap.messages.length, 1, "second call must produce one successful sendMessage");
-
-    const entryAfterSuccess = _getPendingAutoStart(base);
-    assert.equal(
-      entryAfterSuccess!.planBlockedRecoveryCount,
-      1,
-      "counter must be 1 after first successful dispatch",
-    );
-  });
-
-  test("3 successful sendMessage calls exhaust the budget; 4th emits escalation notify", () => {
-    base = mkBase();
-    openDatabase(":memory:");
-    insertMilestone({ id: "M001", title: "Corrections Test", status: "queued" });
-
-    cap = mkCapture();
-    setPendingAutoStart(base, {
-      basePath: base,
-      milestoneId: "M001",
-      ctx: mkCtx(cap),
-      pi: mkPi(cap),
-    });
-
-    // Three successful recoveries
-    checkAutoStartAfterDiscuss(); // count → 1
-    checkAutoStartAfterDiscuss(); // count → 2
-    checkAutoStartAfterDiscuss(); // count → 3
-
-    const entry = _getPendingAutoStart(base);
-    assert.equal(entry!.planBlockedRecoveryCount, 3, "counter must be 3 after three successes");
-    assert.equal(cap.messages.length, 3, "three sendMessage calls must have occurred");
-
-    // Fourth call hits the cap
-    cap.notifies = [];
-    cap.messages = [];
-    const resultAtCap = checkAutoStartAfterDiscuss();
-    assert.equal(resultAtCap, false, "4th call must return false");
-    assert.equal(cap.messages.length, 0, "4th call must NOT call sendMessage");
-    const errorNotify = cap.notifies.find((n) => n.level === "error");
-    assert.ok(errorNotify, "4th call must emit escalation notify with level 'error'");
-  });
-});