gsd-pi 2.22.0 → 2.24.0

package/dist/help-text.js

@@ -17,6 +17,51 @@ const SUBCOMMAND_HELP = {
         '',
         'Equivalent to: npm install -g gsd-pi@latest',
     ].join('\n'),
+    sessions: [
+        'Usage: gsd sessions',
+        '',
+        'List all saved sessions for the current directory and interactively',
+        'pick one to resume. Shows date, message count, and a preview of the',
+        'first message for each session.',
+        '',
+        'Sessions are stored per-directory, so you only see sessions that were',
+        'started from the current working directory.',
+        '',
+        'Compare with --continue (-c) which always resumes the most recent session.',
+    ].join('\n'),
+    headless: [
+        'Usage: gsd headless [flags] [command] [args...]',
+        '',
+        'Run /gsd commands without the TUI. Default command: auto',
+        '',
+        'Flags:',
+        '  --timeout N          Overall timeout in ms (default: 300000)',
+        '  --json               JSONL event stream to stdout',
+        '  --model ID           Override model',
+        '',
+        'Commands:',
+        '  auto                 Run all queued units continuously (default)',
+        '  next                 Run one unit',
+        '  status               Show progress dashboard',
+        '  new-milestone        Create a milestone from a specification document',
+        '',
+        'new-milestone flags:',
+        '  --context <path>     Path to spec/PRD file (use \'-\' for stdin)',
+        '  --context-text <txt> Inline specification text',
+        '  --auto               Start auto-mode after milestone creation',
+        '  --verbose            Show tool calls in progress output',
+        '',
+        'Examples:',
+        '  gsd headless                                    Run /gsd auto',
+        '  gsd headless next                               Run one unit',
+        '  gsd headless --json status                      Machine-readable status',
+        '  gsd headless --timeout 60000                    With 1-minute timeout',
+        '  gsd headless new-milestone --context spec.md    Create milestone from file',
+        '  cat spec.md | gsd headless new-milestone --context -   From stdin',
+        '  gsd headless new-milestone --context spec.md --auto    Create + auto-execute',
+        '',
+        'Exit codes: 0 = complete, 1 = error/timeout, 2 = blocked',
+    ].join('\n'),
 };
 export function printHelp(version) {
     process.stdout.write(`GSD v${version} — Get Shit Done\n\n`);
@@ -35,6 +80,8 @@ export function printHelp(version) {
     process.stdout.write('\nSubcommands:\n');
     process.stdout.write('  config                   Re-run the setup wizard\n');
     process.stdout.write('  update                   Update GSD to the latest version\n');
+    process.stdout.write('  sessions                 List and resume a past session\n');
+    process.stdout.write('  headless [cmd] [args]    Run /gsd commands without TUI (default: auto)\n');
     process.stdout.write('\nRun gsd <subcommand> --help for subcommand-specific help.\n');
 }
 export function printSubcommandHelp(subcommand, version) {

package/dist/mcp-server.d.ts

@@ -1,4 +1,8 @@
-interface McpTool {
+/**
+ * Minimal tool interface matching GSD's AgentTool shape.
+ * Avoids a direct dependency on @gsd/pi-agent-core from this compiled module.
+ */
+export interface McpToolDef {
     name: string;
     description: string;
     parameters: Record<string, unknown>;
@@ -11,8 +15,21 @@ interface McpTool {
         }>;
     }>;
 }
+/**
+ * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
+ *
+ * This enables GSD's tools (read, write, edit, bash, grep, glob, ls, etc.)
+ * to be used by external AI clients such as Claude Desktop, VS Code Copilot,
+ * and any MCP-compatible host.
+ *
+ * The server registers all tools from the agent session's tool registry and
+ * maps MCP tools/list and tools/call requests to GSD tool definitions and
+ * execution, respectively.
+ *
+ * All MCP SDK imports are dynamic to avoid subpath export resolution issues
+ * with TypeScript's NodeNext module resolution.
+ */
 export declare function startMcpServer(options: {
-    tools: McpTool[];
+    tools: McpToolDef[];
     version?: string;
 }): Promise<void>;
-export {};

package/dist/mcp-server.js

@@ -2,6 +2,20 @@
 // at runtime but TypeScript cannot statically type-check. We construct the
 // specifiers dynamically so tsc treats them as `any`.
 const MCP_PKG = '@modelcontextprotocol/sdk';
+/**
+ * Starts a native MCP (Model Context Protocol) server over stdin/stdout.
+ *
+ * This enables GSD's tools (read, write, edit, bash, grep, glob, ls, etc.)
+ * to be used by external AI clients such as Claude Desktop, VS Code Copilot,
+ * and any MCP-compatible host.
+ *
+ * The server registers all tools from the agent session's tool registry and
+ * maps MCP tools/list and tools/call requests to GSD tool definitions and
+ * execution, respectively.
+ *
+ * All MCP SDK imports are dynamic to avoid subpath export resolution issues
+ * with TypeScript's NodeNext module resolution.
+ */
 export async function startMcpServer(options) {
     const { tools, version = '0.0.0' } = options;
     const serverMod = await import(`${MCP_PKG}/server`);
@@ -10,11 +24,13 @@ export async function startMcpServer(options) {
     const Server = serverMod.Server;
     const StdioServerTransport = stdioMod.StdioServerTransport;
     const { ListToolsRequestSchema, CallToolRequestSchema } = typesMod;
+    // Build a lookup map for fast tool resolution on calls
     const toolMap = new Map();
     for (const tool of tools) {
         toolMap.set(tool.name, tool);
     }
     const server = new Server({ name: 'gsd', version }, { capabilities: { tools: {} } });
+    // tools/list — return every registered GSD tool with its JSON Schema parameters
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: tools.map((t) => ({
             name: t.name,
@@ -22,6 +38,7 @@ export async function startMcpServer(options) {
             inputSchema: t.parameters,
         })),
     }));
+    // tools/call — execute the requested tool and return content blocks
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         const tool = toolMap.get(name);
@@ -32,7 +49,9 @@ export async function startMcpServer(options) {
             };
         }
         try {
-            const result = await tool.execute(`mcp-${Date.now()}`, args ?? {}, undefined, undefined);
+            const result = await tool.execute(`mcp-${Date.now()}`, args ?? {}, undefined, // no AbortSignal
+            undefined);
+            // Convert AgentToolResult content blocks to MCP content format
             const content = result.content.map((block) => {
                 if (block.type === 'text')
                     return { type: 'text', text: block.text ?? '' };
@@ -47,6 +66,7 @@ export async function startMcpServer(options) {
             return { isError: true, content: [{ type: 'text', text: message }] };
         }
     });
+    // Connect to stdin/stdout transport
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.stderr.write(`[gsd] MCP server started (v${version})\n`);

package/dist/models-resolver.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Models.json resolution with fallback to ~/.pi/agent/models.json
+ *
+ * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
+ * experience, this module provides resolution logic that:
+ *
+ * 1. Reads ~/.gsd/agent/models.json if it exists
+ * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
+ * 3. Merges both files if both exist (GSD takes precedence)
+ */
+/**
+ * Resolve the path to models.json with fallback logic.
+ *
+ * Priority:
+ * 1. ~/.gsd/agent/models.json (exists) → return this path
+ * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
+ * 3. Neither exists → return GSD path (will be created)
+ *
+ * @returns The path to use for models.json
+ */
+export declare function resolveModelsJsonPath(): string;
+/**
+ * Check if both GSD and PI models.json files exist.
+ */
+export declare function hasBothModelsFiles(): boolean;
+/**
+ * Get the paths to both models.json files.
+ */
+export declare function getModelsPaths(): {
+    gsd: string;
+    pi: string;
+};

package/dist/models-resolver.js

@@ -0,0 +1,50 @@
+/**
+ * Models.json resolution with fallback to ~/.pi/agent/models.json
+ *
+ * GSD uses ~/.gsd/agent/models.json, but for a smooth migration/development
+ * experience, this module provides resolution logic that:
+ *
+ * 1. Reads ~/.gsd/agent/models.json if it exists
+ * 2. Falls back to ~/.pi/agent/models.json if GSD file doesn't exist
+ * 3. Merges both files if both exist (GSD takes precedence)
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { agentDir } from './app-paths.js';
+const GSD_MODELS_PATH = join(agentDir, 'models.json');
+const PI_MODELS_PATH = join(homedir(), '.pi', 'agent', 'models.json');
+/**
+ * Resolve the path to models.json with fallback logic.
+ *
+ * Priority:
+ * 1. ~/.gsd/agent/models.json (exists) → return this path
+ * 2. ~/.pi/agent/models.json (exists) → return this path (fallback)
+ * 3. Neither exists → return GSD path (will be created)
+ *
+ * @returns The path to use for models.json
+ */
+export function resolveModelsJsonPath() {
+    if (existsSync(GSD_MODELS_PATH)) {
+        return GSD_MODELS_PATH;
+    }
+    if (existsSync(PI_MODELS_PATH)) {
+        return PI_MODELS_PATH;
+    }
+    return GSD_MODELS_PATH;
+}
+/**
+ * Check if both GSD and PI models.json files exist.
+ */
+export function hasBothModelsFiles() {
+    return existsSync(GSD_MODELS_PATH) && existsSync(PI_MODELS_PATH);
+}
+/**
+ * Get the paths to both models.json files.
+ */
+export function getModelsPaths() {
+    return {
+        gsd: GSD_MODELS_PATH,
+        pi: PI_MODELS_PATH,
+    };
+}

package/dist/resource-loader.js

@@ -1,6 +1,6 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 import { homedir } from 'node:os';
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -113,6 +113,38 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     }
     return compareSemver(managedVersion, currentVersion) > 0 ? managedVersion : null;
 }
+/**
+ * Recursively makes all files and directories under dirPath owner-writable.
+ *
+ * Files copied from the Nix store inherit read-only modes (0444/0555).
+ * Calling this before cpSync prevents overwrite failures on subsequent upgrades,
+ * and calling it after ensures the next run can overwrite the copies too.
+ *
+ * Preserves existing permission bits (including executability) and only adds
+ * owner-write (and for directories, owner-exec) without widening group/other
+ * permissions.
+ */
+function makeTreeWritable(dirPath) {
+    if (!existsSync(dirPath))
+        return;
+    const stats = statSync(dirPath);
+    const isDir = stats.isDirectory();
+    const currentMode = stats.mode & 0o777;
+    // Ensure owner-write; for directories also ensure owner-exec so they remain traversable.
+    let newMode = currentMode | 0o200;
+    if (isDir) {
+        newMode |= 0o100;
+    }
+    if (newMode !== currentMode) {
+        chmodSync(dirPath, newMode);
+    }
+    if (isDir) {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            const entryPath = join(dirPath, entry.name);
+            makeTreeWritable(entryPath);
+        }
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -130,26 +162,49 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
-    // Skip resource sync when versions match — saves ~128ms of cpSync per launch
-    const currentVersion = getBundledGsdVersion();
-    const managedVersion = readManagedResourceVersion(agentDir);
-    if (managedVersion && managedVersion === currentVersion) {
-        return;
-    }
-    // Sync extensions — overwrite so updates land on next launch
+    // Sync extensions — clean bundled subdirs first to remove stale leftover files,
+    // then overwrite so updates land on next launch. Only bundled subdirs are removed;
+    // user-created extension directories are preserved.
     const destExtensions = join(agentDir, 'extensions');
+    makeTreeWritable(destExtensions);
+    for (const entry of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            const target = join(destExtensions, entry.name);
+            if (existsSync(target))
+                rmSync(target, { recursive: true, force: true });
+        }
+    }
     cpSync(bundledExtensionsDir, destExtensions, { recursive: true, force: true });
+    makeTreeWritable(destExtensions);
     // Sync agents
     const destAgents = join(agentDir, 'agents');
     const srcAgents = join(resourcesDir, 'agents');
     if (existsSync(srcAgents)) {
+        makeTreeWritable(destAgents);
+        for (const entry of readdirSync(srcAgents, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destAgents, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcAgents, destAgents, { recursive: true, force: true });
+        makeTreeWritable(destAgents);
     }
-    // Sync skills — overwrite so updates land on next launch
+    // Sync skills
     const destSkills = join(agentDir, 'skills');
     const srcSkills = join(resourcesDir, 'skills');
     if (existsSync(srcSkills)) {
+        makeTreeWritable(destSkills);
+        for (const entry of readdirSync(srcSkills, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destSkills, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcSkills, destSkills, { recursive: true, force: true });
+        makeTreeWritable(destSkills);
     }
     writeManagedResourceManifest(agentDir);
 }

package/dist/resources/extensions/bg-shell/output-formatter.ts

@@ -10,12 +10,19 @@ import {
 import type { BgProcess, OutputDigest, OutputLine, GetOutputOptions } from "./types.js";
 import {
 	ERROR_PATTERNS,
+	ERROR_PATTERN_UNION,
+	WARNING_PATTERN_UNION,
+	READINESS_PATTERN_UNION,
+	BUILD_COMPLETE_PATTERN_UNION,
+	TEST_RESULT_PATTERN_UNION,
 	WARNING_PATTERNS,
 	URL_PATTERN,
 	PORT_PATTERN,
+	PORT_PATTERN_SOURCE,
 	READINESS_PATTERNS,
 	BUILD_COMPLETE_PATTERNS,
 	TEST_RESULT_PATTERNS,
+	LINE_DEDUP_MAX,
 } from "./types.js";
 import { addEvent, pushAlert } from "./process-manager.js";
 import { transitionToReady } from "./readiness-detector.js";
@@ -24,8 +31,8 @@ import { formatUptime, formatTimeAgo } from "./utilities.js";
 // ── Output Analysis ────────────────────────────────────────────────────────
 
 export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "stderr"): void {
-	// Error detection
-	if (ERROR_PATTERNS.some(p => p.test(line))) {
+	// Error detection — single union regex instead of .some(p => p.test(line))
+	if (ERROR_PATTERN_UNION.test(line)) {
 		bg.recentErrors.push(line.trim().slice(0, 200)); // Cap line length
 		if (bg.recentErrors.length > 50) bg.recentErrors.splice(0, bg.recentErrors.length - 50);
 
@@ -40,8 +47,8 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 	}
 
-	// Warning detection
-	if (WARNING_PATTERNS.some(p => p.test(line))) {
+	// Warning detection — single union regex
+	if (WARNING_PATTERN_UNION.test(line)) {
 		bg.recentWarnings.push(line.trim().slice(0, 200));
 		if (bg.recentWarnings.length > 50) bg.recentWarnings.splice(0, bg.recentWarnings.length - 50);
 	}
@@ -56,9 +63,10 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 	}
 
-	// Port extraction
+	// Port extraction — PORT_PATTERN has /g flag so must be re-created per call
+	// Use PORT_PATTERN_SOURCE (string) to avoid re-parsing the literal each time
+	const portRe = new RegExp(PORT_PATTERN_SOURCE, "gi");
 	let portMatch: RegExpExecArray | null;
-	const portRe = new RegExp(PORT_PATTERN.source, PORT_PATTERN.flags);
 	while ((portMatch = portRe.exec(line)) !== null) {
 		const port = parseInt(portMatch[1], 10);
 		if (port > 0 && port <= 65535 && !bg.ports.includes(port)) {
@@ -71,7 +79,7 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 	}
 
-	// Readiness detection
+	// Readiness detection — single union regex
 	if (bg.status === "starting") {
 		// Check custom ready pattern first
 		if (bg.readyPattern) {
@@ -83,14 +91,14 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 
 		// Check built-in readiness patterns
-		if (bg.status === "starting" && READINESS_PATTERNS.some(p => p.test(line))) {
+		if (bg.status === "starting" && READINESS_PATTERN_UNION.test(line)) {
 			transitionToReady(bg, `Readiness pattern matched: ${line.trim().slice(0, 100)}`);
 		}
 	}
 
 	// Recovery detection: if we were in error and see a success pattern
 	if (bg.status === "error") {
-		if (READINESS_PATTERNS.some(p => p.test(line)) || BUILD_COMPLETE_PATTERNS.some(p => p.test(line))) {
+		if (READINESS_PATTERN_UNION.test(line) || BUILD_COMPLETE_PATTERN_UNION.test(line)) {
 			bg.status = "ready";
 			bg.recentErrors = [];
 			addEvent(bg, { type: "recovered", detail: "Process recovered from error state" });
@@ -98,10 +106,22 @@ export function analyzeLine(bg: BgProcess, line: string, stream: "stdout" | "std
 		}
 	}
 
-	// Dedup tracking
+	// Dedup tracking — evict oldest entry when map exceeds LINE_DEDUP_MAX (LRU via Map insertion order)
 	bg.totalRawLines++;
 	const lineHash = line.trim().slice(0, 100);
-	bg.lineDedup.set(lineHash, (bg.lineDedup.get(lineHash) || 0) + 1);
+	const existing = bg.lineDedup.get(lineHash);
+	if (existing !== undefined) {
+		// Re-insert to update insertion order (move to tail = most recent)
+		bg.lineDedup.delete(lineHash);
+		bg.lineDedup.set(lineHash, existing + 1);
+	} else {
+		if (bg.lineDedup.size >= LINE_DEDUP_MAX) {
+			// Evict oldest entry (Map iteration order = insertion order = LRU at head)
+			const oldest = bg.lineDedup.keys().next().value;
+			if (oldest !== undefined) bg.lineDedup.delete(oldest);
+		}
+		bg.lineDedup.set(lineHash, 1);
+	}
 }
 
 // ── Digest Generation ──────────────────────────────────────────────────────
@@ -154,12 +174,12 @@ export function getHighlights(bg: BgProcess, maxLines: number = 15): string[] {
 	for (let i = 0; i < bg.output.length; i++) {
 		const entry = bg.output[i];
 		let score = 0;
-		if (ERROR_PATTERNS.some(p => p.test(entry.line))) score += 10;
-		if (WARNING_PATTERNS.some(p => p.test(entry.line))) score += 5;
+		if (ERROR_PATTERN_UNION.test(entry.line)) score += 10;
+		if (WARNING_PATTERN_UNION.test(entry.line)) score += 5;
 		if (URL_PATTERN.test(entry.line)) score += 3;
-		if (READINESS_PATTERNS.some(p => p.test(entry.line))) score += 8;
-		if (TEST_RESULT_PATTERNS.some(p => p.test(entry.line))) score += 7;
-		if (BUILD_COMPLETE_PATTERNS.some(p => p.test(entry.line))) score += 6;
+		if (READINESS_PATTERN_UNION.test(entry.line)) score += 8;
+		if (TEST_RESULT_PATTERN_UNION.test(entry.line)) score += 7;
+		if (BUILD_COMPLETE_PATTERN_UNION.test(entry.line)) score += 6;
 		// Boost recent lines so highlights favor fresh output over stale
 		if (i >= bg.output.length - 50) score += 2;
 		if (score > 0) {

package/dist/resources/extensions/bg-shell/process-manager.ts

@@ -39,6 +39,8 @@ export function setPendingAlerts(alerts: string[]): void {
 
 export function addOutputLine(bg: BgProcess, stream: "stdout" | "stderr", line: string): void {
 	bg.output.push({ stream, line, ts: Date.now() });
+	if (stream === "stdout") bg.stdoutLineCount++;
+	else bg.stderrLineCount++;
 	if (bg.output.length > MAX_BUFFER_LINES) {
 		const excess = bg.output.length - MAX_BUFFER_LINES;
 		bg.output.splice(0, excess);
@@ -60,8 +62,6 @@ export function pushAlert(bg: BgProcess, message: string): void {
 }
 
 export function getInfo(p: BgProcess): BgProcessInfo {
-	const stdoutLines = p.output.filter(l => l.stream === "stdout").length;
-	const stderrLines = p.output.filter(l => l.stream === "stderr").length;
 	return {
 		id: p.id,
 		label: p.label,
@@ -72,8 +72,8 @@ export function getInfo(p: BgProcess): BgProcessInfo {
 		exitCode: p.exitCode,
 		signal: p.signal,
 		outputLines: p.output.length,
-		stdoutLines,
-		stderrLines,
+		stdoutLines: p.stdoutLineCount,
+		stderrLines: p.stderrLineCount,
 		status: p.status,
 		processType: p.processType,
 		ports: p.ports,
@@ -161,6 +161,8 @@ export function startProcess(opts: StartOptions): BgProcess {
 		commandHistory: [],
 		lineDedup: new Map(),
 		totalRawLines: 0,
+		stdoutLineCount: 0,
+		stderrLineCount: 0,
 		envKeys: Object.keys(opts.env || {}),
 		restartCount: 0,
 		startConfig: {

package/dist/resources/extensions/bg-shell/types.ts

@@ -90,10 +90,14 @@ export interface BgProcess {
 	lastWarningCount: number;
 	/** Command history for shell-type sessions */
 	commandHistory: string[];
-	/** Dedup tracker: hash → count of repeated lines */
+	/** Dedup tracker: hash → count of repeated lines (capped at LINE_DEDUP_MAX entries) */
 	lineDedup: Map<string, number>;
 	/** Total raw lines (before dedup) for token savings calc */
 	totalRawLines: number;
+	/** Tracked stdout line count (incremented in addOutputLine, avoids O(n) filter) */
+	stdoutLineCount: number;
+	/** Tracked stderr line count (incremented in addOutputLine, avoids O(n) filter) */
+	stderrLineCount: number;
 	/** Env snapshot (keys only, no values for security) */
 	envKeys: string[];
 	/** Restart count */
@@ -163,6 +167,8 @@ export interface ProcessManifest {
 export const MAX_BUFFER_LINES = 5000;
 export const MAX_EVENTS = 200;
 export const DEAD_PROCESS_TTL = 10 * 60 * 1000;
+/** Maximum unique entries in the per-process lineDedup Map before LRU eviction. */
+export const LINE_DEDUP_MAX = 500;
 export const PORT_PROBE_TIMEOUT = 500;
 export const READY_POLL_INTERVAL = 250;
 export const DEFAULT_READY_TIMEOUT = 30000;
@@ -249,3 +255,29 @@ export const BUILD_COMPLETE_PATTERNS: RegExp[] = [
 	/webpack\s+\d+\.\d+/i,
 	/bundle\s+(?:is\s+)?ready/i,
 ];
+
+// ── Compiled union regexes (single-pass alternatives to .some(p => p.test(line))) ──
+// Built once at module load — eliminates per-line RegExp construction overhead.
+
+export const ERROR_PATTERN_UNION = new RegExp(
+	ERROR_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const WARNING_PATTERN_UNION = new RegExp(
+	WARNING_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const READINESS_PATTERN_UNION = new RegExp(
+	READINESS_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const BUILD_COMPLETE_PATTERN_UNION = new RegExp(
+	BUILD_COMPLETE_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+export const TEST_RESULT_PATTERN_UNION = new RegExp(
+	TEST_RESULT_PATTERNS.map(p => p.source).join("|"),
+	"i",
+);
+/** PORT_PATTERN compiled once for reuse in analyzeLine (needs exec, so must be re-created per call with /g) */
+export const PORT_PATTERN_SOURCE = PORT_PATTERN.source;

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

@@ -10,9 +10,11 @@ import sharp from "sharp";
 import type { CompactPageState, CompactSelectorState } from "./state.js";
 import { formatCompactStateSummary } from "./utils.js";
 
-// Anthropic API rejects images > 2000px in multi-image requests.
-// Cap at 1568px (recommended optimal size) to stay well within limits.
-const MAX_SCREENSHOT_DIM = 1568;
+// Anthropic vision: 1568px is the recommended optimal width. Height is capped
+// generously at 8000px so tall full-page screenshots remain readable rather
+// than being squished into a square constraint.
+const MAX_SCREENSHOT_WIDTH = 1568;
+const MAX_SCREENSHOT_HEIGHT = 8000;
 
 // ---------------------------------------------------------------------------
 // Compact page state capture
@@ -120,9 +122,10 @@ export async function postActionSummary(p: Page, target?: Page | Frame): Promise
 // ---------------------------------------------------------------------------
 
 /**
- * If either dimension of the image buffer exceeds MAX_SCREENSHOT_DIM,
- * downscale proportionally using sharp. Returns the original buffer
- * unchanged if already within limits.
+ * Constrain screenshot dimensions for the Anthropic vision API.
+ * Width is capped at 1568px (optimal) and height at 8000px, each
+ * independently, using `fit: "inside"` so aspect ratio is preserved.
+ * Small images are never upscaled.
  *
  * `page` parameter is retained for ToolDeps signature stability (D008)
  * but is no longer used — all processing is server-side via sharp.
@@ -133,18 +136,17 @@ export async function constrainScreenshot(
 	mimeType: string,
 	quality: number,
 ): Promise<Buffer> {
-	const { width, height } = await sharp(buffer).metadata();
+	const meta = await sharp(buffer).metadata();
+	const width = meta.width;
+	const height = meta.height;
 
-	if (
-		width !== undefined &&
-		height !== undefined &&
-		width <= MAX_SCREENSHOT_DIM &&
-		height <= MAX_SCREENSHOT_DIM
-	) {
-		return buffer;
-	}
+	if (width === undefined || height === undefined) return buffer;
+	if (width <= MAX_SCREENSHOT_WIDTH && height <= MAX_SCREENSHOT_HEIGHT) return buffer;
 
-	const resizer = sharp(buffer).resize(MAX_SCREENSHOT_DIM, MAX_SCREENSHOT_DIM, { fit: "inside" });
+	const resizer = sharp(buffer).resize(MAX_SCREENSHOT_WIDTH, MAX_SCREENSHOT_HEIGHT, {
+		fit: "inside",
+		withoutEnlargement: true,
+	});
 
 	if (mimeType === "image/png") {
 		return Buffer.from(await resizer.png().toBuffer());

package/dist/resources/extensions/browser-tools/index.ts

@@ -17,6 +17,16 @@ import { registerWaitTools } from "./tools/wait.js";
 import { registerPageTools } from "./tools/pages.js";
 import { registerFormTools } from "./tools/forms.js";
 import { registerIntentTools } from "./tools/intent.js";
+import { registerPdfTools } from "./tools/pdf.js";
+import { registerStatePersistenceTools } from "./tools/state-persistence.js";
+import { registerNetworkMockTools } from "./tools/network-mock.js";
+import { registerDeviceTools } from "./tools/device.js";
+import { registerExtractTools } from "./tools/extract.js";
+import { registerVisualDiffTools } from "./tools/visual-diff.js";
+import { registerZoomTools } from "./tools/zoom.js";
+import { registerCodegenTools } from "./tools/codegen.js";
+import { registerActionCacheTools } from "./tools/action-cache.js";
+import { registerInjectionDetectionTools } from "./tools/injection-detect.js";
 
 export default function (pi: ExtensionAPI) {
 	pi.on("session_shutdown", async () => { await closeBrowser(); });
@@ -48,4 +58,14 @@ export default function (pi: ExtensionAPI) {
 	registerPageTools(pi, deps);
 	registerFormTools(pi, deps);
 	registerIntentTools(pi, deps);
+	registerPdfTools(pi, deps);
+	registerStatePersistenceTools(pi, deps);
+	registerNetworkMockTools(pi, deps);
+	registerDeviceTools(pi, deps);
+	registerExtractTools(pi, deps);
+	registerVisualDiffTools(pi, deps);
+	registerZoomTools(pi, deps);
+	registerCodegenTools(pi, deps);
+	registerActionCacheTools(pi, deps);
+	registerInjectionDetectionTools(pi, deps);
 }