gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/scripts/postinstall.js

@@ -1,180 +1,11 @@
 #!/usr/bin/env node
 
-import { exec as execCb, spawnSync } from 'child_process'
-import { createHash, randomUUID } from 'crypto'
-import { chmodSync, copyFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'fs'
-import { arch, homedir, platform } from 'os'
-import { dirname, resolve, join } from 'path'
-import { Readable } from 'stream'
-import { finished } from 'stream/promises'
-import extractZip from 'extract-zip'
-import { fileURLToPath } from 'url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const cwd = resolve(__dirname, '..')
-const PLAYWRIGHT_SKIP =
-  process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === '1' ||
-  process.env.PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD === 'true'
-const RTK_SKIP =
-  process.env.GSD_SKIP_RTK_INSTALL === '1' ||
-  process.env.GSD_SKIP_RTK_INSTALL === 'true' ||
-  process.env.GSD_RTK_DISABLED === '1' ||
-  process.env.GSD_RTK_DISABLED === 'true'
-
-const RTK_VERSION = '0.33.1'
-const RTK_REPO = 'rtk-ai/rtk'
-const RTK_ENV = { ...process.env, RTK_TELEMETRY_DISABLED: '1' }
-const managedBinDir = join(process.env.GSD_HOME || join(homedir(), '.gsd'), 'agent', 'bin')
-const managedBinaryPath = join(managedBinDir, platform() === 'win32' ? 'rtk.exe' : 'rtk')
-
-function run(cmd) {
-  return new Promise((resolvePromise) => {
-    execCb(cmd, { cwd }, (error, stdout, stderr) => {
-      resolvePromise({ ok: !error, stdout, stderr })
-    })
-  })
-}
-
-function logWarn(message) {
-  process.stderr.write(`[gsd] postinstall: ${message}\n`)
-}
-
-function resolveAssetName() {
-  const currentPlatform = platform()
-  const currentArch = arch()
-  if (currentPlatform === 'darwin' && currentArch === 'arm64') return 'rtk-aarch64-apple-darwin.tar.gz'
-  if (currentPlatform === 'darwin' && currentArch === 'x64') return 'rtk-x86_64-apple-darwin.tar.gz'
-  if (currentPlatform === 'linux' && currentArch === 'arm64') return 'rtk-aarch64-unknown-linux-gnu.tar.gz'
-  if (currentPlatform === 'linux' && currentArch === 'x64') return 'rtk-x86_64-unknown-linux-musl.tar.gz'
-  if (currentPlatform === 'win32' && currentArch === 'x64') return 'rtk-x86_64-pc-windows-msvc.zip'
-  return null
-}
-
-function parseChecksums(text) {
-  const checksums = new Map()
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim()
-    if (!line) continue
-    const match = line.match(/^([a-f0-9]{64})\s+(.+)$/i)
-    if (!match) continue
-    checksums.set(match[2], match[1].toLowerCase())
-  }
-  return checksums
-}
-
-function sha256File(path) {
-  const hash = createHash('sha256')
-  hash.update(readFileSync(path))
-  return hash.digest('hex')
-}
-
-async function downloadToFile(url, destination) {
-  const response = await fetch(url, { headers: { 'User-Agent': 'gsd-pi-postinstall' } })
-  if (!response.ok) {
-    throw new Error(`download failed (${response.status}) for ${url}`)
-  }
-  if (!response.body) {
-    throw new Error(`download returned no body for ${url}`)
-  }
-  const output = createWriteStream(destination)
-  await finished(Readable.fromWeb(response.body).pipe(output))
-}
-
-function findBinaryRecursively(rootDir, binaryName) {
-  const stack = [rootDir]
-  while (stack.length > 0) {
-    const current = stack.pop()
-    if (!current) continue
-    const entries = readdirSync(current, { withFileTypes: true })
-    for (const entry of entries) {
-      const fullPath = join(current, entry.name)
-      if (entry.isFile() && entry.name === binaryName) return fullPath
-      if (entry.isDirectory()) stack.push(fullPath)
-    }
-  }
-  return null
-}
-
-function validateRtkBinary(binaryPath) {
-  const result = spawnSync(binaryPath, ['rewrite', 'git status'], {
-    encoding: 'utf-8',
-    env: RTK_ENV,
-    stdio: ['ignore', 'pipe', 'ignore'],
-    timeout: 5000,
-  })
-  return !result.error && result.status === 0 && (result.stdout || '').trim() === 'rtk git status'
-}
-
-async function ensureRtkInstalled() {
-  if (RTK_SKIP) return
-  const assetName = resolveAssetName()
-  if (!assetName) return
-  if (existsSync(managedBinaryPath) && validateRtkBinary(managedBinaryPath)) return
-
-  const tempRoot = join(managedBinDir, `.rtk-postinstall-${randomUUID().slice(0, 8)}`)
-  const archivePath = join(tempRoot, assetName)
-  const extractDir = join(tempRoot, 'extract')
-  const releaseBase = `https://github.com/${RTK_REPO}/releases/download/v${RTK_VERSION}`
-
-  mkdirSync(tempRoot, { recursive: true })
-  mkdirSync(managedBinDir, { recursive: true })
-
-  try {
-    const checksumsResponse = await fetch(`${releaseBase}/checksums.txt`, {
-      headers: { 'User-Agent': 'gsd-pi-postinstall' },
-    })
-    if (!checksumsResponse.ok) {
-      throw new Error(`failed to fetch RTK checksums (${checksumsResponse.status})`)
-    }
-
-    const checksums = parseChecksums(await checksumsResponse.text())
-    const expectedSha = checksums.get(assetName)
-    if (!expectedSha) {
-      throw new Error(`missing checksum for ${assetName}`)
-    }
-
-    await downloadToFile(`${releaseBase}/${assetName}`, archivePath)
-    const actualSha = sha256File(archivePath)
-    if (actualSha !== expectedSha) {
-      throw new Error(`checksum mismatch for ${assetName}`)
-    }
-
-    mkdirSync(extractDir, { recursive: true })
-    if (assetName.endsWith('.zip')) {
-      await extractZip(archivePath, { dir: extractDir })
-    } else {
-      const extractResult = spawnSync('tar', ['xzf', archivePath, '-C', extractDir], {
-        encoding: 'utf-8',
-        timeout: 30000,
-      })
-      if (extractResult.error || extractResult.status !== 0) {
-        throw new Error(extractResult.error?.message || extractResult.stderr?.trim() || `failed to extract ${assetName}`)
-      }
-    }
-
-    const extractedBinary = findBinaryRecursively(extractDir, platform() === 'win32' ? 'rtk.exe' : 'rtk')
-    if (!extractedBinary) {
-      throw new Error(`RTK binary not found in ${assetName}`)
-    }
-
-    copyFileSync(extractedBinary, managedBinaryPath)
-    if (platform() !== 'win32') {
-      chmodSync(managedBinaryPath, 0o755)
-    }
-
-    if (!validateRtkBinary(managedBinaryPath)) {
-      rmSync(managedBinaryPath, { force: true })
-      throw new Error('downloaded RTK binary failed validation')
-    }
-  } catch (error) {
-    logWarn(`RTK install skipped: ${error instanceof Error ? error.message : String(error)}`)
-  } finally {
-    rmSync(tempRoot, { recursive: true, force: true })
-  }
-}
-
-if (!PLAYWRIGHT_SKIP) {
-  await run('npx playwright install chromium')
-}
-
-await ensureRtkInstalled()
+/**
+ * GSD Postinstall
+ *
+ * Thin wrapper that delegates to install.js in postinstall mode
+ * (workspace linking + deps only, no global/local npm install).
+ */
+
+process.env.npm_lifecycle_event = process.env.npm_lifecycle_event || 'postinstall'
+import('./install.js')

package/src/resources/agents/researcher.md

@@ -1,7 +1,7 @@
 ---
 name: researcher
 description: Web researcher that finds and synthesizes current information using Brave Search
-tools: search-the-web, bash
+tools: search-the-web, bash, capture_thought, memory_query, gsd_graph
 ---
 
 You are a web researcher. You find current, accurate information using web search and synthesize it into a clear, well-structured report.

package/src/resources/extensions/browser-tools/capture.ts

@@ -22,6 +22,18 @@ async function getSharp(): Promise<typeof import("sharp") | null> {
 	}
 	return _sharp;
 }
+
+/**
+ * Test-only seam: override the cached sharp module. Pass `null` to simulate
+ * an environment where the sharp native dep is unavailable; pass `undefined`
+ * to clear the cache and let the next getSharp() call re-import. See
+ * tests/capture-sharp-optional.test.cjs.
+ */
+export function __setSharpForTesting(
+	value: typeof import("sharp") | null | undefined,
+): void {
+	_sharp = value;
+}
 import type { CompactPageState, CompactSelectorState } from "./state.js";
 import { formatCompactStateSummary } from "./utils.js";
 

package/src/resources/extensions/browser-tools/tests/browser-tools-integration.test.mjs

@@ -12,76 +12,25 @@
 import { describe, it, before, after } from "node:test";
 import assert from "node:assert/strict";
 import { chromium } from "playwright";
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, "..");
 
 // ---------------------------------------------------------------------------
-// Source extraction — get the IIFE strings we need for injection
+// Source loading — import the IIFE builders directly via jiti.
+// The test-only named exports in tools/intent.ts and tools/forms.ts exist
+// exactly so this test can call the real, in-tree builders. No brace
+// walking, no regex stripping — a refactor of the signatures just updates
+// the import surface, not the test.
 // ---------------------------------------------------------------------------
 
-// 1. EVALUATE_HELPERS_SOURCE — exported constant, extract via jiti
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const jiti = require("jiti")(__dirname, { interopDefault: true, debug: false });
 const { EVALUATE_HELPERS_SOURCE } = jiti("../evaluate-helpers.ts");
-
-// 2. Intent scoring — module-private buildIntentScoringScript.
-//    Extract the function from source, wrap it, and eval to get the builder.
-const intentSource = readFileSync(resolve(ROOT, "tools/intent.ts"), "utf-8");
-
-function extractBuildIntentScoringScript() {
-  // Match the function body: starts with "function buildIntentScoringScript"
-  // and returns a template literal string. We extract up to the matching closing brace.
-  const startMarker = "function buildIntentScoringScript(intent: string, scope?: string): string {";
-  const startIdx = intentSource.indexOf(startMarker);
-  if (startIdx === -1) throw new Error("Could not find buildIntentScoringScript in intent.ts");
-
-  // Walk from start, counting braces to find the end
-  let depth = 0;
-  let foundFirst = false;
-  let endIdx = startIdx;
-  for (let i = startIdx; i < intentSource.length; i++) {
-    if (intentSource[i] === "{") { depth++; foundFirst = true; }
-    if (intentSource[i] === "}") depth--;
-    if (foundFirst && depth === 0) { endIdx = i + 1; break; }
-  }
-
-  let fnBody = intentSource.slice(startIdx, endIdx);
-  // Strip TypeScript type annotations
-  fnBody = fnBody.replace(/\(intent:\s*string,\s*scope\?:\s*string\):\s*string/, "(intent, scope)");
-  return new Function("return " + fnBody)();
-}
-
-const buildIntentScoringScript = extractBuildIntentScoringScript();
-
-// 3. Form analysis — module-private buildFormAnalysisScript.
-const formsSource = readFileSync(resolve(ROOT, "tools/forms.ts"), "utf-8");
-
-function extractBuildFormAnalysisScript() {
-  const startMarker = "function buildFormAnalysisScript(selector?: string): string {";
-  const startIdx = formsSource.indexOf(startMarker);
-  if (startIdx === -1) throw new Error("Could not find buildFormAnalysisScript in forms.ts");
-
-  let depth = 0;
-  let foundFirst = false;
-  let endIdx = startIdx;
-  for (let i = startIdx; i < formsSource.length; i++) {
-    if (formsSource[i] === "{") { depth++; foundFirst = true; }
-    if (formsSource[i] === "}") depth--;
-    if (foundFirst && depth === 0) { endIdx = i + 1; break; }
-  }
-
-  let fnBody = formsSource.slice(startIdx, endIdx);
-  // Strip TypeScript type annotation
-  fnBody = fnBody.replace(/\(selector\?:\s*string\):\s*string/, "(selector)");
-  return new Function("return " + fnBody)();
-}
-
-const buildFormAnalysisScript = extractBuildFormAnalysisScript();
+const { buildIntentScoringScript } = jiti("../tools/intent.ts");
+const { buildFormAnalysisScript } = jiti("../tools/forms.ts");
 
 // ---------------------------------------------------------------------------
 // Browser lifecycle

package/src/resources/extensions/browser-tools/tests/browser-tools-unit.test.cjs

@@ -387,32 +387,44 @@ describe("formatArtifactTimestamp", () => {
 // ---------------------------------------------------------------------------
 
 describe("EVALUATE_HELPERS_SOURCE", () => {
-	it("is a parseable string (valid JavaScript)", () => {
-		assert.doesNotThrow(() => {
-			new Function(EVALUATE_HELPERS_SOURCE);
-		});
-	});
+	// Behaviour test: executing the source in a Node vm sandbox must
+	// populate a `window.__pi` namespace with every expected helper.
+	// No source grep — we actually run the code and verify the resulting
+	// object shape.
+	it("executing the source assigns all expected helpers to window.__pi", () => {
+		const vm = require("node:vm");
+		const expectedFunctions = [
+			"cssPath",
+			"simpleHash",
+			"isVisible",
+			"isEnabled",
+			"inferRole",
+			"accessibleName",
+			"isInteractiveEl",
+			"domPath",
+			"selectorHints",
+		];
 
-	const expectedFunctions = [
-		"cssPath",
-		"simpleHash",
-		"isVisible",
-		"isEnabled",
-		"inferRole",
-		"accessibleName",
-		"isInteractiveEl",
-		"domPath",
-		"selectorHints",
-	];
-
-	for (const fnName of expectedFunctions) {
-		it(`contains assignment for pi.${fnName}`, () => {
-			assert.ok(
-				EVALUATE_HELPERS_SOURCE.includes(`pi.${fnName} = function`),
-				`Expected pi.${fnName} = function assignment in source`,
+		// Playwright evaluates the source in a page context where `window`
+		// exists, so the helpers attach to `window.__pi`. Provide a minimal
+		// window stub in a vm context so we avoid polluting the test globals.
+		const sandbox = { window: {} };
+		const script = new vm.Script(EVALUATE_HELPERS_SOURCE);
+		script.runInNewContext(sandbox, { timeout: 1000 });
+
+		assert.ok(
+			sandbox.window.__pi && typeof sandbox.window.__pi === "object",
+			"executing EVALUATE_HELPERS_SOURCE must assign window.__pi",
+		);
+
+		for (const fnName of expectedFunctions) {
+			assert.equal(
+				typeof sandbox.window.__pi[fnName],
+				"function",
+				`window.__pi.${fnName} must be a function after executing the source`,
 			);
-		});
-	}
+		}
+	});
 });
 
 // ---------------------------------------------------------------------------

package/src/resources/extensions/browser-tools/tests/capture-sharp-optional.test.cjs

@@ -1,93 +1,91 @@
 /**
  * Regression tests for the optional sharp dependency in capture.ts.
  *
- * Verifies two things:
- *   1. Static: the lazy-load pattern is structurally correct in the source.
- *   2. Behavioral: constrainScreenshot returns the raw buffer unchanged when
- *      sharp is unavailable, rather than throwing.
+ * Behaviour:
+ *   - constrainScreenshot must fall back to returning the raw buffer
+ *     unchanged when sharp is unavailable, rather than throwing.
+ *   - When sharp IS available, oversized screenshots get resized.
+ *
+ * No source-grep. The test drives the real constrainScreenshot function
+ * after seeding the module-private `_sharp` cache via the test-only
+ * `__setSharpForTesting` export.
  */
 
-const { describe, it } = require("node:test");
+const { describe, it, afterEach } = require("node:test");
 const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const { join } = require("node:path");
-
-// ---------------------------------------------------------------------------
-// 1. Static analysis — verify the lazy-load pattern is present in source
-// ---------------------------------------------------------------------------
+const jiti = require("jiti")(__filename, { interopDefault: true, debug: false });
 
-describe("capture.ts — sharp optional lazy-load (static)", () => {
-	const source = readFileSync(
-		join(process.cwd(), "src/resources/extensions/browser-tools/capture.ts"),
-		"utf-8",
-	);
+const { constrainScreenshot, __setSharpForTesting } = jiti("../capture.ts");
 
-	it("does not have a top-level static sharp import", () => {
-		assert.ok(
-			!source.includes('import sharp from "sharp"'),
-			'capture.ts must not contain a top-level `import sharp from "sharp"` — sharp must be loaded lazily',
-		);
+describe("constrainScreenshot — sharp unavailable (null)", () => {
+	afterEach(() => {
+		// Clear the test override so later tests don't inherit a null sharp.
+		__setSharpForTesting(undefined);
 	});
 
-	it("defines a getSharp lazy-loader function", () => {
-		assert.ok(
-			source.includes("async function getSharp()"),
-			"capture.ts must define an async getSharp() lazy-loader",
+	it("returns the raw buffer unchanged when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); // PNG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/png", 80);
+
+		assert.strictEqual(
+			result,
+			rawBuffer,
+			"constrainScreenshot must return the exact same buffer instance when sharp is null",
 		);
 	});
 
-	it("guards constrainScreenshot with a null-sharp early return", () => {
-		assert.ok(
-			source.includes("if (!sharp) return buffer"),
-			"constrainScreenshot must return the raw buffer early when sharp is null",
-		);
+	it("returns the raw buffer unchanged for JPEG input when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0xff, 0xd8, 0xff, 0xe0]); // JPEG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/jpeg", 80);
+
+		assert.strictEqual(result, rawBuffer);
 	});
 });
 
-// ---------------------------------------------------------------------------
-// 2. Behavioral — constrainScreenshot passes through buffer when sharp is null
-// ---------------------------------------------------------------------------
-
-describe("capture.ts — constrainScreenshot with sharp unavailable", () => {
-	it("returns the raw buffer unchanged when sharp is null", async () => {
-		// Simulate what getSharp() returns on platforms without sharp by
-		// directly calling constrainScreenshot through a module whose _sharp
-		// cache has been pre-seeded to null via the module-level variable reset.
-		//
-		// Because jiti caches modules across the test suite we use a fresh
-		// require-cache trick: load capture.ts source manually and evaluate the
-		// constrainScreenshot function with a stub getSharp that always returns null.
-		const captureSource = readFileSync(
-			join(process.cwd(), "src/resources/extensions/browser-tools/capture.ts"),
-			"utf-8",
-		);
+describe("constrainScreenshot — sharp available", () => {
+	afterEach(() => {
+		__setSharpForTesting(undefined);
+	});
 
-		// Verify the guard line is reachable (structural check already done above).
-		// For the behavioral test we use the actual constrainScreenshot imported
-		// via jiti — but we force getSharp() to return null by calling the function
-		// with a very small buffer where sharp IS available. Separately we test the
-		// null path by crafting a minimal wrapper.
-		//
-		// The simplest verifiable behaviour: if the guard `if (!sharp) return buffer`
-		// is present, passing a Buffer through a version of constrainScreenshot where
-		// _sharp=null must return that exact buffer. We verify this by extracting and
-		// running a minimal inline version of the guard logic.
+	it("passes through a small image unchanged (below cap)", async () => {
+		const sharp = require("sharp");
+		const small = await sharp({
+			create: {
+				width: 400,
+				height: 300,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
 
-		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]); // fake PNG header
+		const result = await constrainScreenshot(null, small, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.equal(meta.width, 400, "small images must not be resized");
+		assert.equal(meta.height, 300);
+	});
 
-		// Inline the guard as it appears in capture.ts so the test is coupled to
-		// the actual contract, not an arbitrary helper.
-		async function constrainScreenshotWithNullSharp(buffer) {
-			const sharp = null; // simulates getSharp() returning null
-			if (!sharp) return buffer;
-			// (remainder of constrainScreenshot would run here with a real sharp)
-		}
+	it("resizes an oversized image to within 1568px", async () => {
+		const sharp = require("sharp");
+		const big = await sharp({
+			create: {
+				width: 3000,
+				height: 2000,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
 
-		const result = await constrainScreenshotWithNullSharp(rawBuffer);
-		assert.strictEqual(
-			result,
-			rawBuffer,
-			"constrainScreenshot must return the exact same buffer instance when sharp is null",
-		);
+		const result = await constrainScreenshot(null, big, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.ok(meta.width <= 1568, `width ${meta.width} must be <= 1568`);
+		assert.ok(meta.height <= 1568, `height ${meta.height} must be <= 1568`);
 	});
 });

package/src/resources/extensions/browser-tools/tools/forms.ts

@@ -46,7 +46,11 @@ interface FormAnalysisResult {
  * Runs inside page.evaluate(). Finds the target form, inventories all fields
  * with full label resolution, and returns a structured result.
  */
-function buildFormAnalysisScript(selector?: string): string {
+// Exported for tests only (see tests/browser-tools-integration.test.mjs).
+// Keep this function treated as module-private for production call sites —
+// the only legitimate external caller is the Playwright-driven integration
+// suite that needs to evaluate the returned IIFE against real DOM.
+export function buildFormAnalysisScript(selector?: string): string {
 	// We return a string that will be evaluated in the page context.
 	// This avoids serialization issues with passing functions.
 	return `(() => {

package/src/resources/extensions/browser-tools/tools/intent.ts

@@ -37,7 +37,11 @@ type Intent = (typeof INTENTS)[number];
  * Uses window.__pi utilities (injected via addInitScript) for element
  * metadata — no inline redeclarations.
  */
-function buildIntentScoringScript(intent: string, scope?: string): string {
+// Exported for tests only (see tests/browser-tools-integration.test.mjs).
+// Keep this function treated as module-private for production call sites —
+// the only legitimate external caller is the Playwright-driven integration
+// suite that needs to evaluate the returned IIFE against real DOM.
+export function buildIntentScoringScript(intent: string, scope?: string): string {
 	const scopeSelector = JSON.stringify(scope ?? null);
 
 	return `(() => {

package/src/resources/extensions/claude-code-cli/readiness.ts

@@ -12,16 +12,40 @@
 import { execFileSync } from "node:child_process";
 
 /**
- * Platform-correct binary name for the Claude Code CLI.
+ * Candidate executable names for the Claude Code CLI.
  *
- * On Windows, npm-global binaries are installed as `.cmd` shims and
- * `execFileSync` does not auto-resolve the extension — calling bare
- * `claude` would fail with ENOENT even when the CLI is installed and
- * authenticated. Mirrors the `NPM_COMMAND` pattern in
- * `src/resources/extensions/gsd/pre-execution-checks.ts`.
+ * Keep the explicit win32 ternary selector for regression coverage (Issue #4424):
+ * Node's execFileSync must target `claude.cmd` directly on Windows.
  */
 const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
 
+/**
+ * Windows installs vary: some environments expose `claude.cmd` (npm shim),
+ * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
+ * (for example Git Bash wrappers). Try all three to avoid false "not
+ * installed" results in readiness checks.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
+
+function execClaude(args: string[]): Buffer {
+	let lastError: unknown;
+	for (const command of CLAUDE_COMMAND_CANDIDATES) {
+		try {
+			return execFileSync(command, args, { timeout: 5_000, stdio: "pipe" });
+		} catch (error) {
+			lastError = error;
+			const code = (error as NodeJS.ErrnoException | undefined)?.code;
+			// Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
+			// of ENOENT. Treat both as "try next candidate".
+			if (code === "ENOENT" || code === "EINVAL") {
+				continue;
+			}
+			throw error;
+		}
+	}
+	throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
+}
+
 let cachedBinaryPresent: boolean | null = null;
 let cachedAuthed: boolean | null = null;
 let lastCheckMs = 0;
@@ -38,7 +62,7 @@ function refreshCache(): void {
 
 	// Check binary presence
 	try {
-		execFileSync(CLAUDE_COMMAND, ["--version"], { timeout: 5_000, stdio: "pipe" });
+		execClaude(["--version"]);
 		cachedBinaryPresent = true;
 	} catch {
 		cachedBinaryPresent = false;
@@ -48,7 +72,7 @@ function refreshCache(): void {
 
 	// Check auth status — exit code 0 with non-error output means authenticated
 	try {
-		const output = execFileSync(CLAUDE_COMMAND, ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+		const output = execClaude(["auth", "status"])
 			.toString()
 			.toLowerCase();
 		// The CLI outputs "not logged in", "no credentials", or similar when unauthenticated