@wrongstack/tools 0.285.0 → 0.286.0

package/dist/pack.js

@@ -56,7 +56,7 @@ function createOutputSpool(opts) {
   let filePath = null;
   let failed = false;
   let finalized = false;
-  const open2 = () => {
+  const open3 = () => {
     if (stream || failed) return;
     try {
       const dir = toolOutputDir();
@@ -89,7 +89,7 @@ function createOutputSpool(opts) {
           return;
         }
         head += text;
-        open2();
+        open3();
         head = "";
         return;
       }
@@ -907,8 +907,8 @@ async function* spawnStream(opts) {
   try {
     for (; ; ) {
       while (queue.length === 0) {
-        await new Promise((resolve11) => {
-          waiter = resolve11;
+        await new Promise((resolve14) => {
+          waiter = resolve14;
         });
       }
       const chunk = queue.shift();
@@ -982,14 +982,14 @@ function sha256hex(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 async function detectPackageManager(cwd) {
-  const { stat: stat15 } = await import("node:fs/promises");
+  const { stat: stat17 } = await import("node:fs/promises");
   try {
-    await stat15(`${cwd}/pnpm-lock.yaml`);
+    await stat17(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
   } catch {
   }
   try {
-    await stat15(`${cwd}/yarn.lock`);
+    await stat17(`${cwd}/yarn.lock`);
     return "yarn";
   } catch {
   }
@@ -2558,8 +2558,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, signal)
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename7, profiles, state) {
-  const lower = basename7.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename8, profiles, state) {
+  const lower = basename8.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2570,7 +2570,7 @@ function collectFileEvidence(directory, fullPath, basename7, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename7,
+        value: basename8,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -2698,8 +2698,8 @@ function normalizeLimits(input) {
 async function canonicalDirectory(input) {
   const resolved = path4.resolve(input);
   const real = await fs2.realpath(resolved);
-  const stat15 = await fs2.stat(real);
-  if (!stat15.isDirectory()) throw new Error(`Project root is not a directory: ${input}`);
+  const stat17 = await fs2.stat(real);
+  if (!stat17.isDirectory()) throw new Error(`Project root is not a directory: ${input}`);
   return real;
 }
 async function canonicalInside(input, root, label) {
@@ -2719,12 +2719,12 @@ function resolveFrom(cwd, input) {
   return path4.isAbsolute(input) ? input : path4.resolve(cwd, input);
 }
 function isInside(candidate, root) {
-  const relative10 = path4.relative(root, candidate);
-  return relative10 === "" || !relative10.startsWith("..") && !path4.isAbsolute(relative10);
+  const relative12 = path4.relative(root, candidate);
+  return relative12 === "" || !relative12.startsWith("..") && !path4.isAbsolute(relative12);
 }
 function pathDepth(candidate, root) {
-  const relative10 = path4.relative(root, candidate);
-  return relative10 === "" ? 0 : relative10.split(path4.sep).length;
+  const relative12 = path4.relative(root, candidate);
+  return relative12 === "" ? 0 : relative12.split(path4.sep).length;
 }
 function dedupeEvidence(items) {
   const seen = /* @__PURE__ */ new Set();
@@ -3424,8 +3424,8 @@ function compareCandidates(a, b) {
   return b.confidence - a.confidence || a.language.localeCompare(b.language) || a.root.localeCompare(b.root);
 }
 function workspaceDepth(workspaceRoot, projectRoot) {
-  const relative10 = path6.relative(path6.resolve(projectRoot), path6.resolve(workspaceRoot));
-  return relative10 === "" ? 0 : relative10.split(path6.sep).length;
+  const relative12 = path6.relative(path6.resolve(projectRoot), path6.resolve(workspaceRoot));
+  return relative12 === "" ? 0 : relative12.split(path6.sep).length;
 }
 function validateOperationOptions(operation, packages) {
   if (!operation.startsWith("package-") || !packages) return;
@@ -3455,8 +3455,8 @@ async function canonicalTarget(cwd, target, projectRoot) {
   return real;
 }
 function isInside2(candidate, root) {
-  const relative10 = path6.relative(path6.resolve(root), path6.resolve(candidate));
-  return relative10 === "" || !relative10.startsWith("..") && !path6.isAbsolute(relative10);
+  const relative12 = path6.relative(path6.resolve(root), path6.resolve(candidate));
+  return relative12 === "" || !relative12.startsWith("..") && !path6.isAbsolute(relative12);
 }
 var MAX_ARGUMENTS, MAX_ARGUMENT_LENGTH, PACKAGE_NAME_RE, COMPOSER_PACKAGE_RE, GO_MODULE_RE;
 var init_plan = __esm({
@@ -3587,8 +3587,8 @@ async function executeInternal(options, startedAt) {
   const target = options.plan.evidence.find((item) => item.kind === "target")?.path;
   if (!target) return unavailableResult(options, "Internal syntax plan has no target evidence.");
   const safeTarget = await assertContainedFile(target, options.projectRoot);
-  const stat15 = await fs4.stat(safeTarget);
-  if (stat15.size > MAX_INTERNAL_SOURCE_BYTES) {
+  const stat17 = await fs4.stat(safeTarget);
+  if (stat17.size > MAX_INTERNAL_SOURCE_BYTES) {
     return unavailableResult(
       options,
       `Internal syntax target exceeds ${MAX_INTERNAL_SOURCE_BYTES} bytes.`
@@ -3635,14 +3635,14 @@ async function validatePlanRealpaths(plan, projectRoot) {
   return void 0;
 }
 function isRealInside(candidate, root) {
-  const relative10 = path7.relative(root, candidate);
-  return relative10 === "" || !relative10.startsWith("..") && !path7.isAbsolute(relative10);
+  const relative12 = path7.relative(root, candidate);
+  return relative12 === "" || !relative12.startsWith("..") && !path7.isAbsolute(relative12);
 }
 async function assertContainedFile(candidate, projectRoot) {
   const realRoot = await fs4.realpath(projectRoot);
   const realTarget = await fs4.realpath(candidate);
-  const relative10 = path7.relative(realRoot, realTarget);
-  if (relative10.startsWith("..") || path7.isAbsolute(relative10)) {
+  const relative12 = path7.relative(realRoot, realTarget);
+  if (relative12.startsWith("..") || path7.isAbsolute(relative12)) {
     throw new Error(`Internal syntax target resolves outside project root: ${candidate}`);
   }
   return realTarget;
@@ -3875,8 +3875,8 @@ async function snapshotPaths(paths) {
   const existing = [];
   for (const candidate of paths) {
     try {
-      const stat15 = await fs4.stat(candidate);
-      if (!stat15.isFile()) continue;
+      const stat17 = await fs4.stat(candidate);
+      if (!stat17.isFile()) continue;
       existing.push(candidate);
     } catch {
     }
@@ -3887,15 +3887,15 @@ async function changedPaths(before, after, beforeSizes, afterSizes) {
   const beforeSet = new Set(before);
   const afterSet = new Set(after);
   const changed = /* @__PURE__ */ new Set();
-  for (const path28 of after) {
-    if (!beforeSet.has(path28)) changed.add(path28);
+  for (const path32 of after) {
+    if (!beforeSet.has(path32)) changed.add(path32);
   }
-  for (const path28 of before) {
-    if (!afterSet.has(path28)) changed.add(path28);
+  for (const path32 of before) {
+    if (!afterSet.has(path32)) changed.add(path32);
   }
   if (beforeSizes && afterSizes) {
-    for (const path28 of after) {
-      if (beforeSizes.get(path28) !== afterSizes.get(path28)) changed.add(path28);
+    for (const path32 of after) {
+      if (beforeSizes.get(path32) !== afterSizes.get(path32)) changed.add(path32);
     }
   }
   return [...changed].sort();
@@ -3904,8 +3904,8 @@ async function snapshotSizes(paths) {
   const sizes = /* @__PURE__ */ new Map();
   for (const candidate of paths) {
     try {
-      const stat15 = await fs4.stat(candidate);
-      if (stat15.isFile()) sizes.set(candidate, stat15.size);
+      const stat17 = await fs4.stat(candidate);
+      if (stat17.isFile()) sizes.set(candidate, stat17.size);
     } catch {
     }
   }
@@ -4848,8 +4848,8 @@ var auditTool = {
     yield { type: "final", output: parseAuditOutput(result.stdout, result.exitCode) };
   }
 };
-function parseAuditOutput(json, exitCode) {
-  if (!json) {
+function parseAuditOutput(json2, exitCode) {
+  if (!json2) {
     return {
       exit_code: exitCode,
       vulnerabilities: [],
@@ -4860,7 +4860,7 @@ function parseAuditOutput(json, exitCode) {
     };
   }
   try {
-    const data = JSON.parse(json);
+    const data = JSON.parse(json2);
     const advisories = [];
     const ads = data.advisories ?? {};
     for (const id of Object.keys(ads)) {
@@ -4879,8 +4879,8 @@ function parseAuditOutput(json, exitCode) {
       vulnerabilities: advisories,
       total,
       summary,
-      output: json,
-      truncated: json.length > 1e5
+      output: json2,
+      truncated: json2.length > 1e5
     };
   } catch {
     return {
@@ -4888,7 +4888,7 @@ function parseAuditOutput(json, exitCode) {
       vulnerabilities: [],
       total: 0,
       summary: "Could not parse audit output",
-      output: json,
+      output: json2,
       truncated: false
     };
   }
@@ -5916,10 +5916,10 @@ var bashTool = {
         queue.push(c);
       }
     };
-    const next = () => new Promise((resolve11) => {
+    const next = () => new Promise((resolve14) => {
       const c = queue.shift();
-      if (c) resolve11(c);
-      else resolveNext = resolve11;
+      if (c) resolve14(c);
+      else resolveNext = resolve14;
     });
     let lastFlush = Date.now();
     const flush = () => {
@@ -6159,6 +6159,1238 @@ async function executeSingle(call, ctx, opts) {
   }
 }
 
+// src/browser/tools.ts
+import * as path12 from "node:path";
+import { ToolCapabilities } from "@wrongstack/core";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+
+// src/browser/manager.ts
+import * as fs8 from "node:fs/promises";
+import * as path11 from "node:path";
+import { ulid as ulid2 } from "@wrongstack/core/utils";
+
+// src/browser/artifacts.ts
+import { createHash as createHash3 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import * as fs7 from "node:fs/promises";
+import * as path10 from "node:path";
+import { atomicWrite, ulid } from "@wrongstack/core/utils";
+var BrowserArtifactStore = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  async write(sessionId, kind, extension, mimeType, content) {
+    const id = ulid();
+    const dir = path10.join(this.root, safeSegment(sessionId));
+    const target = path10.join(dir, `${id}.${extension.replace(/^\./, "")}`);
+    await atomicWrite(target, content, { mode: 384 });
+    return this.record(id, sessionId, kind, target, mimeType);
+  }
+  async record(id, sessionId, kind, target, mimeType) {
+    await fs7.chmod(target, 384).catch(() => void 0);
+    const [stat17, sha256] = await Promise.all([fs7.stat(target), hashFile(target)]);
+    const artifact = {
+      id,
+      kind,
+      sensitivity: "sensitive",
+      path: target,
+      mimeType,
+      sizeBytes: stat17.size,
+      sha256,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const metadataPath = path10.join(path10.dirname(target), `${id}.metadata.json`);
+    try {
+      await atomicWrite(
+        metadataPath,
+        `${JSON.stringify({
+          id: artifact.id,
+          sessionId: safeSegment(sessionId),
+          kind: artifact.kind,
+          sensitivity: artifact.sensitivity,
+          mimeType: artifact.mimeType,
+          sizeBytes: artifact.sizeBytes,
+          sha256: artifact.sha256,
+          createdAt: artifact.createdAt
+        })}
+`,
+        { mode: 384 }
+      );
+    } catch (error) {
+      await fs7.rm(target, { force: true }).catch(() => void 0);
+      throw error;
+    }
+    return artifact;
+  }
+  pathFor(sessionId, extension) {
+    const id = ulid();
+    return {
+      id,
+      path: path10.join(this.root, safeSegment(sessionId), `${id}.${extension.replace(/^\./, "")}`)
+    };
+  }
+  async describe(id, kind, target, mimeType) {
+    return this.record(id, path10.basename(path10.dirname(target)), kind, target, mimeType);
+  }
+};
+async function hashFile(target) {
+  const hash = createHash3("sha256");
+  await new Promise((resolve14, reject) => {
+    const stream = createReadStream(target);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.once("error", reject);
+    stream.once("end", resolve14);
+  });
+  return hash.digest("hex");
+}
+function safeSegment(value) {
+  return value.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 80);
+}
+
+// src/browser/network-guard-proxy.ts
+import * as http from "node:http";
+import * as net2 from "node:net";
+
+// src/browser/security.ts
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+import { assertNotPrivateHost, isPrivateIPv4, isPrivateIPv6 } from "@wrongstack/core/utils";
+var SAFE_SUBRESOURCE_PROTOCOLS = /* @__PURE__ */ new Set(["about:", "blob:", "data:"]);
+async function assertBrowserUrlAllowed(rawUrl, opts) {
+  const url = parseBrowserUrl(rawUrl, opts.navigation ?? true);
+  if (!opts.navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
+  if (!opts.allowPrivateHosts && !isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins)) {
+    await assertNotPrivateHost(url.hostname);
+  }
+  return url;
+}
+async function resolvePinnedBrowserTarget(rawUrl, opts = {}) {
+  const url = parseBrowserUrl(rawUrl, true);
+  const allowPrivate = opts.allowPrivateHosts === true || isAllowedPrivateOrigin(url, opts.allowedPrivateOrigins);
+  const hostname2 = unbracket(url.hostname);
+  const literalFamily = net.isIP(hostname2);
+  if (literalFamily === 4 || literalFamily === 6) {
+    if (!allowPrivate && isPrivateAddress(hostname2, literalFamily)) {
+      throw new Error(`browser: blocked private/loopback address "${hostname2}"`);
+    }
+    return { url, address: hostname2, family: literalFamily };
+  }
+  if ((hostname2 === "localhost" || hostname2.endsWith(".localhost")) && !allowPrivate) {
+    throw new Error("browser: blocked localhost target");
+  }
+  const lookup3 = opts.lookup ?? ((host) => dns.lookup(host, { all: true }));
+  let records;
+  try {
+    records = await lookup3(hostname2);
+  } catch (error) {
+    throw new Error(
+      `browser: DNS resolution failed for "${hostname2}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (records.length === 0) throw new Error(`browser: DNS returned no addresses for "${hostname2}"`);
+  for (const record of records) {
+    if (record.family !== 4 && record.family !== 6) {
+      throw new Error(`browser: DNS returned an unsupported address family for "${hostname2}"`);
+    }
+    if (!allowPrivate && isPrivateAddress(record.address, record.family)) {
+      throw new Error(`browser: resolved to private address ${record.address}`);
+    }
+  }
+  const selected = records[0];
+  return { url, address: selected.address, family: selected.family };
+}
+function parsePrivateOriginAllowlist(raw) {
+  if (!raw?.trim()) return [];
+  const origins = /* @__PURE__ */ new Set();
+  for (const entry of raw.split(",")) {
+    const candidate = entry.trim();
+    if (!candidate) continue;
+    const url = parseBrowserUrl(candidate, true);
+    if (url.pathname !== "/" || url.search || url.hash) {
+      throw new Error(`browser: private origin allowlist entry must be an origin: "${candidate}"`);
+    }
+    origins.add(url.origin);
+  }
+  return [...origins];
+}
+function parseBrowserUrl(rawUrl, navigation) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error("browser: url must be an absolute URL");
+  }
+  if (!navigation && SAFE_SUBRESOURCE_PROTOCOLS.has(url.protocol)) return url;
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`browser: unsupported protocol "${url.protocol}"`);
+  }
+  if (url.username || url.password) {
+    throw new Error("browser: credentials in URLs are not allowed");
+  }
+  return url;
+}
+function isAllowedPrivateOrigin(url, origins) {
+  return origins?.includes(url.origin) ?? false;
+}
+function isPrivateAddress(address, family) {
+  return family === 4 ? isPrivateIPv4(address) : isPrivateIPv6(address);
+}
+function unbracket(hostname2) {
+  return hostname2.startsWith("[") && hostname2.endsWith("]") ? hostname2.slice(1, -1) : hostname2;
+}
+function safeBrowserUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return "about:blank";
+  }
+}
+function redactBrowserText(text) {
+  return text.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]").replace(
+    /\b(api[-_ ]?key|access[-_ ]?token|auth[-_ ]?token|token|password|secret)\b\s*[:=]\s*[^\s,;]+/gi,
+    "$1=[REDACTED]"
+  );
+}
+
+// src/browser/network-guard-proxy.ts
+var BrowserNetworkGuardProxy = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.server = http.createServer((request2, response) => {
+      void this.forwardHttp(request2, response);
+    });
+    this.server.on("connect", (request2, socket, head) => {
+      void this.forwardConnect(request2, socket, head);
+    });
+    this.server.on("upgrade", (request2, socket, head) => {
+      void this.forwardUpgrade(request2, socket, head);
+    });
+    this.server.on("connection", (socket) => {
+      this.sockets.add(socket);
+      socket.once("close", () => this.sockets.delete(socket));
+    });
+    this.server.on("clientError", (_error, socket) => {
+      socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+    });
+  }
+  options;
+  server;
+  sockets = /* @__PURE__ */ new Set();
+  startPromise;
+  url;
+  async start() {
+    if (this.url) return this.url;
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = new Promise((resolve14, reject) => {
+      const onError = (error) => {
+        this.server.off("listening", onListening);
+        reject(error);
+      };
+      const onListening = () => {
+        this.server.off("error", onError);
+        const address = this.server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("browser: network guard proxy failed to bind"));
+          return;
+        }
+        this.url = `http://127.0.0.1:${address.port}`;
+        resolve14(this.url);
+      };
+      this.server.once("error", onError);
+      this.server.once("listening", onListening);
+      this.server.listen(0, "127.0.0.1");
+    }).finally(() => {
+      this.startPromise = void 0;
+    });
+    return this.startPromise;
+  }
+  async close() {
+    this.url = void 0;
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    if (!this.server.listening) return;
+    await new Promise((resolve14) => this.server.close(() => resolve14()));
+  }
+  async forwardHttp(request2, response) {
+    try {
+      const target = await this.resolve(request2.url ?? "");
+      if (target.url.protocol !== "http:") throw new Error("browser: HTTPS must use CONNECT");
+      const headers = sanitizeHeaders(request2.headers);
+      headers.host = target.url.host;
+      const upstream = http.request({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 80),
+        method: request2.method,
+        path: `${target.url.pathname}${target.url.search}`,
+        headers,
+        agent: false
+      });
+      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => {
+        upstream.destroy(new Error("browser: upstream connection timed out"));
+      });
+      upstream.on("response", (upstreamResponse) => {
+        response.writeHead(
+          upstreamResponse.statusCode ?? 502,
+          sanitizeHeaders(upstreamResponse.headers)
+        );
+        upstreamResponse.pipe(response);
+      });
+      upstream.on("error", () => writeProxyError(response, 502, "Bad Gateway"));
+      request2.on("aborted", () => upstream.destroy());
+      request2.pipe(upstream);
+    } catch {
+      writeProxyError(response, 403, "Blocked by browser network policy");
+    }
+  }
+  async forwardConnect(request2, client, head) {
+    try {
+      const authority = request2.url ?? "";
+      const target = await this.resolve(`https://${authority}`);
+      const upstream = net2.connect({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 443)
+      });
+      upstream.setTimeout(this.options.connectTimeoutMs ?? 3e4, () => upstream.destroy());
+      upstream.once("connect", () => {
+        client.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        if (head.length > 0) upstream.write(head);
+        upstream.pipe(client);
+        client.pipe(upstream);
+      });
+      upstream.once("error", () => {
+        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+      });
+      client.once("close", () => upstream.destroy());
+    } catch {
+      client.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+    }
+  }
+  async forwardUpgrade(request2, client, head) {
+    let upstream;
+    try {
+      const rawUrl = request2.url ?? "";
+      const websocketUrl = new URL(rawUrl);
+      if (websocketUrl.protocol !== "ws:") {
+        throw new Error("browser: only plain ws upgrades are handled by the HTTP proxy");
+      }
+      websocketUrl.protocol = "http:";
+      const target = await this.resolve(websocketUrl.toString());
+      const headers = sanitizeHeaders(request2.headers, true);
+      headers.host = target.url.host;
+      upstream = http.request({
+        host: target.address,
+        family: target.family,
+        port: Number(target.url.port || 80),
+        method: request2.method,
+        path: `${target.url.pathname}${target.url.search}`,
+        headers,
+        agent: false
+      });
+      upstream.once("upgrade", (response, upstreamSocket, upstreamHead) => {
+        writeRawResponseHead(client, response);
+        if (head.length > 0) upstreamSocket.write(head);
+        if (upstreamHead.length > 0) client.write(upstreamHead);
+        upstreamSocket.pipe(client);
+        client.pipe(upstreamSocket);
+        client.once("close", () => upstreamSocket.destroy());
+      });
+      upstream.once("response", (response) => {
+        writeRawResponseHead(client, response);
+        response.pipe(client);
+      });
+      upstream.once("error", () => {
+        client.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\n\r\n");
+      });
+      client.once("close", () => upstream?.destroy());
+      upstream.end();
+    } catch {
+      upstream?.destroy();
+      client.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+    }
+  }
+  resolve(rawUrl) {
+    return resolvePinnedBrowserTarget(rawUrl, {
+      allowPrivateHosts: this.options.allowPrivateHosts,
+      allowedPrivateOrigins: this.options.allowedPrivateOrigins,
+      lookup: this.options.lookup
+    });
+  }
+};
+function sanitizeHeaders(headers, preserveUpgrade = false) {
+  const sanitized = { ...headers };
+  delete sanitized["proxy-authorization"];
+  delete sanitized["proxy-connection"];
+  if (!preserveUpgrade) delete sanitized.connection;
+  return sanitized;
+}
+function writeRawResponseHead(client, response) {
+  const status = response.statusCode ?? 502;
+  const statusText = response.statusMessage ?? "Bad Gateway";
+  const lines = [`HTTP/1.1 ${status} ${statusText}`];
+  for (let index = 0; index < response.rawHeaders.length; index += 2) {
+    lines.push(`${response.rawHeaders[index]}: ${response.rawHeaders[index + 1]}`);
+  }
+  client.write(`${lines.join("\r\n")}\r
+\r
+`);
+}
+function writeProxyError(response, status, message) {
+  if (response.headersSent || response.destroyed) return;
+  response.writeHead(status, { "content-type": "text/plain", connection: "close" });
+  response.end(message);
+}
+
+// src/browser/manager.ts
+var DEFAULT_OPERATION_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_SNAPSHOT_CHARS = 64 * 1024;
+var DEFAULT_MAX_ENTRIES = 100;
+var BrowserSessionManager = class {
+  constructor(options, launcher = defaultLauncher) {
+    this.launcher = launcher;
+    this.artifacts = new BrowserArtifactStore(options.artifactRoot);
+    this.allowPrivateHosts = options.allowPrivateHosts ?? false;
+    this.allowedPrivateOrigins = options.allowedPrivateOrigins ?? [];
+    this.networkProxy = new BrowserNetworkGuardProxy({
+      allowPrivateHosts: this.allowPrivateHosts,
+      allowedPrivateOrigins: this.allowedPrivateOrigins
+    });
+    this.headless = options.headless ?? true;
+    this.operationTimeoutMs = options.operationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+    this.maxSnapshotChars = options.maxSnapshotChars ?? DEFAULT_MAX_SNAPSHOT_CHARS;
+    this.maxConsoleEntries = options.maxConsoleEntries ?? DEFAULT_MAX_ENTRIES;
+    this.maxNetworkEntries = options.maxNetworkEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  launcher;
+  sessions = /* @__PURE__ */ new Map();
+  artifacts;
+  allowPrivateHosts;
+  allowedPrivateOrigins;
+  networkProxy;
+  headless;
+  operationTimeoutMs;
+  maxSnapshotChars;
+  maxConsoleEntries;
+  maxNetworkEntries;
+  browser;
+  launching;
+  async open(ownerId, input, signal) {
+    signal.throwIfAborted();
+    if (input.url) {
+      await assertBrowserUrlAllowed(input.url, {
+        allowPrivateHosts: this.allowPrivateHosts,
+        allowedPrivateOrigins: this.allowedPrivateOrigins,
+        navigation: true
+      });
+    }
+    const browser = await this.ensureBrowser(signal);
+    const proxyServer = await this.networkProxy.start();
+    const context = await abortable(
+      signal,
+      async () => {
+        const created = await browser.newContext({
+          acceptDownloads: false,
+          ignoreHTTPSErrors: false,
+          serviceWorkers: "block",
+          proxy: { server: proxyServer },
+          viewport: input.viewport ?? { width: 1440, height: 900 }
+        });
+        if (signal.aborted) {
+          await created.close().catch(() => void 0);
+          signal.throwIfAborted();
+        }
+        return created;
+      },
+      () => void 0
+    );
+    const session = {
+      id: ulid2(),
+      ownerId,
+      context,
+      page: await context.newPage(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tracing: input.trace ?? true,
+      console: [],
+      network: []
+    };
+    this.sessions.set(session.id, session);
+    this.attachEvidenceCollectors(session);
+    await context.route("**/*", async (route) => {
+      try {
+        await assertBrowserUrlAllowed(route.request().url(), {
+          allowPrivateHosts: this.allowPrivateHosts,
+          allowedPrivateOrigins: this.allowedPrivateOrigins,
+          navigation: false
+        });
+        await route.continue();
+      } catch {
+        this.pushNetwork(session, {
+          method: route.request().method(),
+          url: safeBrowserUrl(route.request().url()),
+          failed: true,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        await route.abort("blockedbyclient");
+      }
+    });
+    try {
+      if (session.tracing) {
+        await context.tracing.start({ screenshots: true, snapshots: true, sources: false });
+      }
+      if (input.url) await this.navigate(session.id, ownerId, input.url, signal);
+      return await this.summary(session);
+    } catch (err) {
+      await context.close().catch(() => void 0);
+      this.sessions.delete(session.id);
+      await this.closeBrowserIfIdle();
+      throw err;
+    }
+  }
+  async list(ownerId) {
+    const owned = [...this.sessions.values()].filter((session) => session.ownerId === ownerId);
+    return Promise.all(owned.map((session) => this.summary(session)));
+  }
+  async navigate(id, ownerId, rawUrl, signal) {
+    await assertBrowserUrlAllowed(rawUrl, {
+      allowPrivateHosts: this.allowPrivateHosts,
+      allowedPrivateOrigins: this.allowedPrivateOrigins,
+      navigation: true
+    });
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.goto(rawUrl, {
+        waitUntil: "domcontentloaded",
+        timeout: this.operationTimeoutMs
+      })
+    );
+    return this.summary(session);
+  }
+  async snapshot(id, ownerId, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const raw = await this.runPageOperation(session, signal, async () => {
+      try {
+        return await session.page.locator("body").ariaSnapshot({ timeout: this.operationTimeoutMs });
+      } catch {
+        return await session.page.locator("body").innerText({ timeout: this.operationTimeoutMs });
+      }
+    });
+    const aria = redactBrowserText(raw);
+    const truncated = aria.length > this.maxSnapshotChars;
+    return {
+      session: await this.summary(session),
+      aria: truncated ? `${aria.slice(0, this.maxSnapshotChars)}
+\u2026[snapshot truncated]` : aria,
+      console: session.console.map((entry) => ({ ...entry })),
+      network: session.network.map((entry) => ({ ...entry })),
+      truncated
+    };
+  }
+  async screenshot(id, ownerId, input, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const bytes = await this.runPageOperation(
+      session,
+      signal,
+      () => input.selector ? session.page.locator(input.selector).screenshot({ type: "png", timeout: this.operationTimeoutMs }) : session.page.screenshot({ type: "png", fullPage: input.fullPage ?? false })
+    );
+    signal.throwIfAborted();
+    return this.artifacts.write(session.id, "screenshot", "png", "image/png", bytes);
+  }
+  async click(id, ownerId, selector, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).click({ timeout: this.operationTimeoutMs })
+    );
+  }
+  async type(id, ownerId, selector, text, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).fill(text, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async select(id, ownerId, selector, value, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).selectOption(value, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async press(id, ownerId, key, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(session, signal, () => session.page.keyboard.press(key));
+  }
+  async hover(id, ownerId, selector, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).hover({ timeout: this.operationTimeoutMs })
+    );
+  }
+  async wait(id, ownerId, input, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const timeout = Math.min(
+      Math.max(input.timeoutMs ?? this.operationTimeoutMs, 0),
+      this.operationTimeoutMs
+    );
+    await this.runPageOperation(
+      session,
+      signal,
+      () => input.selector ? session.page.locator(input.selector).waitFor({ state: "visible", timeout }) : session.page.waitForTimeout(timeout)
+    );
+  }
+  async drag(id, ownerId, from, to, signal) {
+    const session = this.requireOwned(id, ownerId);
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(from).dragTo(session.page.locator(to), {
+        timeout: this.operationTimeoutMs
+      })
+    );
+  }
+  async upload(id, ownerId, selector, files, projectRoot, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const root = path11.resolve(projectRoot);
+    const realRoot = await fs8.realpath(root);
+    const resolved = [];
+    for (const file of files) {
+      const absolute = path11.resolve(root, file);
+      const relative12 = path11.relative(root, absolute);
+      if (relative12.startsWith("..") || path11.isAbsolute(relative12)) {
+        throw new Error("browser: upload files must stay inside the project root");
+      }
+      const realFile = await fs8.realpath(absolute);
+      const realRelative = path11.relative(realRoot, realFile);
+      if (realRelative.startsWith("..") || path11.isAbsolute(realRelative)) {
+        throw new Error("browser: upload files must not escape the project root through a symlink");
+      }
+      const stat17 = await fs8.stat(realFile);
+      if (!stat17.isFile()) throw new Error(`browser: upload target is not a file: ${file}`);
+      resolved.push(realFile);
+    }
+    await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.locator(selector).setInputFiles(resolved, { timeout: this.operationTimeoutMs })
+    );
+  }
+  async evaluate(id, ownerId, expression, signal) {
+    const session = this.requireOwned(id, ownerId);
+    const result = await this.runPageOperation(
+      session,
+      signal,
+      () => session.page.evaluate(expression)
+    );
+    const serialized = JSON.stringify(result);
+    if (serialized && serialized.length > this.maxSnapshotChars) {
+      throw new Error(`browser: evaluation result exceeds ${this.maxSnapshotChars} characters`);
+    }
+    return result;
+  }
+  async close(id, ownerId) {
+    const session = this.requireOwned(id, ownerId);
+    let trace;
+    try {
+      if (session.tracing) {
+        const target = this.artifacts.pathFor(session.id, "zip");
+        await fs8.mkdir(path11.dirname(target.path), { recursive: true });
+        await session.context.tracing.stop({ path: target.path });
+        trace = await this.artifacts.describe(target.id, "trace", target.path, "application/zip");
+      }
+    } finally {
+      await session.context.close().catch(() => void 0);
+      this.sessions.delete(id);
+      await this.closeBrowserIfIdle();
+    }
+    return trace ? { trace } : {};
+  }
+  async closeOwner(ownerId) {
+    const ids = [...this.sessions.values()].filter((session) => session.ownerId === ownerId).map((session) => session.id);
+    for (const id of ids) await this.close(id, ownerId).catch(() => void 0);
+  }
+  async dispose() {
+    for (const session of [...this.sessions.values()]) {
+      await session.context.close().catch(() => void 0);
+    }
+    this.sessions.clear();
+    const browser = this.browser;
+    this.browser = void 0;
+    this.launching = void 0;
+    await browser?.close().catch(() => void 0);
+    await this.networkProxy.close();
+  }
+  async ensureBrowser(signal) {
+    if (this.browser?.isConnected()) return this.browser;
+    if (!this.launching) {
+      this.launching = this.launcher(this.headless).then((browser) => {
+        this.browser = browser;
+        browser.on("disconnected", () => {
+          if (this.browser === browser) this.browser = void 0;
+          for (const [id, session] of this.sessions) {
+            if (session.context.browser() === browser) this.sessions.delete(id);
+          }
+        });
+        return browser;
+      });
+    }
+    try {
+      return await abortable(
+        signal,
+        () => this.launching,
+        async () => {
+          const browser = await this.launching?.catch(() => void 0);
+          await browser?.close().catch(() => void 0);
+        }
+      );
+    } finally {
+      this.launching = void 0;
+    }
+  }
+  requireOwned(id, ownerId) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`browser: unknown session "${id}"`);
+    if (session.ownerId !== ownerId) throw new Error("browser: session belongs to another agent");
+    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return session;
+  }
+  async summary(session) {
+    return {
+      id: session.id,
+      ownerId: session.ownerId,
+      url: safeBrowserUrl(session.page.url()),
+      title: redactBrowserText(await session.page.title().catch(() => "")),
+      createdAt: session.createdAt,
+      lastUsedAt: session.lastUsedAt,
+      tracing: session.tracing
+    };
+  }
+  attachEvidenceCollectors(session) {
+    session.page.on("console", (message) => {
+      pushBounded(
+        session.console,
+        {
+          level: message.type(),
+          text: redactBrowserText(message.text()).slice(0, 4096),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        this.maxConsoleEntries
+      );
+    });
+    session.page.on("response", (response) => {
+      this.pushNetwork(session, {
+        method: response.request().method(),
+        url: safeBrowserUrl(response.url()),
+        status: response.status(),
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+    session.page.on("requestfailed", (request2) => {
+      this.pushNetwork(session, {
+        method: request2.method(),
+        url: safeBrowserUrl(request2.url()),
+        failed: true,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  }
+  pushNetwork(session, entry) {
+    pushBounded(session.network, entry, this.maxNetworkEntries);
+  }
+  async runPageOperation(session, signal, operation) {
+    signal.throwIfAborted();
+    session.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return abortable(signal, operation, async () => {
+      await session.context.close().catch(() => void 0);
+      this.sessions.delete(session.id);
+      await this.closeBrowserIfIdle();
+    });
+  }
+  async closeBrowserIfIdle() {
+    if (this.sessions.size > 0 || !this.browser) return;
+    const browser = this.browser;
+    this.browser = void 0;
+    await browser.close().catch(() => void 0);
+  }
+};
+async function defaultLauncher(headless) {
+  try {
+    const { chromium } = await import("@playwright/test");
+    return await chromium.launch({ headless });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `browser: Playwright Chromium is unavailable (${detail}). Run "pnpm exec playwright install chromium".`
+    );
+  }
+}
+async function browserInstallationDiagnostics() {
+  try {
+    const { chromium } = await import("@playwright/test");
+    const executablePath = chromium.executablePath();
+    await fs8.access(executablePath);
+    return { available: true, executablePath, message: "Playwright Chromium is available." };
+  } catch {
+    return {
+      available: false,
+      message: 'Playwright Chromium is unavailable. Run "pnpm exec playwright install chromium".'
+    };
+  }
+}
+function pushBounded(target, value, limit) {
+  target.push(value);
+  if (target.length > limit) target.splice(0, target.length - limit);
+}
+async function abortable(signal, operation, onAbort) {
+  signal.throwIfAborted();
+  return new Promise((resolve14, reject) => {
+    let settled = false;
+    let aborting = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", abort);
+      fn();
+    };
+    const abort = () => {
+      aborting = true;
+      void Promise.resolve(onAbort()).finally(() => {
+        finish(() => reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted")));
+      });
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    operation().then(
+      (value) => {
+        if (!aborting) finish(() => resolve14(value));
+      },
+      (err) => {
+        if (!aborting) finish(() => reject(err));
+      }
+    );
+  });
+}
+
+// src/browser/tools.ts
+var managers = /* @__PURE__ */ new Map();
+var cleanupSignalByContext = /* @__PURE__ */ new WeakMap();
+function managerFor(ctx) {
+  const root = path12.resolve(ctx.projectRoot);
+  let manager = managers.get(root);
+  if (!manager) {
+    const wpaths = resolveWstackPaths({ projectRoot: root });
+    manager = new BrowserSessionManager({
+      artifactRoot: path12.join(wpaths.projectDir, "browser-artifacts"),
+      allowedPrivateOrigins: parsePrivateOriginAllowlist(
+        process.env["WRONGSTACK_BROWSER_PRIVATE_ORIGINS"]
+      )
+    });
+    managers.set(root, manager);
+  }
+  const runSignal = ctx.signal;
+  if (cleanupSignalByContext.get(ctx) !== runSignal) {
+    cleanupSignalByContext.set(ctx, runSignal);
+    const managerForRun = manager;
+    const ownerForRun = owner(ctx);
+    ctx.registerAbortHook?.(async () => {
+      if (cleanupSignalByContext.get(ctx) === runSignal) {
+        cleanupSignalByContext.delete(ctx);
+      }
+      await managerForRun.closeOwner(ownerForRun);
+    });
+  }
+  return manager;
+}
+function owner(ctx) {
+  return ctx.agentId || "leader";
+}
+function json(value) {
+  return JSON.stringify(value, null, 2);
+}
+var sessionIdSchema = {
+  type: "string",
+  minLength: 1,
+  description: "Browser session id returned by browser_open."
+};
+var browserOpenTool = {
+  name: "browser_open",
+  description: "Open an isolated first-party Playwright browser session, optionally navigating to a URL.",
+  usageHint: "browser_open({ url?, width?, height?, trace? })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  subjectKey: "url",
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "Optional absolute http(s) URL." },
+      width: { type: "integer", minimum: 320, maximum: 3840 },
+      height: { type: "integer", minimum: 240, maximum: 2160 },
+      trace: { type: "boolean", description: "Capture a Playwright trace; defaults to true." }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const viewport = input.width || input.height ? { width: input.width ?? 1440, height: input.height ?? 900 } : void 0;
+    return json(
+      await managerFor(ctx).open(
+        owner(ctx),
+        { url: input.url, viewport, trace: input.trace },
+        opts.signal
+      )
+    );
+  }
+};
+var browserListTool = {
+  name: "browser_list",
+  description: "List browser sessions owned by the current agent without exposing other agents sessions.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: { type: "object", properties: {} },
+  async execute(_input, ctx) {
+    return json(await managerFor(ctx).list(owner(ctx)));
+  }
+};
+var browserStatusTool = {
+  name: "browser_status",
+  description: "Check whether first-party Playwright Chromium is installed and ready to launch.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.TOOL_META],
+  inputSchema: { type: "object", properties: {} },
+  async execute() {
+    return json(await browserInstallationDiagnostics());
+  }
+};
+var browserNavigateTool = {
+  name: "browser_navigate",
+  description: "Navigate an owned browser session to an approved http(s) URL.",
+  usageHint: "browser_navigate({ sessionId, url })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  subjectKey: "url",
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema, url: { type: "string", minLength: 1 } },
+    required: ["sessionId", "url"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).navigate(input.sessionId, owner(ctx), input.url, opts.signal)
+    );
+  }
+};
+var browserSnapshotTool = {
+  name: "browser_snapshot",
+  description: "Return bounded accessibility state plus redacted console and network summaries.",
+  usageHint: "browser_snapshot({ sessionId })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    return json(await managerFor(ctx).snapshot(input.sessionId, owner(ctx), opts.signal));
+  }
+};
+var browserScreenshotTool = {
+  name: "browser_screenshot",
+  description: "Capture a page or element PNG and return sensitive artifact metadata with integrity hash.",
+  usageHint: "browser_screenshot({ sessionId, fullPage?, selector? })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      fullPage: { type: "boolean" },
+      selector: { type: "string", minLength: 1 }
+    },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).screenshot(
+        input.sessionId,
+        owner(ctx),
+        { fullPage: input.fullPage, selector: input.selector },
+        opts.signal
+      )
+    );
+  }
+};
+function selectorTool(name, description, run) {
+  return {
+    name,
+    description,
+    usageHint: `${name}({ sessionId, selector })`,
+    permission: "confirm",
+    mutating: true,
+    riskTier: "standard",
+    capabilities: [ToolCapabilities.NET_OUTBOUND],
+    inputSchema: {
+      type: "object",
+      properties: { sessionId: sessionIdSchema, selector: { type: "string", minLength: 1 } },
+      required: ["sessionId", "selector"]
+    },
+    async execute(input, ctx, opts) {
+      await run(managerFor(ctx), input, owner(ctx), opts.signal);
+      return "ok";
+    }
+  };
+}
+var browserClickTool = selectorTool(
+  "browser_click",
+  "Click an element in an owned browser session.",
+  (manager, input, ownerId, signal) => manager.click(input.sessionId, ownerId, input.selector, signal)
+);
+var browserHoverTool = selectorTool(
+  "browser_hover",
+  "Hover an element in an owned browser session.",
+  (manager, input, ownerId, signal) => manager.hover(input.sessionId, ownerId, input.selector, signal)
+);
+var browserTypeTool = {
+  name: "browser_type",
+  description: "Fill an input in an owned browser session. Use secretEnv instead of text for credentials so values stay out of tool arguments and session audit.",
+  usageHint: "browser_type({ sessionId, selector, text? | secretEnv? })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      text: { type: "string" },
+      secretEnv: {
+        type: "string",
+        pattern: "^[A-Z_][A-Z0-9_]*$",
+        description: "Host environment variable resolved only at execution time."
+      }
+    },
+    required: ["sessionId", "selector"]
+  },
+  validate(input) {
+    return input.text === void 0 === (input.secretEnv === void 0) ? ["exactly one of text or secretEnv is required"] : [];
+  },
+  async execute(input, ctx, opts) {
+    const value = input.text ?? (input.secretEnv ? process.env[input.secretEnv] : void 0);
+    if (value === void 0) {
+      throw new Error(`browser: secret environment variable "${input.secretEnv ?? ""}" is not set`);
+    }
+    await managerFor(ctx).type(input.sessionId, owner(ctx), input.selector, value, opts.signal);
+    return "ok";
+  }
+};
+var browserSelectTool = {
+  name: "browser_select",
+  description: "Select an option in an owned browser session.",
+  usageHint: "browser_select({ sessionId, selector, value })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      value: { type: "string" }
+    },
+    required: ["sessionId", "selector", "value"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).select(
+      input.sessionId,
+      owner(ctx),
+      input.selector,
+      input.value,
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserPressTool = {
+  name: "browser_press",
+  description: "Press a keyboard key in an owned browser session.",
+  usageHint: "browser_press({ sessionId, key })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema, key: { type: "string", minLength: 1 } },
+    required: ["sessionId", "key"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).press(input.sessionId, owner(ctx), input.key, opts.signal);
+    return "ok";
+  }
+};
+var browserDragTool = {
+  name: "browser_drag",
+  description: "Drag one element to another in an owned browser session.",
+  usageHint: "browser_drag({ sessionId, from, to })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "standard",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      from: { type: "string", minLength: 1 },
+      to: { type: "string", minLength: 1 }
+    },
+    required: ["sessionId", "from", "to"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).drag(input.sessionId, owner(ctx), input.from, input.to, opts.signal);
+    return "ok";
+  }
+};
+var browserWaitTool = {
+  name: "browser_wait",
+  description: "Wait for an element or a bounded duration in an owned browser session.",
+  usageHint: "browser_wait({ sessionId, selector?, timeoutMs? })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      timeoutMs: { type: "integer", minimum: 0, maximum: 3e4 }
+    },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).wait(
+      input.sessionId,
+      owner(ctx),
+      { selector: input.selector, timeoutMs: input.timeoutMs },
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserEvaluateTool = {
+  name: "browser_evaluate",
+  description: "Evaluate bounded JavaScript in the page. Requires confirmation because page code is arbitrary.",
+  usageHint: "browser_evaluate({ sessionId, expression })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "destructive",
+  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.TOOL_MUTATE_ANY],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      expression: { type: "string", minLength: 1, maxLength: 16384 }
+    },
+    required: ["sessionId", "expression"]
+  },
+  async execute(input, ctx, opts) {
+    return json(
+      await managerFor(ctx).evaluate(input.sessionId, owner(ctx), input.expression, opts.signal)
+    );
+  }
+};
+var browserUploadTool = {
+  name: "browser_upload",
+  description: "Upload project-local files through a file input in an owned browser session.",
+  usageHint: "browser_upload({ sessionId, selector, files })",
+  permission: "confirm",
+  mutating: true,
+  riskTier: "destructive",
+  capabilities: [ToolCapabilities.NET_OUTBOUND, ToolCapabilities.FS_READ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      sessionId: sessionIdSchema,
+      selector: { type: "string", minLength: 1 },
+      files: { type: "array", minItems: 1, maxItems: 20, items: { type: "string", minLength: 1 } }
+    },
+    required: ["sessionId", "selector", "files"]
+  },
+  async execute(input, ctx, opts) {
+    await managerFor(ctx).upload(
+      input.sessionId,
+      owner(ctx),
+      input.selector,
+      input.files,
+      ctx.projectRoot,
+      opts.signal
+    );
+    return "ok";
+  }
+};
+var browserCloseTool = {
+  name: "browser_close",
+  description: "Close an owned browser session, reclaim its context, and return sensitive trace metadata.",
+  usageHint: "browser_close({ sessionId })",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: [ToolCapabilities.NET_OUTBOUND],
+  inputSchema: {
+    type: "object",
+    properties: { sessionId: sessionIdSchema },
+    required: ["sessionId"]
+  },
+  async execute(input, ctx) {
+    return json(await managerFor(ctx).close(input.sessionId, owner(ctx)));
+  }
+};
+var browserTools = [
+  browserOpenTool,
+  browserStatusTool,
+  browserListTool,
+  browserNavigateTool,
+  browserSnapshotTool,
+  browserScreenshotTool,
+  browserClickTool,
+  browserTypeTool,
+  browserSelectTool,
+  browserPressTool,
+  browserHoverTool,
+  browserDragTool,
+  browserWaitTool,
+  browserEvaluateTool,
+  browserUploadTool,
+  browserCloseTool
+];
+for (const tool of browserTools) tool.icon = "web";
+for (const tool of browserTools) tool.timeoutMs ??= 6e4;
+
 // src/codebase-index/writer.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core";
 
@@ -6245,9 +7477,9 @@ var indexCircuitBreaker = new IndexCircuitBreaker();
 // src/codebase-index/writer.ts
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 import { createRequire } from "node:module";
-import * as fs7 from "node:fs";
-import * as path10 from "node:path";
-import { resolveWstackPaths } from "@wrongstack/core";
+import * as fs9 from "node:fs";
+import * as path13 from "node:path";
+import { resolveWstackPaths as resolveWstackPaths2 } from "@wrongstack/core";
 
 // src/codebase-index/schema.ts
 var SCHEMA_VERSION = 2;
@@ -6376,7 +7608,7 @@ var Bm25Index = class {
 // src/codebase-index/writer.ts
 var DB_FILE = "index.db";
 function resolveIndexDir(projectRoot, override) {
-  return override ?? resolveWstackPaths({ projectRoot }).projectCodebaseIndex;
+  return override ?? resolveWstackPaths2({ projectRoot }).projectCodebaseIndex;
 }
 function codebaseIndexDirOverride(ctx) {
   const v = ctx.meta?.["codebaseIndexDir"];
@@ -6491,9 +7723,9 @@ var IndexStore = class {
   }
   constructor(projectRoot, opts = {}) {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
-    fs7.mkdirSync(this.indexDir, { recursive: true });
+    fs9.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
-    this.db = new Database(path10.join(this.indexDir, DB_FILE));
+    this.db = new Database(path13.join(this.indexDir, DB_FILE));
     try {
       this.db.exec("PRAGMA journal_mode = WAL");
       this.db.exec("PRAGMA busy_timeout = 5000");
@@ -7072,9 +8304,9 @@ var IndexStore = class {
     }));
   }
   sizeBytes() {
-    const dbPath = path10.join(this.indexDir, DB_FILE);
+    const dbPath = path13.join(this.indexDir, DB_FILE);
     try {
-      return fs7.statSync(dbPath).size;
+      return fs9.statSync(dbPath).size;
     } catch {
       return 0;
     }
@@ -7089,14 +8321,14 @@ var IndexStore = class {
 };
 
 // src/codebase-index/background-indexer.ts
-import * as fs13 from "node:fs";
+import * as fs15 from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
 
 // src/codebase-index/indexer.ts
 import { expectDefined as expectDefined6 } from "@wrongstack/core";
-import * as fs12 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as fs14 from "node:fs/promises";
+import * as path19 from "node:path";
 import { compileGlob as compileGlob2 } from "@wrongstack/core";
 
 // src/codebase-index/ts-parser.ts
@@ -7289,8 +8521,8 @@ function detectLang(file) {
 // src/codebase-index/go-parser.ts
 import { spawn as spawn4 } from "node:child_process";
 import * as os5 from "node:os";
-import * as path11 from "node:path";
-import * as fs8 from "node:fs/promises";
+import * as path14 from "node:path";
+import * as fs10 from "node:fs/promises";
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
@@ -7591,10 +8823,10 @@ func formatType(t ast.Expr) string {
 }
 `;
 async function syncGoParse(filePath, content, lang) {
-  const tmpDir = await fs8.mkdtemp(path11.join(os5.tmpdir(), "ws-go-parse-"));
+  const tmpDir = await fs10.mkdtemp(path14.join(os5.tmpdir(), "ws-go-parse-"));
   try {
-    const scriptPath = path11.join(tmpDir, "parse.go");
-    await fs8.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const scriptPath = path14.join(tmpDir, "parse.go");
+    await fs10.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
     const proc = spawn4("go", ["run", scriptPath], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
@@ -7606,8 +8838,8 @@ async function syncGoParse(filePath, content, lang) {
     proc.stdin?.write(content);
     proc.stdin?.end();
     const { code } = await Promise.race([
-      new Promise((resolve11) => {
-        proc.on("close", (c) => resolve11({ code: c }));
+      new Promise((resolve14) => {
+        proc.on("close", (c) => resolve14({ code: c }));
       }),
       new Promise(
         (_, reject) => setTimeout(() => {
@@ -7637,15 +8869,15 @@ async function syncGoParse(filePath, content, lang) {
   } catch {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   } finally {
-    await fs8.rm(tmpDir, { recursive: true, force: true });
+    await fs10.rm(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/codebase-index/py-parser.ts
 import { spawn as spawn5 } from "node:child_process";
-import * as fs9 from "node:fs/promises";
+import * as fs11 from "node:fs/promises";
 import * as os6 from "node:os";
-import * as path12 from "node:path";
+import * as path15 from "node:path";
 async function parseSymbols3(opts) {
   const { file, content, lang } = opts;
   try {
@@ -7861,10 +9093,10 @@ var _cachedScriptPath = null;
 async function syncPyParse(filePath, content, lang) {
   try {
     if (!_cachedScriptPath) {
-      const tmpDir = path12.join(os6.tmpdir(), "ws-py-parse");
-      await fs9.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path12.join(tmpDir, "parse.py");
-      await fs9.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+      const tmpDir = path15.join(os6.tmpdir(), "ws-py-parse");
+      await fs11.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path15.join(tmpDir, "parse.py");
+      await fs11.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
     }
     const proc = spawn5("python", [_cachedScriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -7877,8 +9109,8 @@ async function syncPyParse(filePath, content, lang) {
       stdout += chunk.toString();
     });
     const { code } = await Promise.race([
-      new Promise((resolve11) => {
-        proc.on("close", (c) => resolve11({ code: c }));
+      new Promise((resolve14) => {
+        proc.on("close", (c) => resolve14({ code: c }));
       }),
       new Promise(
         (_, reject) => setTimeout(() => {
@@ -7913,8 +9145,8 @@ async function syncPyParse(filePath, content, lang) {
 // src/codebase-index/rs-parser.ts
 import { expectDefined as expectDefined3 } from "@wrongstack/core";
 import { execFileSync, spawn as spawn6 } from "node:child_process";
-import * as fs10 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as fs12 from "node:fs/promises";
+import * as path16 from "node:path";
 async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   const nativeAvailable = checkNativeParser();
@@ -7927,7 +9159,7 @@ async function parseSymbols4(opts) {
 function checkNativeParser() {
   try {
     execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
-    const toolsDir = path13.join(process.cwd(), "tools");
+    const toolsDir = path16.join(process.cwd(), "tools");
     try {
       execFileSync(
         "cargo",
@@ -7937,7 +9169,7 @@ function checkNativeParser() {
           "--format-version",
           "1",
           "--manifest-path",
-          path13.join(toolsDir, "Cargo.toml")
+          path16.join(toolsDir, "Cargo.toml")
         ],
         { stdio: "pipe", windowsHide: true }
       );
@@ -7951,13 +9183,13 @@ function checkNativeParser() {
 }
 async function tryNativeParse(file, content) {
   try {
-    const toolsDir = path13.join(process.cwd(), "tools");
-    const crateDir = path13.join(toolsDir, "syn-parser");
-    const tmpFile = path13.join(crateDir, "src", "input.rs");
-    await fs10.writeFile(tmpFile, content, "utf8");
+    const toolsDir = path16.join(process.cwd(), "tools");
+    const crateDir = path16.join(toolsDir, "syn-parser");
+    const tmpFile = path16.join(crateDir, "src", "input.rs");
+    await fs12.writeFile(tmpFile, content, "utf8");
     const proc = spawn6(
       "cargo",
-      ["run", "--manifest-path", path13.join(toolsDir, "Cargo.toml")],
+      ["run", "--manifest-path", path16.join(toolsDir, "Cargo.toml")],
       {
         cwd: process.cwd(),
         stdio: ["pipe", "pipe", "pipe"],
@@ -7969,8 +9201,8 @@ async function tryNativeParse(file, content) {
       stdout += chunk.toString();
     });
     const { code } = await Promise.race([
-      new Promise((resolve11) => {
-        proc.on("close", (c) => resolve11({ code: c }));
+      new Promise((resolve14) => {
+        proc.on("close", (c) => resolve14({ code: c }));
       }),
       new Promise(
         (_, reject) => setTimeout(() => {
@@ -8061,7 +9293,7 @@ function regexParse(opts) {
 
 // src/codebase-index/json-parser.ts
 import { expectDefined as expectDefined4 } from "@wrongstack/core";
-import * as path14 from "node:path";
+import * as path17 from "node:path";
 function parseSymbols5(opts) {
   const { file, content, lang } = opts;
   try {
@@ -8073,9 +9305,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename7 = path14.basename(file).toLowerCase();
-  const isPackageJson = basename7 === "package.json";
-  const isTsconfig = basename7 === "tsconfig.json" || basename7 === "tsconfig.build.json";
+  const basename8 = path17.basename(file).toLowerCase();
+  const isPackageJson = basename8 === "package.json";
+  const isTsconfig = basename8 === "tsconfig.json" || basename8 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -8099,11 +9331,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path14.basename(file),
+        name: path17.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path14.basename(file)}" = { ... }`,
+        signature: `"${path17.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -8414,8 +9646,8 @@ function makeSymbol2(opts) {
 }
 
 // src/codebase-index/gitignore.ts
-import * as fs11 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as fs13 from "node:fs/promises";
+import * as path18 from "node:path";
 import { compileGlob } from "@wrongstack/core";
 function globBody(glob) {
   return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
@@ -8461,7 +9693,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs11.readFile(path15.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs13.readFile(path18.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -8472,7 +9704,7 @@ async function loadGitignoreMatcher(projectRoot) {
 var YIELD_EVERY_N = 50;
 var PARALLEL_BATCH = 20;
 function yieldEventLoop() {
-  return new Promise((resolve11) => setImmediate(resolve11));
+  return new Promise((resolve14) => setImmediate(resolve14));
 }
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
@@ -8519,21 +9751,21 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs12.readdir(dir, { withFileTypes: true });
+      entries = await fs14.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path16.join(dir, e.name);
-      const rel = path16.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path19.join(dir, e.name);
+      const rel = path19.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
         if (isGitIgnored(rel, false)) continue;
-        const ext = path16.extname(e.name);
+        const ext = path19.extname(e.name);
         for (const { ext: extName, pat } of globs) {
           if (ext === extName && (pat.test(rel) || pat.test(e.name))) {
             results.push(full);
@@ -8589,7 +9821,7 @@ async function runIndexerWithStore(store, opts) {
   let files;
   let discoveredFiles = null;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path16.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path16.relative(projectRoot, f).replace(/\\/g, "/"), false));
+    files = opts.files.map((f) => path19.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path19.relative(projectRoot, f).replace(/\\/g, "/"), false));
   } else {
     files = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
     discoveredFiles = new Set(files);
@@ -8617,34 +9849,34 @@ async function runIndexerWithStore(store, opts) {
     const statOpts = signal ? { signal } : {};
     const statReadParse = await Promise.allSettled(
       batchFiles.map(async (file) => {
-        let stat15;
+        let stat17;
         try {
-          stat15 = await fs12.stat(file, statOpts);
+          stat17 = await fs14.stat(file, statOpts);
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: null, lang: "", parsed: null, error: `stat error: ${e instanceof Error ? e.message : String(e)}` };
         }
-        if (!stat15.isFile()) return { file, stat: stat15, lang: "", parsed: null };
+        if (!stat17.isFile()) return { file, stat: stat17, lang: "", parsed: null };
         const lang = detectLang(file);
-        if (!lang) return { file, stat: stat15, lang: "", parsed: null };
+        if (!lang) return { file, stat: stat17, lang: "", parsed: null };
         const meta = existingMeta.get(file);
-        if (!force && meta && meta.mtimeMs === Math.floor(stat15.mtimeMs)) {
-          return { file, stat: stat15, lang, parsed: null, skippedMeta: meta };
+        if (!force && meta && meta.mtimeMs === Math.floor(stat17.mtimeMs)) {
+          return { file, stat: stat17, lang, parsed: null, skippedMeta: meta };
         }
         let content;
         try {
-          content = await fs12.readFile(file, { encoding: "utf8", signal });
+          content = await fs14.readFile(file, { encoding: "utf8", signal });
         } catch (e) {
           if (isAbortError(e)) throw e;
-          return { file, stat: stat15, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
+          return { file, stat: stat17, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
         }
         let parsed;
         try {
           parsed = await parseFile(file, content, lang);
         } catch (e) {
-          return { file, stat: stat15, lang, parsed: null, error: `parse error: ${e instanceof Error ? e.message : String(e)}` };
+          return { file, stat: stat17, lang, parsed: null, error: `parse error: ${e instanceof Error ? e.message : String(e)}` };
         }
-        return { file, stat: stat15, lang, parsed, content };
+        return { file, stat: stat17, lang, parsed, content };
       })
     );
     const batchEntries = [];
@@ -8664,7 +9896,7 @@ async function runIndexerWithStore(store, opts) {
         if (result.error.includes("error:")) errors.push(result.error);
         continue;
       }
-      const { stat: stat15, lang, parsed } = result;
+      const { stat: stat17, lang, parsed } = result;
       if (result.skippedMeta) {
         langStats[lang] = (langStats[lang] ?? 0) + result.skippedMeta.symbolCount;
         symbolsIndexed += result.skippedMeta.symbolCount;
@@ -8676,7 +9908,7 @@ async function runIndexerWithStore(store, opts) {
           store.upsertFile({
             file,
             lang,
-            mtimeMs: Math.floor(stat15.mtimeMs),
+            mtimeMs: Math.floor(stat17.mtimeMs),
             symbolCount: 0,
             lastIndexed: Date.now()
           });
@@ -8688,7 +9920,7 @@ async function runIndexerWithStore(store, opts) {
         store.upsertFile({
           file,
           lang,
-          mtimeMs: Math.floor(stat15.mtimeMs),
+          mtimeMs: Math.floor(stat17.mtimeMs),
           symbolCount: 0,
           lastIndexed: Date.now()
         });
@@ -8704,7 +9936,7 @@ async function runIndexerWithStore(store, opts) {
         lang,
         symbols: parsed.symbols,
         refs,
-        mtimeMs: Math.floor(stat15.mtimeMs),
+        mtimeMs: Math.floor(stat17.mtimeMs),
         symbolCount: parsed.symbols.length
       });
       deleteForFiles.push(file);
@@ -8892,7 +10124,7 @@ function resolveWorkerUrl() {
   for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs13.existsSync(fileURLToPath(url))) return url;
+      if (url.protocol === "file:" && fs15.existsSync(fileURLToPath(url))) return url;
     } catch {
     }
   }
@@ -8950,7 +10182,7 @@ function terminateWorker(reason) {
 function callIndexOp(op, args, opts) {
   const w = ensureWorker();
   if (!w) return callInline(op, args, opts);
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve14, reject) => {
     const id = nextRpcId++;
     const timer = setTimeout(() => {
       pending.delete(id);
@@ -8973,7 +10205,7 @@ function callIndexOp(op, args, opts) {
     pending.set(id, {
       resolve: (v) => {
         cleanup();
-        resolve11(v);
+        resolve14(v);
       },
       reject: (e) => {
         cleanup();
@@ -9312,8 +10544,8 @@ var codebaseStatsTool = {
 };
 
 // src/design.ts
-import * as fs14 from "node:fs/promises";
-import * as path17 from "node:path";
+import * as fs16 from "node:fs/promises";
+import * as path20 from "node:path";
 import {
   applyTokenOverrides,
   getDesignKitLoader,
@@ -9327,17 +10559,17 @@ import {
   setDesignOverrides
 } from "@wrongstack/core";
 async function resolveReal(p) {
-  const resolved = path17.resolve(p);
+  const resolved = path20.resolve(p);
   let probe = resolved;
   const missing = [];
   for (; ; ) {
     try {
-      return path17.resolve(await fs14.realpath(probe), ...missing);
+      return path20.resolve(await fs16.realpath(probe), ...missing);
     } catch (err) {
       if (err.code === "ENOENT") {
-        const parent = path17.dirname(probe);
+        const parent = path20.dirname(probe);
         if (parent === probe) return resolved;
-        missing.unshift(path17.basename(probe));
+        missing.unshift(path20.basename(probe));
         probe = parent;
         continue;
       }
@@ -9503,18 +10735,18 @@ These win over kit tokens. Run \`design {action:"materialize"}\` to write them t
         outPath: input.out
       });
       const root = await resolveReal(ctx.projectRoot);
-      const absResolved = path17.isAbsolute(result.path) ? path17.resolve(result.path) : path17.resolve(path17.join(ctx.projectRoot, result.path));
-      const absParent = await resolveReal(path17.dirname(absResolved));
-      const abs = path17.join(absParent, path17.basename(absResolved));
-      const rel = path17.relative(root, abs);
-      if (rel.startsWith("..") || path17.isAbsolute(rel)) {
+      const absResolved = path20.isAbsolute(result.path) ? path20.resolve(result.path) : path20.resolve(path20.join(ctx.projectRoot, result.path));
+      const absParent = await resolveReal(path20.dirname(absResolved));
+      const abs = path20.join(absParent, path20.basename(absResolved));
+      const rel = path20.relative(root, abs);
+      if (rel.startsWith("..") || path20.isAbsolute(rel)) {
         throw new Error(
           `design: materialize path "${result.path}" would escape the project root`
         );
       }
       let exists = false;
       try {
-        await fs14.access(abs);
+        await fs16.access(abs);
         exists = true;
       } catch {
       }
@@ -9531,8 +10763,8 @@ ${result.content}
 \`\`\``
         };
       }
-      await fs14.mkdir(path17.dirname(abs), { recursive: true });
-      await fs14.writeFile(abs, result.content);
+      await fs16.mkdir(path20.dirname(abs), { recursive: true });
+      await fs16.writeFile(abs, result.content);
       return {
         action,
         kit: active.kit,
@@ -9582,8 +10814,8 @@ Replace off-palette colors with kit tokens (or the materialized CSS vars / token
 init_util();
 import { spawn as spawn7 } from "node:child_process";
 import { statSync as statSync2 } from "node:fs";
-import * as fs15 from "node:fs/promises";
-import * as path18 from "node:path";
+import * as fs17 from "node:fs/promises";
+import * as path21 from "node:path";
 import { buildChildEnv as buildChildEnv3 } from "@wrongstack/core";
 var diffTool = {
   name: "diff",
@@ -9667,18 +10899,18 @@ function findGitDir(cwd) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat15 = statSync2(path18.join(dir, ".git"));
-      if (stat15.isDirectory()) return dir;
+      const stat17 = statSync2(path21.join(dir, ".git"));
+      if (stat17.isDirectory()) return dir;
     } catch {
     }
-    const parent = path18.dirname(dir);
+    const parent = path21.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     const child = spawn7("git", args, {
@@ -9694,8 +10926,8 @@ function runGit(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve11({ stdout, stderr, exitCode: code ?? 0 }));
-    child.on("error", (e) => resolve11({ stdout: "", stderr: e.message, exitCode: 1 }));
+    child.on("close", (code) => resolve14({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve14({ stdout: "", stderr: e.message, exitCode: 1 }));
   });
 }
 async function fileDiff(input, ctx, _signal) {
@@ -9712,9 +10944,9 @@ async function fileDiff(input, ctx, _signal) {
   const results = [];
   for (const file of files) {
     const absPath = safeResolve(file, ctx);
-    const stat15 = await fs15.stat(absPath).catch(() => null);
-    if (!stat15?.isFile()) continue;
-    const content = await fs15.readFile(absPath, "utf8");
+    const stat17 = await fs17.stat(absPath).catch(() => null);
+    if (!stat17?.isFile()) continue;
+    const content = await fs17.readFile(absPath, "utf8");
     const lines = content.split(/\r?\n/);
     results.push(formatWithLineNumbers(file, lines));
   }
@@ -9734,7 +10966,7 @@ ${numbered}`;
 
 // src/document.ts
 init_util();
-import * as fs16 from "node:fs/promises";
+import * as fs18 from "node:fs/promises";
 var documentTool = {
   name: "document",
   category: "Project",
@@ -9778,7 +11010,7 @@ var documentTool = {
     const fileList = input.files ? await resolveFiles(Array.isArray(input.files) ? input.files.join(",") : input.files, cwd) : input.path ? [safeResolve(input.path, ctx)] : [];
     for (const absPath of fileList) {
       try {
-        const content = await fs16.readFile(absPath, "utf8");
+        const content = await fs18.readFile(absPath, "utf8");
         filesProcessed++;
         const processed = processFile(
           content,
@@ -9814,8 +11046,8 @@ async function resolveFiles(filesInput, cwd) {
   for (const f of files) {
     const absPath = f.trim().startsWith("/") ? f.trim() : `${cwd}/${f.trim()}`;
     try {
-      const stat15 = await fs16.stat(absPath);
-      if (stat15.isFile()) resolved.push(absPath);
+      const stat17 = await fs18.stat(absPath);
+      if (stat17.isFile()) resolved.push(absPath);
     } catch {
     }
   }
@@ -9882,10 +11114,426 @@ function processFile(content, absPath, _style, _overwrite, target) {
   return results;
 }
 
+// src/e2e.ts
+init_util();
+import { open, readdir as readdir5 } from "node:fs/promises";
+import * as path22 from "node:path";
+async function readBoundedText(filePath, maxBytes) {
+  let handle;
+  try {
+    handle = await open(filePath, "r");
+    const info = await handle.stat();
+    if (!info.isFile() || info.size > maxBytes) return void 0;
+    const buffer = Buffer.alloc(info.size);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return void 0;
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+var CONFIG_NAMES = /* @__PURE__ */ new Map([
+  ["playwright.config.ts", "playwright"],
+  ["playwright.config.js", "playwright"],
+  ["playwright.config.mts", "playwright"],
+  ["playwright.config.mjs", "playwright"],
+  ["playwright.config.cts", "playwright"],
+  ["playwright.config.cjs", "playwright"],
+  ["cypress.config.ts", "cypress"],
+  ["cypress.config.js", "cypress"],
+  ["cypress.config.mts", "cypress"],
+  ["cypress.config.mjs", "cypress"],
+  ["cypress.config.cts", "cypress"],
+  ["cypress.config.cjs", "cypress"],
+  ["cypress.json", "cypress"]
+]);
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".wrongstack",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "coverage-html",
+  "playwright-report",
+  "test-results",
+  ".next"
+]);
+var MAX_SCAN_DIRECTORIES = 4e3;
+var MAX_PACKAGE_BYTES = 512 * 1024;
+var MAX_CONFIG_BYTES = 512 * 1024;
+var MAX_SPEC_SAMPLES = 20;
+function relativePath(root, target) {
+  const value = path22.relative(root, target) || ".";
+  return value.split(path22.sep).join("/");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function staticString(source, property) {
+  const key = escapeRegExp(property);
+  const direct = source.match(
+    new RegExp(`(?:['"]?${key}['"]?)\\s*:\\s*(['"\\x60])([^'"\\x60\\r\\n]*)\\1`)
+  );
+  if (direct?.[2] && !direct[2].includes("${")) return direct[2];
+  const sameLineFallback = source.match(
+    new RegExp(`(?:['"]?${key}['"]?)\\s*:[^\\r\\n]{0,300}?(['"\\x60])([^'"\\x60\\r\\n]*)\\1`)
+  );
+  return sameLineFallback?.[2] && !sameLineFallback[2].includes("${") ? sameLineFallback[2] : void 0;
+}
+function staticNumber(source, property) {
+  const key = escapeRegExp(property);
+  const match = source.match(new RegExp(`(?:['"]?${key}['"]?)\\s*:\\s*(\\d{2,5})\\b`));
+  return match?.[1] ? Number.parseInt(match[1], 10) : void 0;
+}
+function serverHints(framework, source) {
+  if (framework === "playwright" && /\bwebServer\s*:/.test(source)) {
+    const command = staticString(source, "command");
+    const url = staticString(source, "url");
+    const port = staticNumber(source, "port");
+    return [
+      {
+        kind: "managed",
+        ...command ? { command } : {},
+        ...url ? { url } : {},
+        ...port ? { port } : {},
+        source: "static-config",
+        incomplete: !command || !url && !port
+      }
+    ];
+  }
+  const baseUrl = staticString(source, "baseURL") ?? staticString(source, "baseUrl");
+  return baseUrl ? [{ kind: "attach", url: baseUrl, source: "static-config", incomplete: false }] : [];
+}
+function configuredSpecPattern(framework, source) {
+  if (framework === "playwright") {
+    const testDir = staticString(source, "testDir") ?? "./tests";
+    return `${testDir.replace(/\/$/, "")}/**/*.{spec,test}.{js,jsx,ts,tsx,mjs,cjs}`;
+  }
+  return staticString(source, "specPattern") ?? "cypress/{e2e,integration}/**/*.cy.{js,jsx,ts,tsx,mjs,cjs}";
+}
+async function scanWorkspace(root, maxDepth, signal) {
+  const result = {
+    configs: [],
+    packageFiles: [],
+    scannedDirectories: 0,
+    truncated: false
+  };
+  const queue = [{ directory: root, depth: 0 }];
+  while (queue.length > 0) {
+    signal.throwIfAborted();
+    const current = queue.shift();
+    if (!current) break;
+    result.scannedDirectories += 1;
+    if (result.scannedDirectories > MAX_SCAN_DIRECTORIES) {
+      result.truncated = true;
+      break;
+    }
+    let entries;
+    try {
+      entries = await readdir5(current.directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      signal.throwIfAborted();
+      const absolutePath = path22.join(current.directory, entry.name);
+      if (entry.isFile()) {
+        if (entry.name === "package.json") result.packageFiles.push(absolutePath);
+        const framework = CONFIG_NAMES.get(entry.name);
+        if (framework) result.configs.push({ framework, absolutePath });
+      } else if (entry.isDirectory() && current.depth < maxDepth && !SKIP_DIRECTORIES.has(entry.name) && !entry.name.startsWith("coverage-") && !entry.name.startsWith("cov-")) {
+        queue.push({ directory: absolutePath, depth: current.depth + 1 });
+      }
+    }
+  }
+  return result;
+}
+async function readPackageInfo(packagePath) {
+  try {
+    const raw = await readBoundedText(packagePath, MAX_PACKAGE_BYTES);
+    if (raw === void 0) return void 0;
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts && typeof parsed.scripts === "object" ? Object.fromEntries(
+      Object.entries(parsed.scripts).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : {};
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      const value = parsed[field];
+      if (!value || typeof value !== "object") continue;
+      for (const name of Object.keys(value)) dependencies.add(name);
+    }
+    const declared = typeof parsed.packageManager === "string" ? parsed.packageManager.split("@")[0] ?? "" : "";
+    const packageManager = ["pnpm", "npm", "yarn", "bun"].includes(declared) ? declared : void 0;
+    return { path: packagePath, scripts, dependencies, packageManager };
+  } catch {
+    return void 0;
+  }
+}
+function frameworkFromPackage(info) {
+  const found = /* @__PURE__ */ new Set();
+  if (info.dependencies.has("@playwright/test") || info.dependencies.has("playwright")) {
+    found.add("playwright");
+  }
+  if (info.dependencies.has("cypress")) found.add("cypress");
+  for (const command of Object.values(info.scripts)) {
+    if (/\bplaywright(?:\.cmd)?\b/i.test(command)) found.add("playwright");
+    if (/\bcypress(?:\.cmd)?\b/i.test(command)) found.add("cypress");
+  }
+  return [...found];
+}
+async function detectPackageManager3(projectRoot, scanRoot, declared) {
+  if (declared) return declared;
+  let directory = projectRoot;
+  while (true) {
+    const names = /* @__PURE__ */ new Set();
+    try {
+      for (const entry of await readdir5(directory)) names.add(entry);
+    } catch {
+    }
+    if (names.has("pnpm-lock.yaml")) return "pnpm";
+    if (names.has("yarn.lock")) return "yarn";
+    if (names.has("bun.lock") || names.has("bun.lockb")) return "bun";
+    if (names.has("package-lock.json") || names.has("npm-shrinkwrap.json")) return "npm";
+    if (directory === scanRoot) break;
+    const parent = path22.dirname(directory);
+    const relativeParent = path22.relative(scanRoot, parent);
+    if (parent === directory || relativeParent.startsWith("..") || path22.isAbsolute(relativeParent)) {
+      break;
+    }
+    directory = parent;
+  }
+  return "npm";
+}
+function matchingScripts(info, framework) {
+  if (!info) return [];
+  const matcher = framework === "playwright" ? /\bplaywright(?:\.cmd)?\b/i : /\bcypress(?:\.cmd)?\b/i;
+  return Object.entries(info.scripts).filter(([, command]) => matcher.test(command)).map(([name]) => name).sort((a, b) => {
+    const preferred = ["test:e2e", "e2e", "e2e:test"];
+    const ai = preferred.indexOf(a);
+    const bi = preferred.indexOf(b);
+    if (ai !== -1 || bi !== -1) return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+    return a.localeCompare(b);
+  });
+}
+function executionPlan(framework, manager, root, configPath, scripts) {
+  const script = scripts[0];
+  if (script) {
+    return {
+      command: manager,
+      args: ["run", script],
+      cwd: root,
+      source: "package-script",
+      script
+    };
+  }
+  const runnerArgs = framework === "playwright" ? ["playwright", "test"] : ["cypress", "run"];
+  if (configPath) {
+    runnerArgs.push(framework === "playwright" ? "--config" : "--config-file", configPath);
+  }
+  return {
+    command: manager === "bun" ? "bunx" : manager,
+    args: manager === "bun" ? runnerArgs : manager === "npm" ? ["exec", "--", ...runnerArgs] : ["exec", ...runnerArgs],
+    cwd: root,
+    source: "framework-default"
+  };
+}
+function isSpec(framework, filename) {
+  if (framework === "cypress") return /\.cy\.(?:[cm]?[jt]sx?)$/i.test(filename);
+  return /\.(?:spec|test)\.(?:[cm]?[jt]sx?)$/i.test(filename);
+}
+async function collectSpecs(root, framework, testDirectory, signal) {
+  const roots = testDirectory ? [path22.resolve(root, testDirectory)] : framework === "cypress" ? [path22.join(root, "cypress", "e2e"), path22.join(root, "cypress", "integration")] : [path22.join(root, "tests")];
+  const samples = [];
+  let count = 0;
+  let scanned = 0;
+  const queue = [...roots];
+  while (queue.length > 0) {
+    signal.throwIfAborted();
+    const directory = queue.shift();
+    if (!directory) break;
+    scanned += 1;
+    if (scanned > MAX_SCAN_DIRECTORIES) return { count, samples, truncated: true };
+    let entries;
+    try {
+      entries = await readdir5(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      signal.throwIfAborted();
+      const target = path22.join(directory, entry.name);
+      if (entry.isDirectory() && !SKIP_DIRECTORIES.has(entry.name)) queue.push(target);
+      else if (entry.isFile() && isSpec(framework, entry.name)) {
+        count += 1;
+        if (samples.length < MAX_SPEC_SAMPLES) samples.push(relativePath(root, target));
+      }
+    }
+  }
+  return { count, samples, truncated: count > samples.length };
+}
+async function readConfig(configPath) {
+  if (!configPath) return "";
+  return await readBoundedText(configPath, MAX_CONFIG_BYTES) ?? "";
+}
+function nearestPackage(projectRoot, packagesByDirectory, scanRoot) {
+  let directory = projectRoot;
+  while (true) {
+    const found = packagesByDirectory.get(directory);
+    if (found) return found;
+    if (directory === scanRoot) return void 0;
+    const parent = path22.dirname(directory);
+    if (parent === directory || relativePath(scanRoot, parent).startsWith("..")) return void 0;
+    directory = parent;
+  }
+}
+async function discoverE2EProjects(root, options) {
+  const maxDepth = Math.max(0, Math.min(options.maxDepth ?? 5, 8));
+  const scan = await scanWorkspace(root, maxDepth, options.signal);
+  const packages = (await Promise.all(scan.packageFiles.map(readPackageInfo))).filter(
+    (info) => Boolean(info)
+  );
+  const packagesByDirectory = new Map(packages.map((info) => [path22.dirname(info.path), info]));
+  const candidates = /* @__PURE__ */ new Map();
+  for (const config of scan.configs) {
+    if (options.framework && options.framework !== "all" && config.framework !== options.framework) {
+      continue;
+    }
+    const projectRoot = path22.dirname(config.absolutePath);
+    candidates.set(`${config.framework}:${projectRoot}`, {
+      framework: config.framework,
+      root: projectRoot,
+      configPath: config.absolutePath
+    });
+  }
+  for (const info of packages) {
+    const projectRoot = path22.dirname(info.path);
+    for (const framework of frameworkFromPackage(info)) {
+      if (options.framework && options.framework !== "all" && framework !== options.framework)
+        continue;
+      const key = `${framework}:${projectRoot}`;
+      if (!candidates.has(key)) candidates.set(key, { framework, root: projectRoot });
+    }
+  }
+  const projects = [];
+  for (const candidate of candidates.values()) {
+    options.signal.throwIfAborted();
+    const info = nearestPackage(candidate.root, packagesByDirectory, root);
+    const source = await readConfig(candidate.configPath);
+    const scripts = matchingScripts(info, candidate.framework);
+    const manager = await detectPackageManager3(candidate.root, root, info?.packageManager);
+    const testDirectory = candidate.framework === "playwright" ? staticString(source, "testDir") : void 0;
+    const resolvedTestDirectory = testDirectory ? path22.resolve(candidate.root, testDirectory) : void 0;
+    const relativeTestDirectory = resolvedTestDirectory ? path22.relative(root, resolvedTestDirectory) : void 0;
+    const unsafeTestDirectory = Boolean(
+      relativeTestDirectory && (relativeTestDirectory.startsWith("..") || path22.isAbsolute(relativeTestDirectory))
+    );
+    const specs = options.includeSpecs === false || unsafeTestDirectory ? { count: 0, samples: [], truncated: false } : await collectSpecs(candidate.root, candidate.framework, testDirectory, options.signal);
+    const warnings = [];
+    if (!candidate.configPath)
+      warnings.push("Framework dependency or script found without a config file.");
+    if (candidate.configPath && !source) {
+      warnings.push("Config could not be read or exceeded the static inspection limit.");
+    }
+    if (unsafeTestDirectory) {
+      warnings.push(
+        "Configured testDir resolves outside the requested discovery root and was not scanned."
+      );
+    }
+    const hints = serverHints(candidate.framework, source);
+    if (hints.some((hint) => hint.incomplete)) {
+      warnings.push("Configured server contains dynamic values; only static hints are shown.");
+    }
+    projects.push({
+      framework: candidate.framework,
+      root: relativePath(root, candidate.root),
+      ...candidate.configPath ? { configPath: relativePath(root, candidate.configPath) } : {},
+      ...info ? { packagePath: relativePath(root, info.path) } : {},
+      packageManager: manager,
+      evidence: [
+        ...candidate.configPath ? [`config:${relativePath(root, candidate.configPath)}`] : [],
+        ...info?.dependencies.has(
+          candidate.framework === "playwright" ? "@playwright/test" : "cypress"
+        ) ? [`dependency:${candidate.framework === "playwright" ? "@playwright/test" : "cypress"}`] : [],
+        ...scripts.map((script) => `script:${script}`)
+      ],
+      scripts,
+      serverHints: hints,
+      specPattern: configuredSpecPattern(candidate.framework, source),
+      specCount: specs.count,
+      specSamples: specs.samples,
+      specsTruncated: specs.truncated,
+      execution: executionPlan(
+        candidate.framework,
+        manager,
+        relativePath(root, candidate.root),
+        candidate.configPath ? relativePath(candidate.root, candidate.configPath) : void 0,
+        scripts
+      ),
+      warnings
+    });
+  }
+  projects.sort((a, b) => a.root.localeCompare(b.root) || a.framework.localeCompare(b.framework));
+  return {
+    root,
+    projects,
+    scannedDirectories: scan.scannedDirectories,
+    scanTruncated: scan.truncated,
+    warnings: scan.truncated ? [`Discovery stopped after ${MAX_SCAN_DIRECTORIES} directories; narrow cwd or maxDepth.`] : []
+  };
+}
+var e2ePlanTool = {
+  name: "e2e_plan",
+  category: "Code Quality",
+  description: "Discover Playwright and Cypress projects and preview bounded E2E execution plans without loading configs or starting processes.",
+  usageHint: "Use before running browser E2E tests. The result identifies authoritative configs, package scripts, static server hints, specs, and exact argv. This tool never imports project config or executes commands.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: ["fs.read"],
+  icon: "test",
+  timeoutMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      cwd: { type: "string", description: "Directory inside the project to inspect." },
+      framework: {
+        type: "string",
+        enum: ["all", "playwright", "cypress"],
+        description: "Optional framework filter; defaults to all."
+      },
+      maxDepth: {
+        type: "integer",
+        minimum: 0,
+        maximum: 8,
+        description: "Maximum workspace discovery depth; defaults to 5."
+      },
+      includeSpecs: {
+        type: "boolean",
+        description: "Count and sample specs; defaults to true."
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const root = await safeResolveReal(input.cwd ?? ".", ctx);
+    return discoverE2EProjects(root, {
+      framework: input.framework,
+      maxDepth: input.maxDepth,
+      includeSpecs: input.includeSpecs,
+      signal: opts.signal
+    });
+  }
+};
+
 // src/edit.ts
-import * as fs17 from "node:fs/promises";
+import * as fs19 from "node:fs/promises";
 import {
-  atomicWrite,
+  atomicWrite as atomicWrite2,
   detectNewlineStyle,
   normalizeToLf,
   ToolValidationError,
@@ -10098,7 +11746,7 @@ function prefixSimilarity(a, b) {
 }
 
 // src/_syntax-check.ts
-import * as path19 from "node:path";
+import * as path23 from "node:path";
 var TS_LIKE = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
 var MAX_CHECK_CHARS = 15e5;
 var MAX_ERRORS = 5;
@@ -10122,15 +11770,15 @@ async function checkSyntax(filePath, content, previousContent) {
   return { errors, preExisting };
 }
 function isJsoncFile(filePath) {
-  const base = path19.basename(filePath).toLowerCase();
+  const base = path23.basename(filePath).toLowerCase();
   if (base.endsWith(".jsonc")) return true;
   if (/^(tsconfig|jsconfig)([.-].*)?\.json$/.test(base)) return true;
-  const dir = path19.basename(path19.dirname(filePath)).toLowerCase();
+  const dir = path23.basename(path23.dirname(filePath)).toLowerCase();
   return dir === ".vscode";
 }
 async function parseErrors(filePath, content) {
   if (content.length > MAX_CHECK_CHARS) return void 0;
-  const ext = path19.extname(filePath).toLowerCase();
+  const ext = path23.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".jsonc") {
     try {
       JSON.parse(content);
@@ -10157,7 +11805,7 @@ async function parseErrors(filePath, content) {
     ts2.ScriptKind.JSX
   );
   const sourceFile = ts2.createSourceFile(
-    path19.basename(filePath),
+    path23.basename(filePath),
     content,
     ts2.ScriptTarget.Latest,
     /* setParentNodes */
@@ -10231,7 +11879,7 @@ var editTool = {
       });
     }
     const absPath = await safeResolveReal(input.path, ctx);
-    const stat15 = await fs17.stat(absPath).catch((err) => {
+    const stat17 = await fs19.stat(absPath).catch((err) => {
       if (err.code === "ENOENT") {
         throw new ToolValidationError({
           message: `edit: file "${input.path}" does not exist. Use \`write\` instead.`,
@@ -10241,15 +11889,15 @@ var editTool = {
       }
       throw err;
     });
-    if (!stat15.isFile()) {
+    if (!stat17.isFile()) {
       throw new ToolValidationError({
         message: `edit: "${input.path}" is not a regular file`,
         field: "path"
       });
     }
     const autoRead = !ctx.hasRead(absPath);
-    const original = await fs17.readFile(absPath, "utf8");
-    const updated = await fs17.stat(absPath);
+    const original = await fs19.readFile(absPath, "utf8");
+    const updated = await fs19.stat(absPath);
     const mtimeTolerance = process.platform === "win32" ? 2e3 : 1;
     const originalHash = sha256hex(original);
     const lastReadHash = ctx.lastReadHash?.(absPath);
@@ -10271,7 +11919,7 @@ var editTool = {
         });
       }
     }
-    if (autoRead && updated.mtimeMs > stat15.mtimeMs + mtimeTolerance) {
+    if (autoRead && updated.mtimeMs > stat17.mtimeMs + mtimeTolerance) {
       throw new ToolValidationError({
         message: `edit: file "${input.path}" changed while being auto-read. Retry the edit.`,
         field: "path",
@@ -10353,8 +12001,8 @@ Compare this against your old_string and retry with the file's actual text.` : "
     }
     const newFile = toStyle(newFileLf, style);
     opts?.signal?.throwIfAborted();
-    await atomicWrite(absPath, newFile, { mode: updated.mode & 511 });
-    const written = await fs17.stat(absPath);
+    await atomicWrite2(absPath, newFile, { mode: updated.mode & 511 });
+    const written = await fs19.stat(absPath);
     ctx.recordRead(absPath, written.mtimeMs, "write", sha256hex(newFile));
     ctx.session.recordFileChange({
       path: absPath,
@@ -11314,7 +12962,7 @@ var BLOCKED_ARG_PATTERNS = {
   // and glob patterns that could expand to dangerous targets.
   // `rm -rf ./src/*` expands to project files; `rm -rf ../../` escapes upward;
   // `rm -rf /*` targets the filesystem root. All are blocked.
-  rm: [/^\//, /^~\//, /^~$/, /^\.$/, /^\.\.$/, /\*$/, /\/$/, /\/\*$/, /\.\//],
+  rm: [/^\//, /^[A-Za-z]:[\\/]/, /^~\//, /^~$/, /^\.$/, /^\.\.$/, /\*$/, /\/$/, /\/\*$/, /\.\//],
   // npm/pnpm subcommands are checked separately below. Matching every arg here
   // over-blocked normal dev flows such as `pnpm vitest run ...`.
   npm: [],
@@ -11482,7 +13130,7 @@ var execTool = {
   }
 };
 function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     let killed = false;
@@ -11490,7 +13138,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     const finish = (result) => {
       if (resolvedOnce.value) return;
       resolvedOnce.value = true;
-      resolve11(result);
+      resolve14(result);
     };
     const startedAt = Date.now();
     const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT2 });
@@ -11599,13 +13247,13 @@ import { FetchError as FetchError2, ToolError, ToolValidationError as ToolValida
 import TurndownService from "turndown";
 
 // src/_fetch-guard.ts
-import * as dns from "node:dns/promises";
-import * as net from "node:net";
+import * as dns2 from "node:dns/promises";
+import * as net3 from "node:net";
 import {
   FetchError,
   ToolValidationError as ToolValidationError2,
-  isPrivateIPv4,
-  isPrivateIPv6
+  isPrivateIPv4 as isPrivateIPv42,
+  isPrivateIPv6 as isPrivateIPv62
 } from "@wrongstack/core";
 import { Agent, fetch as undiciFetch } from "undici";
 var nativeGlobalFetch = globalThis.fetch;
@@ -11616,13 +13264,13 @@ if (ALLOW_PRIVATE && !process.env["CI"]) {
   );
 }
 function guardedLookup(hostname2, options, callback) {
-  dns.lookup(hostname2, { all: true }).then((records) => {
+  dns2.lookup(hostname2, { all: true }).then((records) => {
     const family = options?.family;
     const byFamily = family === 4 || family === 6 ? records.filter((r) => r.family === family) : records;
     const list = byFamily.length > 0 ? byFamily : records;
     if (!ALLOW_PRIVATE) {
       for (const r of list) {
-        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        const bad = r.family === 4 ? isPrivateIPv42(r.address) : isPrivateIPv62(r.address);
         if (bad) {
           callback(
             Object.assign(new Error(`fetch: resolved to private address ${r.address}`), {
@@ -11727,16 +13375,16 @@ async function assertNotPrivate(hostname2) {
       field: "url"
     });
   }
-  const ipVersion = net.isIP(host);
+  const ipVersion = net3.isIP(host);
   if (ipVersion === 4) {
-    if (isPrivateIPv4(host)) {
+    if (isPrivateIPv42(host)) {
       throw new ToolValidationError2({
         message: `fetch: blocked private/loopback address "${host}"`,
         field: "url"
       });
     }
   } else if (ipVersion === 6) {
-    if (isPrivateIPv6(host)) {
+    if (isPrivateIPv62(host)) {
       throw new ToolValidationError2({
         message: `fetch: blocked private/loopback address "${host}"`,
         field: "url"
@@ -11744,9 +13392,9 @@ async function assertNotPrivate(hostname2) {
     }
   } else {
     try {
-      const records = await dns.lookup(host, { all: true });
+      const records = await dns2.lookup(host, { all: true });
       for (const r of records) {
-        const bad = r.family === 4 ? isPrivateIPv4(r.address) : isPrivateIPv6(r.address);
+        const bad = r.family === 4 ? isPrivateIPv42(r.address) : isPrivateIPv62(r.address);
         if (bad) {
           throw new ToolValidationError2({
             message: `fetch: resolved to private address ${r.address}`,
@@ -12085,13 +13733,13 @@ var formatTool = {
   }
 };
 async function detectFixer(cwd) {
-  const { stat: stat15 } = await import("node:fs/promises");
+  const { stat: stat17 } = await import("node:fs/promises");
   try {
-    await stat15(`${cwd}/biome.json`);
+    await stat17(`${cwd}/biome.json`);
     return "biome";
   } catch {
     try {
-      await stat15(`${cwd}/.prettierrc`);
+      await stat17(`${cwd}/.prettierrc`);
       return "prettier";
     } catch {
       return "biome";
@@ -12103,7 +13751,7 @@ async function detectFixer(cwd) {
 init_util();
 import { spawn as spawn9 } from "node:child_process";
 import { statSync as statSync3 } from "node:fs";
-import { dirname as dirname9, resolve as resolve8, sep as sep3 } from "node:path";
+import { dirname as dirname12, resolve as resolve11, sep as sep4 } from "node:path";
 import { assessCommitSafety, buildChildEnv as buildChildEnv4 } from "@wrongstack/core";
 var TIMEOUT_MS2 = 3e4;
 var MAX_OUTPUT3 = 1e5;
@@ -12246,9 +13894,9 @@ function validateWorktreeInput(input, projectRoot) {
     return reject(`unsafe worktree path: ${input.worktreePath}`);
   }
   if ((input.worktreeAction === "add" || input.worktreeAction === "remove") && input.worktreePath) {
-    const root = resolve8(projectRoot);
-    const abs = resolve8(root, input.worktreePath);
-    if (abs !== root && !abs.startsWith(root + sep3)) {
+    const root = resolve11(projectRoot);
+    const abs = resolve11(root, input.worktreePath);
+    if (abs !== root && !abs.startsWith(root + sep4)) {
       return reject(`unsafe worktree path (escapes project root): ${input.worktreePath}`);
     }
   }
@@ -12259,12 +13907,12 @@ function findGitDir2(cwd, projectRoot) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat15 = statSync3(`${dir}/.git`);
-      if (stat15.isDirectory() || stat15.isFile()) return dir;
+      const stat17 = statSync3(`${dir}/.git`);
+      if (stat17.isDirectory() || stat17.isFile()) return dir;
     } catch {
     }
     if (dir === root) break;
-    const parent = dirname9(dir);
+    const parent = dirname12(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -12341,7 +13989,7 @@ function buildArgs(input) {
   }
 }
 function runGit2(args, cwd, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     const child = spawn9("git", args, {
@@ -12362,7 +14010,7 @@ function runGit2(args, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      resolve11({
+      resolve14({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: err.message,
@@ -12371,7 +14019,7 @@ function runGit2(args, cwd, signal) {
       });
     });
     child.on("close", (code) => {
-      resolve11({
+      resolve14({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: normalizeCommandOutput(stderr),
@@ -12383,8 +14031,8 @@ function runGit2(args, cwd, signal) {
 }
 
 // src/glob.ts
-import * as fs18 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as fs20 from "node:fs/promises";
+import * as path24 from "node:path";
 import { compileGlob as compileGlob3 } from "@wrongstack/core";
 
 // src/_concurrency.ts
@@ -12456,7 +14104,7 @@ var globTool = {
         return;
       }
       try {
-        const st = await fs18.stat(full);
+        const st = await fs20.stat(full);
         if (truncated || results.length >= limit) {
           truncated = true;
           return;
@@ -12477,7 +14125,7 @@ var globTool = {
       }
       let entries;
       try {
-        entries = await fs18.readdir(dir, { withFileTypes: true });
+        entries = await fs20.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -12488,7 +14136,7 @@ var globTool = {
         if (DEFAULT_IGNORE2.includes(name)) continue;
         if (ignored.includes(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
-        const full = path20.join(dir, name);
+        const full = path24.join(dir, name);
         if (e.isDirectory()) {
           subdirs.push({ full, rel });
         } else if (e.isFile()) {
@@ -12501,13 +14149,13 @@ var globTool = {
           }
         } else if (e.isSymbolicLink()) {
           try {
-            const st = await fs18.stat(full);
+            const st = await fs20.stat(full);
             if (st.isDirectory()) {
-              const real = await fs18.realpath(full);
+              const real = await fs20.realpath(full);
               await assertRealInsideRoot(real, ctx);
               subdirs.push({ full, rel });
             } else if (st.isFile()) {
-              const real = await fs18.realpath(full);
+              const real = await fs20.realpath(full);
               await assertRealInsideRoot(real, ctx);
               re.lastIndex = 0;
               const relMatch = re.test(rel);
@@ -12532,7 +14180,7 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs18.readFile(path20.join(dir, ".gitignore"), "utf8");
+    const raw = await fs20.readFile(path24.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -12542,8 +14190,8 @@ async function readGitignore(dir) {
 // src/grep.ts
 import { expectDefined as expectDefined7 } from "@wrongstack/core";
 import { spawn as spawn10 } from "node:child_process";
-import * as fs19 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs21 from "node:fs/promises";
+import * as path25 from "node:path";
 import { buildChildEnv as buildChildEnv5, compileGlob as compileGlob4, ToolValidationError as ToolValidationError4 } from "@wrongstack/core";
 
 // src/_regex.ts
@@ -12688,13 +14336,13 @@ var grepTool = {
   }
 };
 async function detectRg(signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     try {
       const p = spawn10("rg", ["--version"], { env: buildChildEnv5(), stdio: "ignore", signal, windowsHide: true });
-      p.on("error", () => resolve11(false));
-      p.on("close", (code) => resolve11(code === 0));
+      p.on("error", () => resolve14(false));
+      p.on("close", (code) => resolve14(code === 0));
     } catch {
-      resolve11(false);
+      resolve14(false);
     }
   });
 }
@@ -12845,9 +14493,9 @@ async function runNative(input, base, mode, limit, signal) {
     if (globRe && !globRe.test(name) && !globRe.test(full)) return;
     if (globRe) globRe.lastIndex = 0;
     try {
-      const stat15 = await fs19.stat(full);
-      if (!stat15.isFile() || stat15.size > maxBytes || stopped || signal.aborted) return;
-      const file = await fs19.open(full, "r");
+      const stat17 = await fs21.stat(full);
+      if (!stat17.isFile() || stat17.size > maxBytes || stopped || signal.aborted) return;
+      const file = await fs21.open(full, "r");
       try {
         let bytesReadTotal = 0;
         let lineNumber = 0;
@@ -12926,7 +14574,7 @@ async function runNative(input, base, mode, limit, signal) {
     if (stopped || signal.aborted) return;
     let entries;
     try {
-      entries = await fs19.readdir(dir, { withFileTypes: true });
+      entries = await fs21.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -12936,7 +14584,7 @@ async function runNative(input, base, mode, limit, signal) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
-      const full = path21.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (e.isDirectory()) {
         subdirs.push(full);
       } else if (e.isFile()) {
@@ -12959,7 +14607,7 @@ async function runNative(input, base, mode, limit, signal) {
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import { join as join18 } from "node:path";
+import { join as join21 } from "node:path";
 import { detectPackageEcosystem, recordPackageAction } from "@wrongstack/core";
 var installTool = {
   name: "install",
@@ -13136,16 +14784,16 @@ function resolveManifestPath(cwd, pkgManager) {
     case "pnpm":
     case "yarn":
     case "npm":
-      return join18(cwd, "package.json");
+      return join21(cwd, "package.json");
     /* v8 ignore next 2 -- pkgManager is always pnpm/yarn/npm; the default is defensive. */
     default:
-      return join18(cwd, "package.json");
+      return join21(cwd, "package.json");
   }
 }
 
 // src/json.ts
 init_util();
-import * as fs20 from "node:fs/promises";
+import * as fs22 from "node:fs/promises";
 import { deepMerge as deepMergeCore } from "@wrongstack/core";
 var jsonTool = {
   name: "json",
@@ -13220,7 +14868,7 @@ async function executeParse(input, ctx) {
   let raw;
   if (input.file) {
     try {
-      raw = await fs20.readFile(await safeResolveReal(input.file, ctx), "utf8");
+      raw = await fs22.readFile(await safeResolveReal(input.file, ctx), "utf8");
     } catch {
       return { data: null, formatted: "", type: "unknown", action: "parse", error: "Could not read file" };
     }
@@ -13278,7 +14926,7 @@ async function executeQuery(input, ctx) {
   let parsed;
   if (input.file) {
     try {
-      const raw = await fs20.readFile(await safeResolveReal(input.file, ctx), "utf8");
+      const raw = await fs22.readFile(await safeResolveReal(input.file, ctx), "utf8");
       parsed = JSON.parse(raw);
     } catch {
       return { data: null, formatted: "", type: "unknown", action: "query", error: "Could not read/parse file" };
@@ -13320,7 +14968,7 @@ async function executeValidate(input, ctx) {
   let parsed;
   if (input.file) {
     try {
-      const raw = await fs20.readFile(await safeResolveReal(input.file, ctx), "utf8");
+      const raw = await fs22.readFile(await safeResolveReal(input.file, ctx), "utf8");
       parsed = JSON.parse(raw);
     } catch {
       return { data: null, formatted: "", type: "unknown", action: "validate", error: "Could not read/parse file" };
@@ -13362,7 +15010,7 @@ async function executeTransform(input, ctx) {
   let parsed;
   if (input.file) {
     try {
-      const raw = await fs20.readFile(await safeResolveReal(input.file, ctx), "utf8");
+      const raw = await fs22.readFile(await safeResolveReal(input.file, ctx), "utf8");
       parsed = JSON.parse(raw);
     } catch {
       return { data: null, formatted: "", type: "unknown", action: "transform", error: "Could not read/parse file" };
@@ -13524,56 +15172,56 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path28) {
+  function check(value, s, path32) {
     if (s["type"]) {
       const expectedType = s["type"];
       const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
       if (expectedType === "integer") {
-        if (!Number.isInteger(value)) errors.push(`${path28}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path32}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path28}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path32}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path28}: not a valid URI`);
+        errors.push(`${path32}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const re = new RegExp(s["pattern"]);
-      if (!re.test(value)) errors.push(`${path28}: does not match pattern ${s["pattern"]}`);
+      if (!re.test(value)) errors.push(`${path32}: does not match pattern ${s["pattern"]}`);
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path28}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path32}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path28}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path32}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path28}: below minimum ${s["minimum"]}`);
+      errors.push(`${path32}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path28}: above maximum ${s["maximum"]}`);
+      errors.push(`${path32}: above maximum ${s["maximum"]}`);
     }
     if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
       for (let i = 0; i < value.length; i++) {
-        check(value[i], s["items"], `${path28}[${i}]`);
+        check(value[i], s["items"], `${path32}[${i}]`);
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value) && s["properties"]) {
       const props = s["properties"];
       for (const [k, propSchema] of Object.entries(props)) {
-        check(value[k], propSchema, `${path28}.${k}`);
+        check(value[k], propSchema, `${path32}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path28) {
-  const parts = path28.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path32) {
+  const parts = path32.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -14577,11 +16225,11 @@ var lintTool = {
   }
 };
 async function detectLinter(cwd) {
-  const { stat: stat15 } = await import("node:fs/promises");
+  const { stat: stat17 } = await import("node:fs/promises");
   const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
   for (const f of checks) {
     try {
-      await stat15(`${cwd}/${f}`);
+      await stat17(`${cwd}/${f}`);
       if (f.includes("biome")) return "biome";
       if (f.includes("eslint")) return "eslint";
       if (f.includes("tslint")) return "tslint";
@@ -14681,7 +16329,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     };
   }
   args.push("--timestamps", service);
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     const MAX = 2e5;
@@ -14697,7 +16345,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve11(result);
+      resolve14(result);
     };
     const child = spawn11("docker", args, { cwd, signal, env: buildChildEnv6(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
     const timer = setTimeout(() => {
@@ -14732,16 +16380,16 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path28, lines, filterRe, stream) {
+async function fileLogs(path32, lines, filterRe, stream) {
   const { createInterface } = await import("node:readline");
-  const { createReadStream } = await import("node:fs");
+  const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
   const effLines = lines > 0 ? Math.min(lines, MAX_TAIL_LINES) : MAX_TAIL_LINES;
   const window = new Array(effLines);
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream(path28),
+    input: createReadStream2(path32),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -14762,7 +16410,7 @@ async function fileLogs(path28, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path28,
+    source: path32,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -14916,7 +16564,7 @@ var outdatedTool = {
   }
 };
 function runOutdated(manager, args, cwd, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     const MAX = 1e5;
@@ -14941,10 +16589,10 @@ function runOutdated(manager, args, cwd, signal) {
     });
     child.on("close", (code) => {
       const result = parseOutdatedOutput(stdout, code ?? 0);
-      resolve11(result);
+      resolve14(result);
     });
     child.on("error", (e) => {
-      resolve11({
+      resolve14({
         exit_code: 1,
         packages: [],
         total: 0,
@@ -14954,9 +16602,9 @@ function runOutdated(manager, args, cwd, signal) {
     });
   });
 }
-function parseOutdatedOutput(json, exitCode) {
+function parseOutdatedOutput(json2, exitCode) {
   const packages = [];
-  if (!json) {
+  if (!json2) {
     return {
       exit_code: exitCode,
       packages: [],
@@ -14966,7 +16614,7 @@ function parseOutdatedOutput(json, exitCode) {
     };
   }
   try {
-    const data = JSON.parse(json);
+    const data = JSON.parse(json2);
     for (const name of Object.keys(data)) {
       const info = data[name];
       packages.push({
@@ -14984,17 +16632,17 @@ function parseOutdatedOutput(json, exitCode) {
     exit_code: exitCode,
     packages,
     total: packages.length,
-    output: json,
-    truncated: json.length >= 1e5
+    output: json2,
+    truncated: json2.length >= 1e5
   };
 }
 
 // src/patch.ts
 init_util();
 import { spawn as spawn13 } from "node:child_process";
-import * as fs21 from "node:fs/promises";
+import * as fs23 from "node:fs/promises";
 import * as os7 from "node:os";
-import * as path22 from "node:path";
+import * as path26 from "node:path";
 import { buildChildEnv as buildChildEnv8 } from "@wrongstack/core";
 var patchTool = {
   name: "patch",
@@ -15030,9 +16678,9 @@ var patchTool = {
     for (const t of targets) {
       const stripped = stripPathComponents(t, strip);
       if (!stripped) continue;
-      const candidate = path22.resolve(dir, stripped);
-      const rel = path22.relative(ctx.projectRoot, candidate);
-      if (rel.startsWith("..") || path22.isAbsolute(rel)) {
+      const candidate = path26.resolve(dir, stripped);
+      const rel = path26.relative(ctx.projectRoot, candidate);
+      if (rel.startsWith("..") || path26.isAbsolute(rel)) {
         return {
           applied: 0,
           rejected: 1,
@@ -15049,12 +16697,12 @@ var patchTool = {
         beforeContents.set(target, await readTextForTracking(target));
       }
     }
-    const tmpDir = await fs21.mkdtemp(path22.join(os7.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs23.mkdtemp(path26.join(os7.tmpdir(), ".wstack_patch_"));
     try {
-      await fs21.chmod(tmpDir, 448).catch(() => {
+      await fs23.chmod(tmpDir, 448).catch(() => {
       });
-      const patchFile = path22.join(tmpDir, "in.diff");
-      await fs21.writeFile(patchFile, input.patch, { mode: 384 });
+      const patchFile = path26.join(tmpDir, "in.diff");
+      await fs23.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
       if (result.exitCode !== 0 && !dryRun) {
@@ -15072,8 +16720,8 @@ var patchTool = {
           const before = beforeContents.get(target) ?? null;
           const after = await readTextForTracking(target);
           if (after === null || after === before) continue;
-          const stat15 = await fs21.stat(target).catch(() => null);
-          if (stat15) ctx.recordRead?.(target, stat15.mtimeMs, "write", sha256hex(after));
+          const stat17 = await fs23.stat(target).catch(() => null);
+          if (stat17) ctx.recordRead?.(target, stat17.mtimeMs, "write", sha256hex(after));
           ctx.session?.recordFileChange?.({
             path: target,
             action: before === null ? "created" : "modified",
@@ -15090,7 +16738,7 @@ var patchTool = {
         message: result.stdout || "patch applied"
       };
     } finally {
-      await fs21.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      await fs23.rm(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -15098,9 +16746,9 @@ var patchTool = {
 var MAX_TRACKING_BYTES = 5 * 1024 * 1024;
 async function readTextForTracking(absPath) {
   try {
-    const stat15 = await fs21.stat(absPath);
-    if (!stat15.isFile() || stat15.size > MAX_TRACKING_BYTES) return null;
-    const buf = await fs21.readFile(absPath);
+    const stat17 = await fs23.stat(absPath);
+    if (!stat17.isFile() || stat17.size > MAX_TRACKING_BYTES) return null;
+    const buf = await fs23.readFile(absPath);
     if (buf.includes(0)) return null;
     return buf.toString("utf8");
   } catch {
@@ -15125,7 +16773,7 @@ function stripPathComponents(p, strip) {
   return parts.slice(strip).join("/");
 }
 function runPatch(args, cwd, signal) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv8(), LANG: "C", LC_ALL: "C" };
@@ -15136,8 +16784,8 @@ function runPatch(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve11({ exitCode: code ?? 1, stdout, stderr }));
-    child.on("error", (e) => resolve11({ exitCode: 1, stdout: "", stderr: e.message }));
+    child.on("close", (code) => resolve14({ exitCode: code ?? 1, stdout, stderr }));
+    child.on("error", (e) => resolve14({ exitCode: 1, stdout: "", stderr: e.message }));
   });
 }
 function extractPatchedFiles(output) {
@@ -15414,13 +17062,13 @@ ${formatTaskList(taskFile.tasks)}`
   }
 };
 function mkResult(plan, ok, message, todos) {
-  const open2 = plan.items.filter((i) => i.status !== "done").length;
+  const open3 = plan.items.filter((i) => i.status !== "done").length;
   const result = {
     ok,
     message,
     plan: formatPlan(plan),
     count: plan.items.length,
-    open: open2
+    open: open3
   };
   if (todos !== void 0) result.todos = todos;
   return result;
@@ -15428,7 +17076,7 @@ function mkResult(plan, ok, message, todos) {
 
 // src/read.ts
 init_util();
-import * as fs22 from "node:fs/promises";
+import * as fs24 from "node:fs/promises";
 import { FsError, toErrorMessage as toErrorMessage4, ToolValidationError as ToolValidationError5 } from "@wrongstack/core";
 var MAX_BYTES2 = 5 * 1024 * 1024;
 var readTool = {
@@ -15477,9 +17125,9 @@ var readTool = {
       });
     }
     const absPath = await safeResolveReal(input.path, ctx);
-    let stat15;
+    let stat17;
     try {
-      stat15 = await fs22.stat(absPath);
+      stat17 = await fs24.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -15498,7 +17146,7 @@ var readTool = {
         cause: err
       });
     }
-    if (!stat15.isFile()) {
+    if (!stat17.isFile()) {
       throw new FsError({
         message: `read: "${input.path}" is not a regular file`,
         code: "FS_READ_FAILED",
@@ -15506,22 +17154,22 @@ var readTool = {
         context: { reason: "not-a-regular-file" }
       });
     }
-    if (stat15.size > MAX_BYTES2) {
+    if (stat17.size > MAX_BYTES2) {
       throw new FsError({
-        message: `read: file too large (${stat15.size} bytes, limit ${MAX_BYTES2})`,
+        message: `read: file too large (${stat17.size} bytes, limit ${MAX_BYTES2})`,
         code: "FS_READ_FAILED",
         path: absPath,
-        context: { size: stat15.size, limit: MAX_BYTES2, reason: "too-large" }
+        context: { size: stat17.size, limit: MAX_BYTES2, reason: "too-large" }
       });
     }
     const offset = Math.max(1, input.offset ?? 1);
     const limit = Math.max(0, Math.min(input.limit ?? 2e3, 5e3));
     const prior = getReadRangeRecord(ctx, absPath);
     const requestedEnd = prior ? Math.min(offset + limit - 1, prior.totalLines) : offset + limit - 1;
-    if (input.mode !== "summary" && limit > 0 && prior && coversRange(prior, stat15.mtimeMs, offset, requestedEnd)) {
-      ctx.recordRead(absPath, stat15.mtimeMs);
+    if (input.mode !== "summary" && limit > 0 && prior && coversRange(prior, stat17.mtimeMs, offset, requestedEnd)) {
+      ctx.recordRead(absPath, stat17.mtimeMs);
       return {
-        text: `[unchanged since previous read: "${input.path}" mtime=${Math.round(stat15.mtimeMs)}; requested lines ${offset}-${requestedEnd} were already shown. Use offset/limit for a new range if needed.]`,
+        text: `[unchanged since previous read: "${input.path}" mtime=${Math.round(stat17.mtimeMs)}; requested lines ${offset}-${requestedEnd} were already shown. Use offset/limit for a new range if needed.]`,
         total_lines: prior.totalLines,
         encoding: "utf8",
         truncated: requestedEnd < prior.totalLines,
@@ -15529,7 +17177,7 @@ var readTool = {
         note: "Repeated read suppressed to save tokens."
       };
     }
-    const buf = await fs22.readFile(absPath);
+    const buf = await fs24.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new Error(`read: "${input.path}" appears to be binary`);
     }
@@ -15538,10 +17186,10 @@ var readTool = {
     const allLines = text.split(/\r\n|\r|\n/);
     const total = allLines.length;
     if (input.mode === "summary") {
-      ctx.recordRead(absPath, stat15.mtimeMs, "user", contentHash);
-      rememberReadRange(ctx, absPath, stat15.mtimeMs, total, 1, Math.min(total, 200));
+      ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
+      rememberReadRange(ctx, absPath, stat17.mtimeMs, total, 1, Math.min(total, 200));
       return {
-        text: summarizeFile(input.path, stat15.size, allLines),
+        text: summarizeFile(input.path, stat17.size, allLines),
         total_lines: total,
         encoding: "utf8",
         truncated: total > 200,
@@ -15549,13 +17197,13 @@ var readTool = {
       };
     }
     if (limit === 0) {
-      ctx.recordRead(absPath, stat15.mtimeMs, "user", contentHash);
-      rememberReadRange(ctx, absPath, stat15.mtimeMs, total, 1, 0);
+      ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
+      rememberReadRange(ctx, absPath, stat17.mtimeMs, total, 1, 0);
       return { text: "", total_lines: total, encoding: "utf8", truncated: total > 0 };
     }
     if (offset > total) {
-      ctx.recordRead(absPath, stat15.mtimeMs, "user", contentHash);
-      rememberReadRange(ctx, absPath, stat15.mtimeMs, total, total + 1, total + 1);
+      ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
+      rememberReadRange(ctx, absPath, stat17.mtimeMs, total, total + 1, total + 1);
       return {
         text: `[offset ${offset} is past end of file "${input.path}" \u2014 file has ${total} line(s). Do not retry this offset.]`,
         total_lines: total,
@@ -15567,8 +17215,8 @@ var readTool = {
     const truncated = offset - 1 + slice.length < total;
     const width = String(offset + slice.length - 1).length;
     const numbered = slice.map((line, i) => `${String(offset + i).padStart(width, " ")}\u2192${line}`).join("\n");
-    ctx.recordRead(absPath, stat15.mtimeMs, "user", contentHash);
-    rememberReadRange(ctx, absPath, stat15.mtimeMs, total, offset, offset + slice.length - 1);
+    ctx.recordRead(absPath, stat17.mtimeMs, "user", contentHash);
+    rememberReadRange(ctx, absPath, stat17.mtimeMs, total, offset, offset + slice.length - 1);
     return {
       text: numbered,
       total_lines: total,
@@ -15637,10 +17285,10 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 // src/replace.ts
 import { expectDefined as expectDefined8 } from "@wrongstack/core";
 import { spawn as spawn14 } from "node:child_process";
-import * as fs23 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as fs25 from "node:fs/promises";
+import * as path27 from "node:path";
 import {
-  atomicWrite as atomicWrite2,
+  atomicWrite as atomicWrite3,
   buildChildEnv as buildChildEnv9,
   compileGlob as compileGlob5,
   detectNewlineStyle as detectNewlineStyle2,
@@ -15711,11 +17359,11 @@ var replaceTool = {
     const dryRun = input.dry_run ?? true;
     const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
     const fileList = await resolveFiles2(filesInput, ctx, globRe);
-    const realRoot = await fs23.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+    const realRoot = await fs25.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
     const results = [];
     let totalReplacements = 0;
     for (const absPath of fileList) {
-      const lstat2 = await fs23.lstat(absPath).catch((err) => {
+      const lstat2 = await fs25.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
@@ -15723,17 +17371,17 @@ var replaceTool = {
       if (lstat2.isSymbolicLink()) continue;
       let realPath;
       try {
-        realPath = await fs23.realpath(absPath);
+        realPath = await fs25.realpath(absPath);
       } catch {
         continue;
       }
-      const rel = path23.relative(realRoot, realPath);
-      if (rel.startsWith("..") || path23.isAbsolute(rel)) continue;
-      const stat15 = await fs23.stat(realPath).catch(() => null);
-      if (!stat15?.isFile()) continue;
+      const rel = path27.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path27.isAbsolute(rel)) continue;
+      const stat17 = await fs25.stat(realPath).catch(() => null);
+      if (!stat17?.isFile()) continue;
       let content;
       try {
-        const buf = await fs23.readFile(realPath);
+        const buf = await fs25.readFile(realPath);
         if (isBinaryBuffer(buf)) continue;
         content = buf.toString("utf8");
       } catch {
@@ -15755,8 +17403,8 @@ var replaceTool = {
       totalReplacements += count;
       if (!dryRun) {
         const newContent = toStyle2(newContentLf, style);
-        await atomicWrite2(realPath, newContent, { mode: stat15.mode & 511 });
-        const written = await fs23.stat(realPath).catch(() => null);
+        await atomicWrite3(realPath, newContent, { mode: stat17.mode & 511 });
+        const written = await fs25.stat(realPath).catch(() => null);
         if (written) {
           ctx.recordRead?.(realPath, written.mtimeMs, "write", sha256hex(newContent));
         }
@@ -15795,8 +17443,8 @@ async function resolveFiles2(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = safeResolve(p, ctx);
-    const stat15 = await fs23.stat(absPath).catch(() => null);
-    if (stat15?.isFile()) {
+    const stat17 = await fs25.stat(absPath).catch(() => null);
+    if (stat17?.isFile()) {
       resolved.push(absPath);
     }
   }
@@ -15814,13 +17462,13 @@ async function globFiles(pattern, base, extraGlob) {
   return await globNative(pattern, base, extraGlob);
 }
 function checkRg() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve14) => {
     try {
       const p = spawn14("rg", ["--version"], { env: buildChildEnv9(), stdio: "ignore", windowsHide: true });
-      p.on("error", () => resolve11(false));
-      p.on("close", (code) => resolve11(code === 0));
+      p.on("error", () => resolve14(false));
+      p.on("close", (code) => resolve14(code === 0));
     } catch {
-      resolve11(false);
+      resolve14(false);
     }
   });
 }
@@ -15837,10 +17485,10 @@ function spawnRgFind(pattern, base) {
     buf += chunk.toString();
   });
   return {
-    promise: new Promise((resolve11, reject) => {
+    promise: new Promise((resolve14, reject) => {
       child.on("error", reject);
       child.on("close", () => {
-        resolve11(buf.split("\n").filter(Boolean));
+        resolve14(buf.split("\n").filter(Boolean));
       });
     })
   };
@@ -15851,16 +17499,16 @@ async function globNative(pattern, base, extraGlob) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await fs23.readdir(dir, { withFileTypes: true });
+      entries = await fs25.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (DEFAULT_IGNORE4.includes(e.name)) continue;
-      const full = path23.join(dir, e.name);
+      const full = path27.join(dir, e.name);
       try {
-        const stat15 = await fs23.lstat(full);
-        if (stat15.isSymbolicLink()) continue;
+        const stat17 = await fs25.lstat(full);
+        if (stat17.isSymbolicLink()) continue;
       } catch {
         continue;
       }
@@ -15883,9 +17531,9 @@ async function globNative(pattern, base, extraGlob) {
 
 // src/scaffold.ts
 init_util();
-import * as fs24 from "node:fs/promises";
-import * as path24 from "node:path";
-import { atomicWrite as atomicWrite3 } from "@wrongstack/core";
+import * as fs26 from "node:fs/promises";
+import * as path28 from "node:path";
+import { atomicWrite as atomicWrite4 } from "@wrongstack/core";
 var BUILT_IN_TEMPLATES = {
   "npm-package": {
     description: "Basic npm package with ESM",
@@ -16034,17 +17682,17 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
   let filesCreated = 0;
   for (const [filePath, content] of Object.entries(templateFiles)) {
     const resolvedPath = substituteVars(filePath, name, vars);
-    const joinedPath = path24.join(cwd, resolvedPath);
-    const root = path24.resolve(ctx.projectRoot);
-    const target = path24.resolve(joinedPath);
-    const rel = path24.relative(root, target);
-    if (rel.startsWith("..") || path24.isAbsolute(rel)) {
+    const joinedPath = path28.join(cwd, resolvedPath);
+    const root = path28.resolve(ctx.projectRoot);
+    const target = path28.resolve(joinedPath);
+    const rel = path28.relative(root, target);
+    if (rel.startsWith("..") || path28.isAbsolute(rel)) {
       throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs24.mkdir(path24.dirname(fullPath), { recursive: true });
-      await atomicWrite3(fullPath, substituteVars(content, name, vars));
+      await fs26.mkdir(path28.dirname(fullPath), { recursive: true });
+      await atomicWrite4(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
     filesCreated++;
@@ -16078,6 +17726,7 @@ var DEFAULT_NUM = 10;
 var MAX_RESULTS = 50;
 var TIMEOUT_MS3 = 15e3;
 var CACHE_TTL_MS = 3e5;
+var CACHE_MAX_ENTRIES = 200;
 var cache = /* @__PURE__ */ new Map();
 var searchTool = {
   name: "search",
@@ -16199,7 +17848,7 @@ var searchTool = {
     }
     const finalResults = ranked.slice(0, num);
     cache.set(cacheKey, { results: ranked, source: effectiveSource, timestamp: Date.now() });
-    pruneStaleCacheEntries();
+    pruneCacheEntries();
     yield {
       type: "partial_output",
       text: `${finalResults.length} results from ${effectiveSource}`,
@@ -16221,11 +17870,16 @@ var searchTool = {
     };
   }
 };
-function pruneStaleCacheEntries() {
+function pruneCacheEntries() {
   const cutoff = Date.now() - CACHE_TTL_MS * 2;
   for (const [key, entry] of cache.entries()) {
     if (entry.timestamp < cutoff) cache.delete(key);
   }
+  while (cache.size > CACHE_MAX_ENTRIES) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey === void 0) break;
+    cache.delete(oldestKey);
+  }
 }
 function rankSearchResults(results, query) {
   const seenUrls = /* @__PURE__ */ new Set();
@@ -16454,7 +18108,7 @@ function decodeHtmlEntities(text) {
 }
 
 // src/set-working-dir.ts
-import * as fs25 from "node:fs/promises";
+import * as fs27 from "node:fs/promises";
 import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
 var setWorkingDirTool = {
   name: "set_working_dir",
@@ -16493,7 +18147,7 @@ var setWorkingDirTool = {
       };
     }
     try {
-      await fs25.access(resolved);
+      await fs27.access(resolved);
     } catch {
       try {
         ctx.setWorkingDir(previous);
@@ -16893,7 +18547,7 @@ ${formatTaskList2(file.tasks)}` : file.tasks.length > 0 ? formatTaskList2(file.t
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path25 from "node:path";
+import * as path29 from "node:path";
 var testTool = {
   name: "test",
   category: "Code Quality",
@@ -16996,11 +18650,11 @@ var testTool = {
   }
 };
 async function detectRunner(cwd) {
-  const { stat: stat15 } = await import("node:fs/promises");
+  const { stat: stat17 } = await import("node:fs/promises");
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat15(path25.join(cwd, f));
+      await stat17(path29.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -17466,8 +19120,8 @@ var toolUseTool = {
 // src/tree.ts
 init_util();
 import { expectDefined as expectDefined10 } from "@wrongstack/core";
-import * as fs26 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as fs28 from "node:fs/promises";
+import * as path30 from "node:path";
 var DEFAULT_IGNORE5 = [
   "node_modules",
   ".git",
@@ -17608,7 +19262,7 @@ var treeTool = {
   }
 };
 async function walkDir(dir, depth, opts) {
-  const entries = await fs26.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs28.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
     if (opts.exclude.has(e.name)) return false;
@@ -17638,7 +19292,7 @@ async function walkDir(dir, depth, opts) {
     opts.lines.push(opts.prefix + branch + displayName);
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
-      await walkDir(path26.join(dir, entry.name), depth + 1, {
+      await walkDir(path30.join(dir, entry.name), depth + 1, {
         ...opts,
         prefix: childPrefix,
         isLast
@@ -17651,7 +19305,7 @@ async function walkDir(dir, depth, opts) {
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path27 from "node:path";
+import * as path31 from "node:path";
 var typecheckTool = {
   name: "typecheck",
   category: "Code Quality",
@@ -17750,12 +19404,12 @@ var typecheckTool = {
   }
 };
 async function findTsConfig(cwd) {
-  const { stat: stat15 } = await import("node:fs/promises");
+  const { stat: stat17 } = await import("node:fs/promises");
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat15(path27.join(cwd, f));
-      if (s.isFile()) return path27.join(cwd, f);
+      const s = await stat17(path31.join(cwd, f));
+      if (s.isFile()) return path31.join(cwd, f);
     } catch {
     }
   }
@@ -17763,8 +19417,8 @@ async function findTsConfig(cwd) {
 }
 
 // src/write.ts
-import * as fs27 from "node:fs/promises";
-import { atomicWrite as atomicWrite4, ToolValidationError as ToolValidationError8, unifiedDiff as unifiedDiff3 } from "@wrongstack/core";
+import * as fs29 from "node:fs/promises";
+import { atomicWrite as atomicWrite5, ToolValidationError as ToolValidationError8, unifiedDiff as unifiedDiff3 } from "@wrongstack/core";
 init_util();
 var writeTool = {
   name: "write",
@@ -17828,14 +19482,14 @@ async function prepareWrite(input, ctx) {
   let existed = false;
   let prev = "";
   try {
-    const stat15 = await fs27.stat(absPath);
-    existed = stat15.isFile();
+    const stat17 = await fs29.stat(absPath);
+    existed = stat17.isFile();
     if (existed) {
       if (!ctx.hasRead(absPath)) {
-        prev = await fs27.readFile(absPath, "utf8");
-        ctx.recordRead(absPath, stat15.mtimeMs, "write", sha256hex(prev));
+        prev = await fs29.readFile(absPath, "utf8");
+        ctx.recordRead(absPath, stat17.mtimeMs, "write", sha256hex(prev));
       } else {
-        prev = await fs27.readFile(absPath, "utf8");
+        prev = await fs29.readFile(absPath, "utf8");
       }
     }
   } catch (err) {
@@ -17847,11 +19501,11 @@ async function prepareWrite(input, ctx) {
 }
 async function finishWrite(input, ctx, prepared, signal) {
   signal?.throwIfAborted();
-  await atomicWrite4(prepared.absPath, input.content);
+  await atomicWrite5(prepared.absPath, input.content);
   const diff = prepared.existed ? unifiedDiff3(prepared.prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${input.content.split("\n").length} lines)`;
-  const stat15 = await fs27.stat(prepared.absPath);
-  ctx.recordRead(prepared.absPath, stat15.mtimeMs, "write", sha256hex(input.content));
+  const stat17 = await fs29.stat(prepared.absPath);
+  ctx.recordRead(prepared.absPath, stat17.mtimeMs, "write", sha256hex(input.content));
   ctx.session.recordFileChange({
     path: prepared.absPath,
     action: prepared.existed ? "modified" : "created",
@@ -17875,7 +19529,27 @@ async function finishWrite(input, ctx, prepared, signal) {
 }
 
 // src/builtin.ts
+var OPTIONAL_TOOLS = [
+  ...browserTools,
+  e2ePlanTool,
+  installTool,
+  auditTool,
+  outdatedTool,
+  logsTool,
+  documentTool,
+  scaffoldTool,
+  toolSearchTool,
+  toolUseTool,
+  batchToolUseTool,
+  toolHelpTool,
+  codebaseIndexTool,
+  codebaseSearchTool,
+  codebaseStatsTool,
+  setWorkingDirTool
+];
 var builtinTools = [
+  ...browserTools,
+  e2ePlanTool,
   readTool,
   writeTool,
   editTool,
@@ -17922,7 +19596,7 @@ var builtinTools = [
 // src/pack.ts
 var builtinToolsPack = {
   name: "builtin-tools",
-  description: "The complete set of built-in tools that ship with WrongStack. Covers filesystem (read/write/edit/replace/glob/grep/tree), execution (bash/exec/git/install), networking (fetch/search), code quality (lint/test/typecheck/format), planning (todo/plan/memory), and meta tools (tool-search/tool-help/batch-tool-use/codebase-*).",
+  description: "The complete set of built-in tools that ship with WrongStack. Covers filesystem, execution, first-party browser automation, read-only E2E planning, networking, code quality, planning, and meta tools.",
   tools: builtinTools
 };
 export {