@drewpayment/mink 0.12.0-beta.8 → 0.13.0-beta.1

package/dist/cli.bun.js

@@ -4727,6 +4727,342 @@ var init_reflect = __esm(() => {
   init_fs_utils();
 });
 
+// src/core/agent-detect.ts
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync17 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir3 } from "os";
+function commandExists(bin) {
+  try {
+    const probe = process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`;
+    execSync5(probe, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectAgent(meta, cwd) {
+  const signals = [];
+  if (existsSync17(join14(cwd, meta.projectDir))) {
+    signals.push(`project config (${meta.projectDir}/)`);
+  }
+  if (existsSync17(meta.globalDir)) {
+    signals.push("global config");
+  }
+  if (commandExists(meta.bin)) {
+    signals.push("on PATH");
+  }
+  return { ...meta, detected: signals.length > 0, signals };
+}
+function detectAgents(cwd) {
+  return AGENTS.map((m) => detectAgent(m, cwd));
+}
+function resolveTargetsFromFlag(flag) {
+  const normalized = flag.trim().toLowerCase();
+  if (normalized === "all")
+    return AGENTS.map((a) => a.id);
+  const ids = normalized.split(",").map((s) => s.trim()).filter(Boolean);
+  const valid = AGENTS.map((a) => a.id);
+  const resolved = ids.filter((id) => valid.includes(id));
+  return resolved;
+}
+var AGENTS;
+var init_agent_detect = __esm(() => {
+  AGENTS = [
+    {
+      id: "claude",
+      label: "Claude Code",
+      projectDir: ".claude",
+      globalDir: join14(homedir3(), ".claude"),
+      bin: "claude"
+    },
+    {
+      id: "pi",
+      label: "Pi",
+      projectDir: ".pi",
+      globalDir: join14(homedir3(), ".pi"),
+      bin: "pi"
+    }
+  ];
+});
+
+// src/core/agent-pi.ts
+import { join as join15, resolve as resolve2, dirname as dirname7 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, copyFileSync, rmSync as rmSync2 } from "fs";
+function piExtensionPath(cwd) {
+  return join15(cwd, ".pi", "extensions", "mink.ts");
+}
+function piGuidanceSkillPath(cwd) {
+  return join15(cwd, ".pi", "skills", "mink", "SKILL.md");
+}
+function piNoteSkillPath(cwd) {
+  return join15(cwd, ".pi", "skills", "mink-note", "SKILL.md");
+}
+function buildPiExtension(cliPath) {
+  const isTsSource = cliPath.endsWith(".ts");
+  const cmd = isTsSource ? "bun" : "mink";
+  const baseArgs = isTsSource ? JSON.stringify(["run", cliPath]) : "[]";
+  return `// AUTO-GENERATED by \`mink init\`. Do not edit \u2014 re-run \`mink init\` to refresh.
+//
+// Mink adapter for the Pi coding agent. Routes Pi lifecycle and tool events
+// into the \`mink\` CLI so Pi shares the same ~/.mink state, file index, ledger,
+// and wiki as every other assistant wired to this project.
+//
+// Field shapes confirmed against pi source (earendil-works/pi,
+// packages/coding-agent): read params {path, offset, limit}; write {path,
+// content}; edit {path, edits:[{oldText,newText}]} (with legacy file_path /
+// top-level oldText,newText). tool_call/tool_result events expose toolName,
+// toolCallId, input; tool_result also exposes content (a content-block array),
+// details, isError. Advisories are surfaced by returning a modified result from
+// the tool_result handler \u2014 the documented mechanism. pi.exec has no stdin, so
+// the canonical payload is piped to \`mink\` via a spawned child process. Every
+// host-API access is defensive: the adapter never throws into Pi or blocks a
+// tool \u2014 a failure degrades to "no advisory".
+
+import { spawn } from "node:child_process";
+
+const MINK_CMD = ${JSON.stringify(cmd)};
+const MINK_BASE_ARGS = ${baseArgs};
+const TIMEOUT_MS = 5000;
+
+function runMink(sub, payload, cwd) {
+  return new Promise((res) => {
+    let done = false;
+    const finish = (out) => {
+      if (done) return;
+      done = true;
+      res(out);
+    };
+    try {
+      const child = spawn(MINK_CMD, [...MINK_BASE_ARGS, sub], {
+        cwd,
+        stdio: ["pipe", "ignore", "pipe"],
+      });
+      let stderr = "";
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      child.on("error", () => finish(""));
+      child.on("close", () => finish(stderr.trim()));
+      const timer = setTimeout(() => {
+        try {
+          child.kill();
+        } catch {}
+        finish("");
+      }, TIMEOUT_MS);
+      timer.unref?.();
+      try {
+        child.stdin?.end(payload ? JSON.stringify(payload) : "");
+      } catch {}
+    } catch {
+      finish("");
+    }
+  });
+}
+
+// Pi's edit tool takes an array of { oldText, newText } replacements (legacy
+// inputs may put oldText/newText/new_string at the top level). Concatenate the
+// replacement text so Mink's write-enforcement sees everything being written.
+function editNewText(input) {
+  if (Array.isArray(input.edits)) {
+    return input.edits
+      .map((e) => e?.newText ?? e?.new_string ?? "")
+      .filter(Boolean)
+      .join("\\n");
+  }
+  return input.newText ?? input.new_string ?? input.replacement ?? "";
+}
+
+// Resolve Pi's tool name + arguments to Mink's canonical operation. Only the
+// three file operations matter; anything else returns null and is ignored.
+function toolInfo(event) {
+  const name = String(event?.toolName ?? event?.tool ?? event?.name ?? "").toLowerCase();
+  const input = event?.input ?? event?.arguments ?? {};
+  const filePath = input.path ?? input.file_path ?? input.filePath;
+  if (!filePath) return null;
+  if (name === "read") return { op: "read", filePath };
+  if (name === "write") return { op: "write", filePath, content: input.content ?? input.text ?? "" };
+  if (name === "edit") return { op: "edit", filePath, newString: editNewText(input) };
+  return null;
+}
+
+// A tool_result's content is an array of content blocks ({ type, text }); pull
+// the text out so Mink's post-read can estimate tokens from real content.
+function resultContent(event) {
+  const c = event?.content;
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) {
+    const text = c
+      .map((b) => (typeof b === "string" ? b : b?.text ?? ""))
+      .filter(Boolean)
+      .join("\\n");
+    return text || null;
+  }
+  return null;
+}
+
+function prePayload(info) {
+  if (info.op === "read")
+    return { sub: "pre-read", payload: { tool_name: "Read", tool_input: { file_path: info.filePath } } };
+  if (info.op === "write")
+    return {
+      sub: "pre-write",
+      payload: { tool_name: "Write", tool_input: { file_path: info.filePath, content: info.content } },
+    };
+  return {
+    sub: "pre-write",
+    payload: { tool_name: "Edit", tool_input: { file_path: info.filePath, new_string: info.newString } },
+  };
+}
+
+function postPayload(info, content) {
+  if (info.op === "read")
+    return {
+      sub: "post-read",
+      payload: {
+        tool_name: "Read",
+        tool_input: { file_path: info.filePath },
+        tool_output: content == null ? undefined : { content },
+      },
+    };
+  if (info.op === "write")
+    return {
+      sub: "post-write",
+      payload: { tool_name: "Write", tool_input: { file_path: info.filePath, content: info.content } },
+    };
+  return {
+    sub: "post-write",
+    payload: { tool_name: "Edit", tool_input: { file_path: info.filePath, new_string: info.newString } },
+  };
+}
+
+export default function (pi) {
+  const cwd = pi?.ctx?.cwd || process.cwd();
+  const pending = new Map();
+  const keyOf = (event) => event?.toolCallId ?? event?.id ?? event?.callId ?? "";
+
+  pi.on?.("session_start", (event) => {
+    // Skip hot-reloads so an extension reload mid-task doesn't reset the
+    // ephemeral session state; every genuinely new/resumed session starts fresh.
+    if (event?.reason === "reload") return;
+    void runMink("session-start", null, cwd);
+  });
+  pi.on?.("agent_end", () => {
+    void runMink("session-stop", null, cwd);
+  });
+  pi.on?.("session_shutdown", () => {
+    void runMink("session-stop", null, cwd);
+  });
+
+  pi.on?.("tool_call", async (event) => {
+    const info = toolInfo(event);
+    if (!info) return;
+    const { sub, payload } = prePayload(info);
+    const advisory = await runMink(sub, payload, cwd);
+    if (advisory) pending.set(keyOf(event), advisory);
+  });
+
+  pi.on?.("tool_result", async (event) => {
+    const info = toolInfo(event);
+    if (!info) return;
+    const { sub, payload } = postPayload(info, resultContent(event));
+    const post = await runMink(sub, payload, cwd);
+    const pre = pending.get(keyOf(event)) ?? "";
+    pending.delete(keyOf(event));
+    const advisory = [pre, post].filter(Boolean).join("\\n");
+    if (!advisory) return;
+
+    // Surface Mink's advisory into the model's context by appending a text
+    // block to the tool result \u2014 the parity of Claude feeding hook stderr back.
+    const base = Array.isArray(event.content)
+      ? event.content
+      : typeof event.content === "string"
+        ? [{ type: "text", text: event.content }]
+        : [];
+    return {
+      content: [...base, { type: "text", text: advisory }],
+      details: event.details,
+      isError: event.isError,
+    };
+  });
+}
+`;
+}
+function resolveSkillsSourceDir() {
+  let dir = dirname7(new URL(import.meta.url).pathname);
+  while (true) {
+    if (existsSync18(join15(dir, "package.json")) && existsSync18(join15(dir, "skills"))) {
+      return join15(dir, "skills");
+    }
+    const parent = dirname7(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return resolve2(dirname7(new URL(import.meta.url).pathname), "../../skills");
+}
+function installPi(cwd, cliPath) {
+  const extensionPath = piExtensionPath(cwd);
+  mkdirSync8(dirname7(extensionPath), { recursive: true });
+  atomicWriteText(extensionPath, buildPiExtension(cliPath));
+  const guidancePath = piGuidanceSkillPath(cwd);
+  mkdirSync8(dirname7(guidancePath), { recursive: true });
+  atomicWriteText(guidancePath, PI_GUIDANCE_SKILL);
+  let notePath = null;
+  try {
+    const src = join15(resolveSkillsSourceDir(), "mink-note", "SKILL.md");
+    if (existsSync18(src)) {
+      notePath = piNoteSkillPath(cwd);
+      mkdirSync8(dirname7(notePath), { recursive: true });
+      copyFileSync(src, notePath);
+    }
+  } catch {
+    notePath = null;
+  }
+  return { extensionPath, guidancePath, notePath };
+}
+var PI_GUIDANCE_SKILL = `---
+name: mink
+description: Mink context management is active in this project. Read this to understand how Mink memory, write enforcement, and note capture work under Pi.
+---
+
+# Mink \u2014 context management for this project
+
+This project uses **Mink** (\`@drewpayment/mink\`) for cross-session context management.
+
+## How it works
+- Mink runs automatically through a Pi extension at \`.pi/extensions/mink.ts\` that hooks session start/stop and every read/edit/write tool call.
+- All state lives in \`~/.mink/\` on the user's machine \u2014 **not** in this repository. Do not create or write to any in-repo state directory (no \`.wolf/\`, \`.mink/\`, etc.).
+- Read intelligence, write enforcement, bug memory, and the token ledger are handled by the extension. You do not need to manually read or update any state files.
+- Mink shares one \`~/.mink/\` state across every assistant wired to this project, so history is unified whether the user runs Pi or another assistant.
+
+## When to act on Mink
+- If the user asks to "save a note", "remember this", "log this to my wiki", or similar, use the \`mink-note\` skill (\`/skill:mink-note\`) \u2014 it captures into the user's \`~/.mink/\` vault.
+- If the extension surfaces a learning, past bug, or repeat-read warning in context, treat that as authoritative project memory and follow it.
+- The \`mink dashboard\` and \`mink agent\` commands are user tools \u2014 do not invoke them on the user's behalf.
+`;
+var init_agent_pi = __esm(() => {
+  init_fs_utils();
+});
+
+// src/core/prompt.ts
+import { createInterface } from "readline";
+function stdinIsInteractive() {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  return Boolean(stdin.isTTY) && Boolean(stdout.isTTY) && process.env.MINK_NO_PROMPT !== "1" && !process.env.CI;
+}
+function ask(question) {
+  return new Promise((resolve3) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve3(answer);
+    });
+  });
+}
+var init_prompt = () => {};
+
 // src/core/backup.ts
 var exports_backup = {};
 __export(exports_backup, {
@@ -4735,14 +5071,14 @@ __export(exports_backup, {
   createBackup: () => createBackup
 });
 import {
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync7,
   readFileSync as readFileSync12,
   writeFileSync as writeFileSync5,
-  existsSync as existsSync17,
+  existsSync as existsSync19,
   statSync as statSync7
 } from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 function formatTimestamp(date) {
   const y = date.getFullYear();
   const mo = String(date.getMonth() + 1).padStart(2, "0");
@@ -4754,15 +5090,15 @@ function formatTimestamp(date) {
   return `${y}${mo}${d}-${h}${mi}${s}${ms}`;
 }
 function copyDirectoryFiles(srcDir, destDir, excludeDirs) {
-  mkdirSync8(destDir, { recursive: true });
+  mkdirSync9(destDir, { recursive: true });
   const entries = readdirSync7(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (excludeDirs.includes(entry.name))
         continue;
-      copyDirectoryFiles(join14(srcDir, entry.name), join14(destDir, entry.name), excludeDirs);
+      copyDirectoryFiles(join16(srcDir, entry.name), join16(destDir, entry.name), excludeDirs);
     } else if (entry.isFile()) {
-      writeFileSync5(join14(destDir, entry.name), readFileSync12(join14(srcDir, entry.name)));
+      writeFileSync5(join16(destDir, entry.name), readFileSync12(join16(srcDir, entry.name)));
     }
   }
 }
@@ -4771,25 +5107,25 @@ function createBackup(cwd) {
   const dir = backupDirPath(cwd);
   let name = base;
   let suffix = 1;
-  while (existsSync17(join14(dir, name))) {
+  while (existsSync19(join16(dir, name))) {
     name = `${base}-${suffix}`;
     suffix++;
   }
   const src = projectDir(cwd);
-  const dest = join14(dir, name);
+  const dest = join16(dir, name);
   copyDirectoryFiles(src, dest, ["backups"]);
   return name;
 }
 function listBackups(cwd) {
   const dir = backupDirPath(cwd);
-  if (!existsSync17(dir))
+  if (!existsSync19(dir))
     return [];
   const entries = readdirSync7(dir, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || !entry.name.startsWith("backup-"))
       continue;
-    const backupPath = join14(dir, entry.name);
+    const backupPath = join16(dir, entry.name);
     const match = entry.name.match(/^backup-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})(\d{3})?(?:-\d+)?$/);
     let timestamp;
     if (match) {
@@ -4812,8 +5148,8 @@ function listBackups(cwd) {
   return backups;
 }
 function restoreBackup(cwd, backupName) {
-  const backupPath = join14(backupDirPath(cwd), backupName);
-  if (!existsSync17(backupPath)) {
+  const backupPath = join16(backupDirPath(cwd), backupName);
+  if (!existsSync19(backupPath)) {
     throw new Error(`backup not found: ${backupName}`);
   }
   createBackup(cwd);
@@ -4825,7 +5161,7 @@ var init_backup = __esm(() => {
 
 // src/core/scanner.ts
 import { readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { join as join15, relative } from "path";
+import { join as join17, relative } from "path";
 function matchesPattern(name, pattern) {
   if (pattern.includes("*")) {
     const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
@@ -4849,14 +5185,14 @@ function walkDirectory(dir, projectRoot, excludes, results) {
     if (entry.isDirectory()) {
       if (isExcluded(entry.name, excludes))
         continue;
-      walkDirectory(join15(dir, entry.name), projectRoot, excludes, results);
+      walkDirectory(join17(dir, entry.name), projectRoot, excludes, results);
       continue;
     }
     if (entry.isFile()) {
       if (isExcluded(entry.name, excludes))
         continue;
       try {
-        const fullPath = join15(dir, entry.name);
+        const fullPath = join17(dir, entry.name);
         const stat = statSync8(fullPath);
         results.push({
           relativePath: relative(projectRoot, fullPath),
@@ -5279,7 +5615,7 @@ __export(exports_scan, {
 });
 import { readFileSync as readFileSync13 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join16, relative as relative2 } from "path";
+import { join as join18, relative as relative2 } from "path";
 function configRelativePath(cfgPath, cwd) {
   const rel = relative2(cwd, cfgPath);
   return rel.startsWith("..") ? cfgPath : rel;
@@ -5330,7 +5666,7 @@ function scan(cwd, options) {
     if (!stalePaths.has(file.relativePath)) {
       continue;
     }
-    const fullPath = join16(cwd, file.relativePath);
+    const fullPath = join18(cwd, file.relativePath);
     let content;
     try {
       content = readFileSync13(fullPath, "utf-8");
@@ -5419,10 +5755,10 @@ __export(exports_seed, {
   parseGoMod: () => parseGoMod,
   parseCargoToml: () => parseCargoToml
 });
-import { basename as basename4, join as join17 } from "path";
-import { readFileSync as readFileSync14, existsSync as existsSync18 } from "fs";
+import { basename as basename4, join as join19 } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync20 } from "fs";
 function readFile(filePath) {
-  if (!existsSync18(filePath))
+  if (!existsSync20(filePath))
     return null;
   try {
     return readFileSync14(filePath, "utf-8");
@@ -5515,10 +5851,10 @@ function parseGoMod(filePath) {
 }
 function seedLearningMemory(projectRoot) {
   const parsers = [
-    () => parsePackageJson(join17(projectRoot, "package.json")),
-    () => parsePyprojectToml(join17(projectRoot, "pyproject.toml")),
-    () => parseCargoToml(join17(projectRoot, "Cargo.toml")),
-    () => parseGoMod(join17(projectRoot, "go.mod"))
+    () => parsePackageJson(join19(projectRoot, "package.json")),
+    () => parsePyprojectToml(join19(projectRoot, "pyproject.toml")),
+    () => parseCargoToml(join19(projectRoot, "Cargo.toml")),
+    () => parseGoMod(join19(projectRoot, "go.mod"))
   ];
   const infos = parsers.map((fn) => fn()).filter((info) => info !== null);
   const projectName = infos.find((i) => i.projectName)?.projectName ?? basename4(projectRoot);
@@ -5596,34 +5932,37 @@ var init_seed = __esm(() => {
 var exports_init = {};
 __export(exports_init, {
   writeMinkRule: () => writeMinkRule,
+  resolveTargetsFromFlag: () => resolveTargetsFromFlag,
+  resolveTargets: () => resolveTargets,
   resolveCliPathFrom: () => resolveCliPathFrom,
   resolveCliPath: () => resolveCliPath,
   mergeHooksIntoSettings: () => mergeHooksIntoSettings,
+  installClaude: () => installClaude,
   init: () => init,
   detectRuntime: () => detectRuntime,
   buildHooksConfig: () => buildHooksConfig
 });
-import { execSync as execSync5 } from "child_process";
-import { mkdirSync as mkdirSync9, existsSync as existsSync19 } from "fs";
-import { resolve as resolve2, dirname as dirname7, basename as basename5, join as join18 } from "path";
+import { execSync as execSync6 } from "child_process";
+import { mkdirSync as mkdirSync10, existsSync as existsSync21 } from "fs";
+import { resolve as resolve3, dirname as dirname8, basename as basename5, join as join20 } from "path";
 function detectRuntime() {
   try {
-    execSync5("bun --version", { stdio: "ignore" });
+    execSync6("bun --version", { stdio: "ignore" });
     return "bun";
   } catch {
     return "node";
   }
 }
 function resolveCliPathFrom(selfPath) {
-  const selfDir = dirname7(selfPath);
+  const selfDir = dirname8(selfPath);
   if (selfPath.endsWith("dist/cli.js") || selfPath.endsWith("dist/cli.bun.js") || selfPath.endsWith("dist/cli.node.js")) {
-    return join18(selfDir, "cli.js");
+    return join20(selfDir, "cli.js");
   }
-  const packageRoot = resolve2(selfDir, "..", "..");
-  const distShim = join18(packageRoot, "dist", "cli.js");
-  if (existsSync19(distShim))
+  const packageRoot = resolve3(selfDir, "..", "..");
+  const distShim = join20(packageRoot, "dist", "cli.js");
+  if (existsSync21(distShim))
     return distShim;
-  return join18(packageRoot, "src", "cli.ts");
+  return join20(packageRoot, "src", "cli.ts");
 }
 function resolveCliPath() {
   return resolveCliPathFrom(new URL(import.meta.url).pathname);
@@ -5665,13 +6004,13 @@ function isMinkHook(entry) {
   return false;
 }
 function writeMinkRule(cwd) {
-  const rulePath = resolve2(cwd, ".claude", "rules", "mink.md");
-  mkdirSync9(dirname7(rulePath), { recursive: true });
+  const rulePath = resolve3(cwd, ".claude", "rules", "mink.md");
+  mkdirSync10(dirname8(rulePath), { recursive: true });
   atomicWriteText(rulePath, MINK_RULE_CONTENT);
   return rulePath;
 }
 function mergeHooksIntoSettings(settingsPath, newHooks) {
-  mkdirSync9(dirname7(settingsPath), { recursive: true });
+  mkdirSync10(dirname8(settingsPath), { recursive: true });
   const existing = safeReadJson(settingsPath) ?? {};
   const existingHooks = existing.hooks ?? {};
   for (const [event, entries] of Object.entries(newHooks)) {
@@ -5682,17 +6021,46 @@ function mergeHooksIntoSettings(settingsPath, newHooks) {
   existing.hooks = existingHooks;
   atomicWriteJson(settingsPath, existing);
 }
+function installClaude(cwd, cliPath) {
+  const settingsPath = resolve3(cwd, ".claude", "settings.json");
+  mergeHooksIntoSettings(settingsPath, buildHooksConfig(cliPath));
+  const rulePath = writeMinkRule(cwd);
+  return { settingsPath, rulePath };
+}
+async function resolveTargets(cwd, opts) {
+  if (opts.targets && opts.targets.length > 0)
+    return opts.targets;
+  const detected = detectAgents(cwd);
+  const detectedIds = detected.filter((a) => a.detected).map((a) => a.id);
+  if (opts.interactive && stdinIsInteractive()) {
+    return promptForAgents(detected, detectedIds);
+  }
+  return detectedIds.length > 0 ? detectedIds : ["claude"];
+}
+async function promptForAgents(detected, defaults) {
+  const fallback = defaults.length > 0 ? defaults : ["claude"];
+  console.log("Which assistant(s) should Mink work with?");
+  detected.forEach((a, i) => {
+    const tag = a.detected ? `  (detected \u2014 ${a.signals.join(", ")})` : "";
+    console.log(`  ${i + 1}) ${a.label}${tag}`);
+  });
+  const answer = (await ask(`Enter numbers (comma-separated), 'a' for all [default: ${fallback.join(", ")}]: `)).trim().toLowerCase();
+  if (answer === "")
+    return fallback;
+  if (answer === "a" || answer === "all")
+    return AGENTS.map((a) => a.id);
+  const picked = answer.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n) && n >= 1 && n <= detected.length).map((n) => detected[n - 1].id);
+  return picked.length > 0 ? picked : fallback;
+}
 function isExistingInstallation(cwd) {
   const dir = projectDir(cwd);
-  if (!existsSync19(dir))
+  if (!existsSync21(dir))
     return false;
-  return existsSync19(join18(dir, "file-index.json"));
+  return existsSync21(join20(dir, "file-index.json"));
 }
-async function init(cwd) {
+async function init(cwd, opts = {}) {
   const runtime = detectRuntime();
   const cliPath = resolveCliPath();
-  const hooks = buildHooksConfig(cliPath);
-  const settingsPath = resolve2(cwd, ".claude", "settings.json");
   const dir = projectDir(cwd);
   const upgrading = isExistingInstallation(cwd);
   if (upgrading) {
@@ -5701,9 +6069,22 @@ async function init(cwd) {
     const backupName = createBackup2(cwd);
     console.log(`  backup: ${backupName}`);
   }
-  mergeHooksIntoSettings(settingsPath, hooks);
-  const rulePath = writeMinkRule(cwd);
-  mkdirSync9(dir, { recursive: true });
+  const targets = await resolveTargets(cwd, opts);
+  const wired = {};
+  for (const target of targets) {
+    if (target === "claude") {
+      const { settingsPath, rulePath } = installClaude(cwd, cliPath);
+      wired.claude = [`hooks: ${settingsPath}`, `rule:  ${rulePath}`];
+    } else if (target === "pi") {
+      const r = installPi(cwd, cliPath);
+      wired.pi = [
+        `extension: ${r.extensionPath}`,
+        `guidance:  ${r.guidancePath}`,
+        ...r.notePath ? [`note skill: ${r.notePath}`] : []
+      ];
+    }
+  }
+  mkdirSync10(dir, { recursive: true });
   const identity = resolveProjectIdentity(cwd);
   const projectId = identity.id;
   const isNotesProject = isWikiEnabled() && isVaultInitialized() && isInsideVault(cwd);
@@ -5711,6 +6092,8 @@ async function init(cwd) {
   const existingMeta = safeReadJson(metaPath);
   const deviceId = getOrCreateDeviceId();
   const existingPathsByDevice = existingMeta?.pathsByDevice && typeof existingMeta.pathsByDevice === "object" && !Array.isArray(existingMeta.pathsByDevice) ? existingMeta.pathsByDevice : {};
+  const priorAgents = Array.isArray(existingMeta?.agents) ? existingMeta.agents : [];
+  const agents = Array.from(new Set([...priorAgents, ...targets]));
   atomicWriteJson(metaPath, {
     ...existingMeta ?? {},
     cwd,
@@ -5718,20 +6101,29 @@ async function init(cwd) {
     initTimestamp: existingMeta?.initTimestamp ?? new Date().toISOString(),
     version: "0.1.0",
     pathsByDevice: { ...existingPathsByDevice, [deviceId]: cwd },
+    agents,
     ...isNotesProject ? { projectType: "notes" } : {}
   });
+  const printWiring = () => {
+    for (const id of Object.keys(wired)) {
+      const label = AGENTS.find((a) => a.id === id)?.label ?? id;
+      console.log(`  ${label}:`);
+      for (const line of wired[id])
+        console.log(`    ${line}`);
+    }
+  };
   if (upgrading) {
     console.log(`[mink] upgrade complete`);
     console.log(`  project:  ${projectId}`);
-    console.log(`  hooks:    ${settingsPath}`);
-    console.log(`  rule:     ${rulePath}`);
+    console.log(`  agents:   ${agents.join(", ")}`);
+    printWiring();
   } else {
     console.log(`[mink] initialized`);
     console.log(`  project:  ${projectId} (${identity.source})`);
     console.log(`  state:    ${dir}`);
     console.log(`  runtime:  ${runtime}`);
-    console.log(`  hooks:    ${settingsPath}`);
-    console.log(`  rule:     ${rulePath}`);
+    console.log(`  agents:   ${agents.join(", ")}`);
+    printWiring();
   }
   if (identity.source === "path-derived") {
     const root = getRepoRoot(cwd);
@@ -5743,7 +6135,7 @@ async function init(cwd) {
   scan2(cwd, { check: false });
   const { learningMemoryPath: learningMemoryPath2 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
   const memPath = learningMemoryPath2(cwd);
-  if (!existsSync19(memPath)) {
+  if (!existsSync21(memPath)) {
     const { seedLearningMemory: seedLearningMemory2 } = await Promise.resolve().then(() => (init_seed(), exports_seed));
     const { serializeLearningMemory: serializeLearningMemory2 } = await Promise.resolve().then(() => (init_learning_memory(), exports_learning_memory));
     const mem = seedLearningMemory2(cwd);
@@ -5752,8 +6144,8 @@ async function init(cwd) {
   if (isWikiEnabled() && isVaultInitialized() && !isNotesProject) {
     try {
       const projectSlug = basename5(cwd);
-      const overviewPath = join18(vaultProjects(projectSlug), "overview.md");
-      if (!existsSync19(overviewPath)) {
+      const overviewPath = join20(vaultProjects(projectSlug), "overview.md");
+      if (!existsSync21(overviewPath)) {
         const now = new Date().toISOString();
         const overview = [
           `---`,
@@ -5805,6 +6197,9 @@ var init_init = __esm(() => {
   init_device();
   init_git_identity();
   init_vault();
+  init_agent_detect();
+  init_agent_pi();
+  init_prompt();
 });
 
 // src/repositories/counters-repo.ts
@@ -5879,12 +6274,12 @@ var init_state_counters = __esm(() => {
 });
 
 // src/core/channel-templates.ts
-import { join as join19 } from "path";
-import { existsSync as existsSync20, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
+import { join as join21 } from "path";
+import { existsSync as existsSync22, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11 } from "fs";
 function writeCompanionClaudeMd(vaultPath, overwrite = false) {
-  mkdirSync10(vaultPath, { recursive: true });
-  const claudeMdPath = join19(vaultPath, "CLAUDE.md");
-  if (existsSync20(claudeMdPath) && !overwrite) {
+  mkdirSync11(vaultPath, { recursive: true });
+  const claudeMdPath = join21(vaultPath, "CLAUDE.md");
+  if (existsSync22(claudeMdPath) && !overwrite) {
     return false;
   }
   writeFileSync6(claudeMdPath, COMPANION_CLAUDE_MD);
@@ -6036,8 +6431,8 @@ mink wiki rebuild-index
 var init_channel_templates = () => {};
 
 // src/core/channel-process.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync11, existsSync as existsSync21 } from "fs";
-import { dirname as dirname8, join as join20 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync12, existsSync as existsSync23 } from "fs";
+import { dirname as dirname9, join as join22 } from "path";
 import { spawnSync } from "child_process";
 function readChannelPidFile() {
   try {
@@ -6053,7 +6448,7 @@ function readChannelPidFile() {
 }
 function writeChannelPidFile(data) {
   const pidPath = channelPidPath();
-  mkdirSync11(dirname8(pidPath), { recursive: true });
+  mkdirSync12(dirname9(pidPath), { recursive: true });
   writeFileSync7(pidPath, JSON.stringify(data, null, 2));
 }
 function removeChannelPidFile() {
@@ -6183,12 +6578,12 @@ function getChannelLogs() {
     return null;
   if (!screenSessionExists(pidData.session))
     return null;
-  const tmpPath = join20(minkRoot(), `.channel-capture-${Date.now()}-${process.pid}.txt`);
+  const tmpPath = join22(minkRoot(), `.channel-capture-${Date.now()}-${process.pid}.txt`);
   const result = spawnSync("screen", ["-S", pidData.session, "-X", "hardcopy", "-h", tmpPath], { stdio: "ignore" });
   if (result.status !== 0)
     return null;
   for (let i = 0;i < 20; i++) {
-    if (existsSync21(tmpPath))
+    if (existsSync23(tmpPath))
       break;
     const delayUntil = Date.now() + 50;
     while (Date.now() < delayUntil) {}
@@ -6292,7 +6687,7 @@ async function runtimeServe(opts) {
   }
   const { createServer } = await import("http");
   const { Readable } = await import("stream");
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const httpServer = createServer(async (req, res) => {
       const url = `http://${opts.hostname}:${opts.port}${req.url ?? "/"}`;
       const headers = new Headers;
@@ -6351,7 +6746,7 @@ async function runtimeServe(opts) {
     httpServer.listen(opts.port, opts.hostname, () => {
       const addr = httpServer.address();
       const boundPort = typeof addr === "object" && addr ? addr.port : opts.port;
-      resolve3({
+      resolve4({
         port: boundPort,
         stop: (close) => {
           if (close)
@@ -6369,8 +6764,8 @@ var init_runtime = __esm(() => {
 
 // src/core/daemon.ts
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, openSync } from "fs";
-import { mkdirSync as mkdirSync12 } from "fs";
-import { dirname as dirname9, resolve as resolve3 } from "path";
+import { mkdirSync as mkdirSync13 } from "fs";
+import { dirname as dirname10, resolve as resolve4 } from "path";
 function readPidFile() {
   try {
     const raw = readFileSync16(schedulerPidPath(), "utf-8");
@@ -6385,7 +6780,7 @@ function readPidFile() {
 }
 function writePidFile(data) {
   const pidPath = schedulerPidPath();
-  mkdirSync12(dirname9(pidPath), { recursive: true });
+  mkdirSync13(dirname10(pidPath), { recursive: true });
   writeFileSync8(pidPath, JSON.stringify(data, null, 2));
 }
 function removePidFile() {
@@ -6410,10 +6805,10 @@ function startDaemon(cwd) {
   if (existing) {
     removePidFile();
   }
-  const __dir = dirname9(new URL(import.meta.url).pathname);
-  const cliPath = process.argv[1] ?? resolve3(__dir, "../cli.ts");
+  const __dir = dirname10(new URL(import.meta.url).pathname);
+  const cliPath = process.argv[1] ?? resolve4(__dir, "../cli.ts");
   const logPath = schedulerLogPath();
-  mkdirSync12(dirname9(logPath), { recursive: true });
+  mkdirSync13(dirname10(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const proc = runtimeSpawn(["bun", "run", cliPath, "cron", "__daemon"], {
     cwd,
@@ -6527,9 +6922,9 @@ var exports_status = {};
 __export(exports_status, {
   status: () => status
 });
-import { existsSync as existsSync23, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
 function checkJsonFile(name, filePath, validator) {
-  if (!existsSync23(filePath))
+  if (!existsSync25(filePath))
     return { name, path: filePath, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -6539,7 +6934,7 @@ function checkJsonFile(name, filePath, validator) {
   return { name, path: filePath, status: "ok" };
 }
 function checkDbFile(name, filePath) {
-  if (!existsSync23(filePath))
+  if (!existsSync25(filePath))
     return { name, path: filePath, status: "missing" };
   try {
     const header = readFileSync17(filePath).slice(0, 16).toString("utf-8");
@@ -6554,7 +6949,7 @@ function checkDbFile(name, filePath) {
 function checkShardedText(name, candidatePaths) {
   const canonical = candidatePaths[0];
   for (const p of candidatePaths) {
-    if (!existsSync23(p))
+    if (!existsSync25(p))
       continue;
     try {
       if (statSync9(p).size === 0)
@@ -6647,7 +7042,7 @@ function status(cwd) {
       console.log(`    Decision Log: ${mem.sections["Decision Log"].length}`);
       console.log(`    Total entries: ${total}`);
       const memPath = learningMemoryPath(cwd);
-      if (existsSync23(memPath)) {
+      if (existsSync25(memPath)) {
         const mtime = statSync9(memPath).mtime;
         console.log(`    Canonical last modified: ${mtime.toISOString()}`);
       }
@@ -7487,9 +7882,9 @@ __export(exports_self_update, {
   PACKAGE_NAME: () => PACKAGE_NAME
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname10 } from "path";
-import { join as join21 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname11 } from "path";
+import { join as join23 } from "path";
 function parseSemver(input) {
   const trimmed = input.trim().replace(/^v/, "");
   if (!trimmed)
@@ -7536,15 +7931,15 @@ function compareSemver(a, b) {
 function getInstallInfo() {
   const selfPath = new URL(import.meta.url).pathname;
   const isDevMode = selfPath.endsWith(".ts");
-  let dir = dirname10(selfPath);
+  let dir = dirname11(selfPath);
   let packageJsonPath = null;
   for (let i = 0;i < 10; i++) {
-    const candidate = join21(dir, "package.json");
-    if (existsSync24(candidate)) {
+    const candidate = join23(dir, "package.json");
+    if (existsSync26(candidate)) {
       packageJsonPath = candidate;
       break;
     }
-    const parent = dirname10(dir);
+    const parent = dirname11(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -7614,7 +8009,7 @@ function buildInstallCommand(pm, version) {
   return ["npm", "install", "-g", ref];
 }
 function selfUpdateLogPath() {
-  return join21(minkRoot(), "self-update.log");
+  return join23(minkRoot(), "self-update.log");
 }
 function appendLogEntry(entry) {
   const path = selfUpdateLogPath();
@@ -8403,21 +8798,21 @@ var init_cron = __esm(() => {
 });
 
 // src/core/vault-templates.ts
-import { join as join22 } from "path";
-import { existsSync as existsSync25, writeFileSync as writeFileSync9, readFileSync as readFileSync21, mkdirSync as mkdirSync13 } from "fs";
+import { join as join24 } from "path";
+import { existsSync as existsSync27, writeFileSync as writeFileSync9, readFileSync as readFileSync21, mkdirSync as mkdirSync14 } from "fs";
 function seedTemplates(templatesDir) {
-  mkdirSync13(templatesDir, { recursive: true });
+  mkdirSync14(templatesDir, { recursive: true });
   for (const [name, content] of Object.entries(DEFAULT_TEMPLATES)) {
-    const filePath = join22(templatesDir, `${name}.md`);
-    if (!existsSync25(filePath)) {
+    const filePath = join24(templatesDir, `${name}.md`);
+    if (!existsSync27(filePath)) {
       writeFileSync9(filePath, content);
     }
   }
 }
 function loadTemplate(templatesDir, templateName, vars) {
-  const filePath = join22(templatesDir, `${templateName}.md`);
+  const filePath = join24(templatesDir, `${templateName}.md`);
   let content;
-  if (existsSync25(filePath)) {
+  if (existsSync27(filePath)) {
     content = readFileSync21(filePath, "utf-8");
   } else if (DEFAULT_TEMPLATES[templateName]) {
     content = DEFAULT_TEMPLATES[templateName];
@@ -8571,29 +8966,29 @@ category: resources
 });
 
 // src/core/note-writer.ts
-import { join as join23 } from "path";
-import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
+import { join as join25 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 import { createHash as createHash3 } from "crypto";
 function sha256(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
 function resolveUniqueNotePath(dir, baseSlug, content) {
   const targetHash = sha256(content);
-  const primary = join23(dir, `${baseSlug}.md`);
-  if (!existsSync26(primary))
+  const primary = join25(dir, `${baseSlug}.md`);
+  if (!existsSync28(primary))
     return primary;
   if (sameContent(primary, targetHash))
     return primary;
   const dev4 = getOrCreateDeviceId().replace(/-/g, "").slice(0, 4);
   for (let i = 0;i < MAX_COLLISION_ATTEMPTS; i++) {
     const suffix = i === 0 ? dev4 : `${dev4}-${i + 1}`;
-    const candidate = join23(dir, `${baseSlug}-${suffix}.md`);
-    if (!existsSync26(candidate))
+    const candidate = join25(dir, `${baseSlug}-${suffix}.md`);
+    if (!existsSync28(candidate))
       return candidate;
     if (sameContent(candidate, targetHash))
       return candidate;
   }
-  return join23(dir, `${baseSlug}-${Date.now()}.md`);
+  return join25(dir, `${baseSlug}-${Date.now()}.md`);
 }
 function sameContent(filePath, expectedHash) {
   try {
@@ -8668,8 +9063,8 @@ ${meta.body}
 }
 function appendToDaily(date, content) {
   const dir = vaultDailyDir();
-  const filePath = join23(dir, `${date}.md`);
-  if (existsSync26(filePath)) {
+  const filePath = join25(dir, `${date}.md`);
+  if (existsSync28(filePath)) {
     const timestamp = new Date().toLocaleTimeString("en-US", {
       hour: "2-digit",
       minute: "2-digit",
@@ -8778,10 +9173,10 @@ var init_design_eval = __esm(() => {
 });
 
 // src/core/dashboard-api.ts
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
 import { readdirSync as readdirSync9, readFileSync as readFileSyncFS, existsSync as fsExistsSync } from "fs";
-import { join as join24, resolve as resolve5, normalize, sep } from "path";
-import { execSync as execSync6 } from "child_process";
+import { join as join26, resolve as resolve6, normalize, sep } from "path";
+import { execSync as execSync7 } from "child_process";
 function isSecretKey(key) {
   return SECRET_KEY_PATTERNS.some((re) => re.test(key));
 }
@@ -8793,7 +9188,7 @@ function maskSecret(value, showLast = 4) {
   return "\u2022\u2022\u2022\u2022" + value.slice(-showLast);
 }
 function checkJsonFile2(name, filePath, validator) {
-  if (!existsSync27(filePath))
+  if (!existsSync29(filePath))
     return { name, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -8803,7 +9198,7 @@ function checkJsonFile2(name, filePath, validator) {
   return { name, status: "ok" };
 }
 function checkTextFile(name, filePath) {
-  if (!existsSync27(filePath))
+  if (!existsSync29(filePath))
     return { name, status: "missing" };
   try {
     readFileSync23(filePath, "utf-8");
@@ -8813,7 +9208,7 @@ function checkTextFile(name, filePath) {
   }
 }
 function checkDbFile2(name, filePath) {
-  if (!existsSync27(filePath))
+  if (!existsSync29(filePath))
     return { name, status: "missing" };
   try {
     const header = readFileSync23(filePath).slice(0, 16).toString("utf-8");
@@ -8995,7 +9390,7 @@ function getAheadBehind(branch) {
   if (!branch)
     return { ahead: 0, behind: 0 };
   try {
-    const raw = execSync6(`git rev-list --left-right --count origin/${branch}...${branch}`, { cwd: minkRoot(), timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    const raw = execSync7(`git rev-list --left-right --count origin/${branch}...${branch}`, { cwd: minkRoot(), timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
     const [behindStr, aheadStr] = raw.split(/\s+/);
     return {
       behind: Number(behindStr) || 0,
@@ -9007,7 +9402,7 @@ function getAheadBehind(branch) {
 }
 function getPendingChanges() {
   try {
-    const raw = execSync6("git status --porcelain", {
+    const raw = execSync7("git status --porcelain", {
       cwd: minkRoot(),
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -9079,7 +9474,7 @@ function countMarkdownIn(dir) {
     for (const entry of readdirSync9(dir, { withFileTypes: true })) {
       if (WIKI_TREE_EXCLUDES.has(entry.name) || entry.name.startsWith("."))
         continue;
-      const fullPath = join24(dir, entry.name);
+      const fullPath = join26(dir, entry.name);
       if (entry.isDirectory()) {
         count += countMarkdownIn(fullPath);
       } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
@@ -9108,7 +9503,7 @@ function buildVaultTree(root) {
     for (const entry of entries) {
       if (!entry.isDir)
         continue;
-      const fullPath = join24(dir, entry.name);
+      const fullPath = join26(dir, entry.name);
       const relPath = fullPath.slice(root.length + 1);
       const count = countMarkdownIn(fullPath);
       nodes.push({ name: entry.name, path: relPath, count, depth });
@@ -9193,7 +9588,7 @@ function resolveVaultRelativePath(relPath) {
   if (!relPath || relPath.includes("\x00"))
     return null;
   const root = resolveVaultPath();
-  const absolute = resolve5(root, relPath);
+  const absolute = resolve6(root, relPath);
   const normalizedRoot = normalize(root) + sep;
   if (!absolute.startsWith(normalizedRoot) && absolute !== normalize(root)) {
     return null;
@@ -9531,7 +9926,7 @@ async function triggerIngestFile(sourcePath, category, tags, dedupKey) {
     if (!isValidCategory(category)) {
       return { success: false, error: `Invalid category: ${category}` };
     }
-    const expanded = sourcePath.startsWith("~/") ? join24(process.env.HOME ?? "", sourcePath.slice(2)) : sourcePath;
+    const expanded = sourcePath.startsWith("~/") ? join26(process.env.HOME ?? "", sourcePath.slice(2)) : sourcePath;
     if (!fsExistsSync(expanded)) {
       return { success: false, error: `Source file not found: ${sourcePath}` };
     }
@@ -9618,8 +10013,8 @@ __export(exports_dashboard_server, {
   startDashboardServer: () => startDashboardServer
 });
 import { watch } from "fs";
-import { existsSync as existsSync28 } from "fs";
-import { basename as basename7, dirname as dirname11, join as join25, extname as extname2 } from "path";
+import { existsSync as existsSync30 } from "fs";
+import { basename as basename7, dirname as dirname12, join as join27, extname as extname2 } from "path";
 
 class SSEManager {
   clients = new Map;
@@ -9796,15 +10191,15 @@ async function startDashboardServer(cwd, options = {}) {
       timestamp: new Date().toISOString()
     });
   });
-  const __dir = dirname11(new URL(import.meta.url).pathname);
+  const __dir = dirname12(new URL(import.meta.url).pathname);
   let pkgRoot = __dir;
-  while (pkgRoot !== dirname11(pkgRoot)) {
-    if (existsSync28(join25(pkgRoot, "package.json")))
+  while (pkgRoot !== dirname12(pkgRoot)) {
+    if (existsSync30(join27(pkgRoot, "package.json")))
       break;
-    pkgRoot = dirname11(pkgRoot);
+    pkgRoot = dirname12(pkgRoot);
   }
-  const dashboardOutDir = join25(pkgRoot, "dashboard", "out");
-  const dashboardBuilt = existsSync28(join25(dashboardOutDir, "index.html"));
+  const dashboardOutDir = join27(pkgRoot, "dashboard", "out");
+  const dashboardBuilt = existsSync30(join27(dashboardOutDir, "index.html"));
   let clientIdCounter = 0;
   if (!dashboardBuilt) {
     console.warn("[mink] dashboard not built. Run: cd dashboard && bun run build");
@@ -9834,9 +10229,9 @@ async function startDashboardServer(cwd, options = {}) {
         } else {
           let filePath;
           if (pathname === "/") {
-            filePath = join25(dashboardOutDir, "index.html");
+            filePath = join27(dashboardOutDir, "index.html");
           } else {
-            filePath = join25(dashboardOutDir, pathname);
+            filePath = join27(dashboardOutDir, pathname);
           }
           if (!filePath.startsWith(dashboardOutDir)) {
             return jsonResponse({ error: "Forbidden" }, 403);
@@ -9849,7 +10244,7 @@ async function startDashboardServer(cwd, options = {}) {
           const htmlServed = await serveFile(filePath + ".html", "text/html; charset=utf-8");
           if (htmlServed)
             return htmlServed;
-          const indexServed = await serveFile(join25(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
+          const indexServed = await serveFile(join27(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
           if (indexServed)
             return indexServed;
         }
@@ -9958,7 +10353,7 @@ retry: 3000
             if (!filename || filename.includes("..") || filename.includes("/")) {
               return jsonResponse({ error: "Invalid filename" }, 400);
             }
-            const imgPath = join25(designCapturesDir(resolvedCwd), filename);
+            const imgPath = join27(designCapturesDir(resolvedCwd), filename);
             const served = await serveFile(imgPath, "image/jpeg");
             if (served) {
               served.headers.set("Cache-Control", "public, max-age=60");
@@ -10193,9 +10588,9 @@ __export(exports_dashboard, {
   resolveStartupCwd: () => resolveStartupCwd,
   dashboard: () => dashboard
 });
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 function resolveStartupCwd(cwd, registered = listRegisteredProjects()) {
-  if (existsSync29(projectDir(cwd))) {
+  if (existsSync31(projectDir(cwd))) {
     return { kind: "active", cwd };
   }
   if (registered.length === 0) {
@@ -10232,10 +10627,10 @@ var init_dashboard = __esm(() => {
 });
 
 // src/core/daemon-service.ts
-import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname12, join as join26 } from "path";
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync32, mkdirSync as mkdirSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname13, join as join28 } from "path";
 function detectPlatform() {
   if (process.platform === "linux")
     return "systemd";
@@ -10245,11 +10640,11 @@ function detectPlatform() {
 }
 function resolveServiceInvocation() {
   const entry = process.argv[1];
-  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync30(entry)) {
+  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync32(entry)) {
     return {
       executable: entry,
       args: ["daemon", "start"],
-      pathDir: dirname12(entry)
+      pathDir: dirname13(entry)
     };
   }
   const cliPath = resolveCliPath();
@@ -10257,17 +10652,17 @@ function resolveServiceInvocation() {
   return {
     executable: interpreter,
     args: [cliPath, "daemon", "start"],
-    pathDir: dirname12(interpreter)
+    pathDir: dirname13(interpreter)
   };
 }
 function servicePaths(platform2) {
-  const home = homedir3();
+  const home = homedir4();
   if (platform2 === "systemd") {
-    const unitDir2 = join26(home, ".config", "systemd", "user");
-    return { unitDir: unitDir2, unitFile: join26(unitDir2, "mink-daemon.service") };
+    const unitDir2 = join28(home, ".config", "systemd", "user");
+    return { unitDir: unitDir2, unitFile: join28(unitDir2, "mink-daemon.service") };
   }
-  const unitDir = join26(home, "Library", "LaunchAgents");
-  return { unitDir, unitFile: join26(unitDir, "com.mink.daemon.plist") };
+  const unitDir = join28(home, "Library", "LaunchAgents");
+  return { unitDir, unitFile: join28(unitDir, "com.mink.daemon.plist") };
 }
 function renderSystemdUnit(inv) {
   const execStart = [inv.executable, ...inv.args].join(" ");
@@ -10341,17 +10736,17 @@ function installService(options = {}) {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (existsSync30(paths.unitFile) && !options.force) {
+  if (existsSync32(paths.unitFile) && !options.force) {
     console.error(`[mink] unit file already exists: ${paths.unitFile}`);
     console.error("       re-run with --force to overwrite, or run `mink daemon uninstall` first");
     process.exit(1);
   }
   const inv = resolveServiceInvocation();
-  mkdirSync14(paths.unitDir, { recursive: true });
+  mkdirSync15(paths.unitDir, { recursive: true });
   if (platform2 === "systemd") {
     writeFileSync10(paths.unitFile, renderSystemdUnit(inv));
     try {
-      execSync7("systemctl --user daemon-reload", { stdio: "ignore" });
+      execSync8("systemctl --user daemon-reload", { stdio: "ignore" });
     } catch {}
     console.log(`[mink] wrote ${paths.unitFile}`);
     console.log("[mink] next steps:");
@@ -10374,24 +10769,24 @@ function uninstallService() {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (!existsSync30(paths.unitFile)) {
+  if (!existsSync32(paths.unitFile)) {
     console.log(`[mink] no unit file at ${paths.unitFile} \u2014 nothing to uninstall`);
     return;
   }
   if (platform2 === "systemd") {
     try {
-      execSync7("systemctl --user disable --now mink-daemon.service", {
+      execSync8("systemctl --user disable --now mink-daemon.service", {
         stdio: "ignore"
       });
     } catch {}
     unlinkSync5(paths.unitFile);
     try {
-      execSync7("systemctl --user daemon-reload", { stdio: "ignore" });
+      execSync8("systemctl --user daemon-reload", { stdio: "ignore" });
     } catch {}
     console.log(`[mink] removed ${paths.unitFile}`);
   } else {
     try {
-      execSync7(`launchctl unload -w ${paths.unitFile}`, { stdio: "ignore" });
+      execSync8(`launchctl unload -w ${paths.unitFile}`, { stdio: "ignore" });
     } catch {}
     unlinkSync5(paths.unitFile);
     console.log(`[mink] removed ${paths.unitFile}`);
@@ -10406,7 +10801,7 @@ var exports_daemon = {};
 __export(exports_daemon, {
   daemon: () => daemon
 });
-import { readFileSync as readFileSync24, existsSync as existsSync31 } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync33 } from "fs";
 async function daemon(cwd, args) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -10422,7 +10817,7 @@ async function daemon(cwd, args) {
       break;
     case "logs": {
       const logPath = schedulerLogPath();
-      if (!existsSync31(logPath)) {
+      if (!existsSync33(logPath)) {
         console.log("[mink] no log file found");
         return;
       }
@@ -10694,13 +11089,13 @@ function printValidKeys() {
   }
 }
 function readLineFromStdin() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const chunks = [];
     process.stdin.resume();
     process.stdin.setEncoding("utf-8");
     process.stdin.once("data", (data) => {
       process.stdin.pause();
-      resolve7(String(data).trim());
+      resolve8(String(data).trim());
     });
   });
 }
@@ -10775,7 +11170,7 @@ var exports_update = {};
 __export(exports_update, {
   update: () => update
 });
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 function parseArgs(args) {
   let dryRun = false;
   let project = null;
@@ -10833,7 +11228,7 @@ async function update(cwd, args) {
     }
     const backupName = createBackup(target.cwd);
     console.log(`  backup: ${backupName}`);
-    const settingsPath = resolve7(target.cwd, ".claude", "settings.json");
+    const settingsPath = resolve8(target.cwd, ".claude", "settings.json");
     mergeHooksIntoSettings(settingsPath, newHooks);
     console.log("  hooks: updated");
     const metaPath = projectMetaPath(target.cwd);
@@ -11009,7 +11404,7 @@ var init_restore = __esm(() => {
 
 // src/core/design-eval/server-detect.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join27 } from "path";
+import { join as join29 } from "path";
 async function probePort(port) {
   try {
     const controller = new AbortController;
@@ -11031,7 +11426,7 @@ async function findRunningServer(ports = DEFAULT_PROBE_PORTS) {
 }
 function detectDevCommand(cwd) {
   try {
-    const raw = readFileSync25(join27(cwd, "package.json"), "utf-8");
+    const raw = readFileSync25(join29(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts;
     if (!scripts || typeof scripts !== "object")
@@ -11051,10 +11446,10 @@ var init_server_detect = __esm(() => {
 });
 
 // src/core/design-eval/route-detect.ts
-import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync11 } from "fs";
-import { join as join28, relative as relative7, sep as sep2 } from "path";
+import { existsSync as existsSync34, readdirSync as readdirSync10, statSync as statSync11 } from "fs";
+import { join as join30, relative as relative7, sep as sep2 } from "path";
 function detectFramework(cwd) {
-  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync32(join28(cwd, `${name}.${ext}`))) || existsSync32(join28(cwd, name));
+  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync34(join30(cwd, `${name}.${ext}`))) || existsSync34(join30(cwd, name));
   if (has("next.config"))
     return "nextjs";
   if (has("svelte.config"))
@@ -11079,8 +11474,8 @@ function detectRoutes(cwd) {
 }
 function detectNextRoutes(cwd) {
   const routes = [];
-  const appDir = join28(cwd, "app");
-  if (existsSync32(appDir)) {
+  const appDir = join30(cwd, "app");
+  if (existsSync34(appDir)) {
     const pageFiles = findFiles(appDir, /^page\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative7(appDir, file);
@@ -11091,8 +11486,8 @@ function detectNextRoutes(cwd) {
       routes.push(route);
     }
   }
-  const pagesDir = join28(cwd, "pages");
-  if (existsSync32(pagesDir)) {
+  const pagesDir = join30(cwd, "pages");
+  if (existsSync34(pagesDir)) {
     const pageFiles = findFiles(pagesDir, /\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative7(pagesDir, file);
@@ -11111,8 +11506,8 @@ function detectNextRoutes(cwd) {
   return unique.length > 0 ? unique.sort() : ["/"];
 }
 function detectSvelteKitRoutes(cwd) {
-  const routesDir = join28(cwd, "src", "routes");
-  if (!existsSync32(routesDir))
+  const routesDir = join30(cwd, "src", "routes");
+  if (!existsSync34(routesDir))
     return ["/"];
   const routes = [];
   const pageFiles = findFiles(routesDir, /^\+page\.svelte$/);
@@ -11127,8 +11522,8 @@ function detectSvelteKitRoutes(cwd) {
   return routes.length > 0 ? routes.sort() : ["/"];
 }
 function detectNuxtRoutes(cwd) {
-  const pagesDir = join28(cwd, "pages");
-  if (!existsSync32(pagesDir))
+  const pagesDir = join30(cwd, "pages");
+  if (!existsSync34(pagesDir))
     return ["/"];
   const routes = [];
   const vueFiles = findFiles(pagesDir, /\.vue$/);
@@ -11154,7 +11549,7 @@ function findFiles(dir, pattern) {
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
-      const full = join28(current, entry);
+      const full = join30(current, entry);
       try {
         const stat2 = statSync11(full);
         if (stat2.isDirectory()) {
@@ -11182,11 +11577,11 @@ function __extends(d, b) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve8) {
-      resolve8(value);
+    return value instanceof P ? value : new P(function(resolve9) {
+      resolve9(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve8, reject) {
+  return new (P || (P = Promise))(function(resolve9, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -11202,7 +11597,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -11385,14 +11780,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve8, reject) {
-        v = o[n](v), settle(resolve8, reject, v.done, v.value);
+      return new Promise(function(resolve9, reject) {
+        v = o[n](v), settle(resolve9, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve8, reject, d, v) {
+  function settle(resolve9, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve8({ value: v2, done: d });
+      resolve9({ value: v2, done: d });
     }, reject);
   }
 }
@@ -11923,7 +12318,7 @@ function of() {
 }
 function lastValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve8, reject) {
+  return new Promise(function(resolve9, reject) {
     var _hasValue = false;
     var _value;
     source.subscribe({
@@ -11934,9 +12329,9 @@ function lastValueFrom(source, config22) {
       error: reject,
       complete: function() {
         if (_hasValue) {
-          resolve8(_value);
+          resolve9(_value);
         } else if (hasConfig) {
-          resolve8(config22.defaultValue);
+          resolve9(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -11946,16 +12341,16 @@ function lastValueFrom(source, config22) {
 }
 function firstValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve8, reject) {
+  return new Promise(function(resolve9, reject) {
     var subscriber = new SafeSubscriber({
       next: function(value) {
-        resolve8(value);
+        resolve9(value);
         subscriber.unsubscribe();
       },
       error: reject,
       complete: function() {
         if (hasConfig) {
-          resolve8(config22.defaultValue);
+          resolve9(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -13007,7 +13402,7 @@ var init_rxjs = __esm(() => {
     Observable2.prototype.forEach = function(next, promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve8, reject) {
+      return new promiseCtor(function(resolve9, reject) {
         var subscriber = new SafeSubscriber({
           next: function(value) {
             try {
@@ -13018,7 +13413,7 @@ var init_rxjs = __esm(() => {
             }
           },
           error: reject,
-          complete: resolve8
+          complete: resolve9
         });
         _this.subscribe(subscriber);
       });
@@ -13040,14 +13435,14 @@ var init_rxjs = __esm(() => {
     Observable2.prototype.toPromise = function(promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve8, reject) {
+      return new promiseCtor(function(resolve9, reject) {
         var value;
         _this.subscribe(function(x) {
           return value = x;
         }, function(err) {
           return reject(err);
         }, function() {
-          return resolve8(value);
+          return resolve9(value);
         });
       });
     };
@@ -14973,8 +15368,8 @@ class Deferred {
   #isRejected = false;
   #value;
   #resolve;
-  #taskPromise = new Promise((resolve8) => {
-    this.#resolve = resolve8;
+  #taskPromise = new Promise((resolve9) => {
+    this.#resolve = resolve9;
   });
   #timeoutId;
   #timeoutError;
@@ -15063,12 +15458,12 @@ var init_Mutex = __esm(() => {
       return new Mutex.Guard(this, onRelease);
     }
     release() {
-      const resolve8 = this.#acquirers.shift();
-      if (!resolve8) {
+      const resolve9 = this.#acquirers.shift();
+      if (!resolve9) {
         this.#locked = false;
         return;
       }
-      resolve8();
+      resolve9();
     }
   };
 });
@@ -16812,12 +17207,12 @@ var init_locators = __esm(() => {
       }
       return defer(() => {
         return from(handle.evaluate((element) => {
-          return new Promise((resolve8) => {
+          return new Promise((resolve9) => {
             window.requestAnimationFrame(() => {
               const rect1 = element.getBoundingClientRect();
               window.requestAnimationFrame(() => {
                 const rect2 = element.getBoundingClientRect();
-                resolve8([
+                resolve9([
                   {
                     x: rect1.x,
                     y: rect1.y,
@@ -18108,9 +18503,9 @@ var init_ElementHandle = __esm(() => {
           const handle = await this.#asSVGElementHandle();
           const target = __addDisposableResource6(env_5, handle && await handle.#getOwnerSVGElement(), false);
           return await (target ?? this).evaluate(async (element, threshold) => {
-            const visibleRatio = await new Promise((resolve8) => {
+            const visibleRatio = await new Promise((resolve9) => {
               const observer = new IntersectionObserver((entries) => {
-                resolve8(entries[0].intersectionRatio);
+                resolve9(entries[0].intersectionRatio);
                 observer.disconnect();
               });
               observer.observe(element);
@@ -18504,7 +18899,7 @@ var init_Frame = __esm(() => {
         }
         type = type ?? "text/javascript";
         return await this.mainRealm().transferHandle(await this.isolatedRealm().evaluateHandle(async ({ url, id, type: type2, content: content2 }) => {
-          return await new Promise((resolve8, reject) => {
+          return await new Promise((resolve9, reject) => {
             const script = document.createElement("script");
             script.type = type2;
             script.text = content2;
@@ -18517,12 +18912,12 @@ var init_Frame = __esm(() => {
             if (url) {
               script.src = url;
               script.addEventListener("load", () => {
-                resolve8(script);
+                resolve9(script);
               }, { once: true });
               document.head.appendChild(script);
             } else {
               document.head.appendChild(script);
-              resolve8(script);
+              resolve9(script);
             }
           });
         }, { ...options, type, content }));
@@ -18539,7 +18934,7 @@ var init_Frame = __esm(() => {
           options.content = content;
         }
         return await this.mainRealm().transferHandle(await this.isolatedRealm().evaluateHandle(async ({ url, content: content2 }) => {
-          return await new Promise((resolve8, reject) => {
+          return await new Promise((resolve9, reject) => {
             let element;
             if (!url) {
               element = document.createElement("style");
@@ -18551,7 +18946,7 @@ var init_Frame = __esm(() => {
               element = link;
             }
             element.addEventListener("load", () => {
-              resolve8(element);
+              resolve9(element);
             }, { once: true });
             element.addEventListener("error", (event) => {
               reject(new Error(event.message ?? "Could not load style"));
@@ -19405,9 +19800,9 @@ var init_Page = __esm(() => {
         ++this.#screencastSessionCount;
         if (!this.#startScreencastPromise) {
           this.#startScreencastPromise = this.mainFrame().client.send("Page.startScreencast", { format: "png" }).then(() => {
-            return new Promise((resolve8) => {
+            return new Promise((resolve9) => {
               return this.mainFrame().client.once("Page.screencastFrame", () => {
-                return resolve8();
+                return resolve9();
               });
             });
           });
@@ -22065,11 +22460,11 @@ function addPageBinding(type, name, prefix) {
           return value instanceof Node;
         })
       }));
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         callPuppeteer.callbacks.set(seq, {
           resolve(value) {
             callPuppeteer.args.delete(seq);
-            resolve8(value);
+            resolve9(value);
           },
           reject(value) {
             callPuppeteer.args.delete(seq);
@@ -25532,8 +25927,8 @@ var init_Input2 = __esm(() => {
       if (typeof delay === "number") {
         await Promise.all(actions);
         actions.length = 0;
-        await new Promise((resolve8) => {
-          setTimeout(resolve8, delay);
+        await new Promise((resolve9) => {
+          setTimeout(resolve9, delay);
         });
       }
       actions.push(this.up({ ...options, clickCount }));
@@ -25553,9 +25948,9 @@ var init_Input2 = __esm(() => {
       });
     }
     async drag(start, target) {
-      const promise = new Promise((resolve8) => {
+      const promise = new Promise((resolve9) => {
         this.#client.once("Input.dragIntercepted", (event) => {
-          return resolve8(event.data);
+          return resolve9(event.data);
         });
       });
       await this.move(start.x, start.y);
@@ -25596,8 +25991,8 @@ var init_Input2 = __esm(() => {
       await this.dragEnter(target, data);
       await this.dragOver(target, data);
       if (delay) {
-        await new Promise((resolve8) => {
-          return setTimeout(resolve8, delay);
+        await new Promise((resolve9) => {
+          return setTimeout(resolve9, delay);
         });
       }
       await this.drop(target, data);
@@ -26409,9 +26804,9 @@ var init_Page2 = __esm(() => {
     async captureHeapSnapshot(options) {
       const { createWriteStream } = environment.value.fs;
       const stream = createWriteStream(options.path);
-      const streamPromise = new Promise((resolve8, reject) => {
+      const streamPromise = new Promise((resolve9, reject) => {
         stream.on("error", reject);
-        stream.on("finish", resolve8);
+        stream.on("finish", resolve9);
       });
       const client = this.#primaryTargetClient;
       await client.send("HeapProfiler.enable");
@@ -27924,10 +28319,10 @@ __export(exports_BrowserWebSocketTransport, {
 
 class BrowserWebSocketTransport {
   static create(url) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const ws = new WebSocket(url);
       ws.addEventListener("open", () => {
-        return resolve8(new BrowserWebSocketTransport(ws));
+        return resolve9(new BrowserWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -30761,11 +31156,11 @@ var require_BrowsingContextProcessor = __commonJS((exports) => {
       }
       const parentCdpClient = context2.cdpTarget.parentCdpClient;
       try {
-        const detachedFromTargetPromise = new Promise((resolve8) => {
+        const detachedFromTargetPromise = new Promise((resolve9) => {
           const onContextDestroyed = (event) => {
             if (event.targetId === params.context) {
               parentCdpClient.off("Target.detachedFromTarget", onContextDestroyed);
-              resolve8();
+              resolve9();
             }
           };
           parentCdpClient.on("Target.detachedFromTarget", onContextDestroyed);
@@ -32085,7 +32480,7 @@ var require_ActionDispatcher = __commonJS((exports) => {
         }
       }
       const promises = [
-        new Promise((resolve8) => setTimeout(resolve8, this.#tickDuration))
+        new Promise((resolve9) => setTimeout(resolve9, this.#tickDuration))
       ];
       for (const option of options) {
         promises.push(this.#dispatchAction(option));
@@ -32684,8 +33079,8 @@ var require_Mutex = __commonJS((exports) => {
     acquire() {
       const state = { resolved: false };
       if (this.#locked) {
-        return new Promise((resolve8) => {
-          this.#acquirers.push(() => resolve8(this.#release.bind(this, state)));
+        return new Promise((resolve9) => {
+          this.#acquirers.push(() => resolve9(this.#release.bind(this, state)));
         });
       }
       this.#locked = true;
@@ -32696,12 +33091,12 @@ var require_Mutex = __commonJS((exports) => {
         throw new Error("Cannot release more than once.");
       }
       state.resolved = true;
-      const resolve8 = this.#acquirers.shift();
-      if (!resolve8) {
+      const resolve9 = this.#acquirers.shift();
+      if (!resolve9) {
         this.#locked = false;
         return;
       }
-      resolve8();
+      resolve9();
     }
     async run(action) {
       const release = await this.acquire();
@@ -33828,8 +34223,8 @@ var require_ChannelProxy = __commonJS((exports) => {
         let queueNonEmptyResolver = null;
         return {
           async getMessage() {
-            const onMessage = queue.length > 0 ? Promise.resolve() : new Promise((resolve8) => {
-              queueNonEmptyResolver = resolve8;
+            const onMessage = queue.length > 0 ? Promise.resolve() : new Promise((resolve9) => {
+              queueNonEmptyResolver = resolve9;
             });
             await onMessage;
             return queue.shift();
@@ -33915,7 +34310,7 @@ var require_ChannelProxy = __commonJS((exports) => {
         functionDeclaration: String((id) => {
           const w = window;
           if (w[id] === undefined) {
-            return new Promise((resolve8) => w[id] = resolve8);
+            return new Promise((resolve9) => w[id] = resolve9);
           }
           const channelProxy = w[id];
           delete w[id];
@@ -35266,8 +35661,8 @@ var require_Deferred = __commonJS((exports) => {
       return this.#result;
     }
     constructor() {
-      this.#promise = new Promise((resolve8, reject) => {
-        this.#resolve = resolve8;
+      this.#promise = new Promise((resolve9, reject) => {
+        this.#resolve = resolve9;
         this.#reject = reject;
       });
       this.#promise.catch((_error) => {});
@@ -39592,11 +39987,11 @@ var require_BrowsingContextStorage = __commonJS((exports) => {
       if (this.#contexts.has(browsingContextId)) {
         return Promise.resolve(this.getContext(browsingContextId));
       }
-      return new Promise((resolve8) => {
+      return new Promise((resolve9) => {
         const listener = (event) => {
           if (event.browsingContext.id === browsingContextId) {
             this.#eventEmitter.off("added", listener);
-            resolve8(event.browsingContext);
+            resolve9(event.browsingContext);
           }
         };
         this.#eventEmitter.on("added", listener);
@@ -43092,8 +43487,8 @@ var init_ExposedFunction = __esm(() => {
       const functionDeclaration = stringifyFunction(interpolateFunction((callback) => {
         Object.assign(globalThis, {
           [PLACEHOLDER("name")]: function(...args) {
-            return new Promise((resolve8, reject) => {
-              callback([resolve8, reject, args]);
+            return new Promise((resolve9, reject) => {
+              callback([resolve9, reject, args]);
             });
           }
         });
@@ -43181,8 +43576,8 @@ var init_ExposedFunction = __esm(() => {
           return;
         }
         try {
-          await dataHandle.evaluate(([resolve8], result2) => {
-            resolve8(result2);
+          await dataHandle.evaluate(([resolve9], result2) => {
+            resolve9(result2);
           }, result);
         } catch (error) {
           debugError(error);
@@ -47609,7 +48004,7 @@ import NodeWebSocket from "ws";
 
 class NodeWebSocketTransport {
   static create(url, headers) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const ws = new NodeWebSocket(url, [], {
         followRedirects: true,
         perMessageDeflate: false,
@@ -47621,7 +48016,7 @@ class NodeWebSocketTransport {
         }
       });
       ws.addEventListener("open", () => {
-        return resolve8(new NodeWebSocketTransport(ws));
+        return resolve9(new NodeWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -50511,8 +50906,8 @@ var require_helpers = __commonJS((exports) => {
   function req(url, opts = {}) {
     const href = typeof url === "string" ? url : url.href;
     const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
-    const promise = new Promise((resolve8, reject) => {
-      req2.once("response", resolve8).once("error", reject).end();
+    const promise = new Promise((resolve9, reject) => {
+      req2.once("response", resolve9).once("error", reject).end();
     });
     req2.then = promise.then.bind(promise);
     return req2;
@@ -50883,7 +51278,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
   var debug_1 = __importDefault(require_src());
   var debug2 = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
   function parseProxyResponse(socket) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let buffersLength = 0;
       const buffers = [];
       function read() {
@@ -50952,7 +51347,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
         }
         debug2("got proxy server response: %o %o", firstLine, headers);
         cleanup();
-        resolve8({
+        resolve9({
           connect: {
             statusCode,
             statusText,
@@ -53056,11 +53451,11 @@ var require_receivebuffer = __commonJS((exports) => {
 var require_socksclient = __commonJS((exports) => {
   var __awaiter2 = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
     function adopt(value) {
-      return value instanceof P ? value : new P(function(resolve8) {
-        resolve8(value);
+      return value instanceof P ? value : new P(function(resolve9) {
+        resolve9(value);
       });
     }
-    return new (P || (P = Promise))(function(resolve8, reject) {
+    return new (P || (P = Promise))(function(resolve9, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -53076,7 +53471,7 @@ var require_socksclient = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -53103,13 +53498,13 @@ var require_socksclient = __commonJS((exports) => {
       this.setState(constants_1.SocksClientState.Created);
     }
     static createConnection(options, callback) {
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         try {
           (0, helpers_1.validateSocksClientOptions)(options, ["connect"]);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve8(err);
+            return resolve9(err);
           } else {
             return reject(err);
           }
@@ -53120,16 +53515,16 @@ var require_socksclient = __commonJS((exports) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(null, info);
-            resolve8(info);
+            resolve9(info);
           } else {
-            resolve8(info);
+            resolve9(info);
           }
         });
         client.once("error", (err) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(err);
-            resolve8(err);
+            resolve9(err);
           } else {
             reject(err);
           }
@@ -53137,13 +53532,13 @@ var require_socksclient = __commonJS((exports) => {
       });
     }
     static createConnectionChain(options, callback) {
-      return new Promise((resolve8, reject) => __awaiter2(this, undefined, undefined, function* () {
+      return new Promise((resolve9, reject) => __awaiter2(this, undefined, undefined, function* () {
         try {
           (0, helpers_1.validateSocksClientChainOptions)(options);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve8(err);
+            return resolve9(err);
           } else {
             return reject(err);
           }
@@ -53169,14 +53564,14 @@ var require_socksclient = __commonJS((exports) => {
           }
           if (typeof callback === "function") {
             callback(null, { socket: sock });
-            resolve8({ socket: sock });
+            resolve9({ socket: sock });
           } else {
-            resolve8({ socket: sock });
+            resolve9({ socket: sock });
           }
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            resolve8(err);
+            resolve9(err);
           } else {
             reject(err);
           }
@@ -53776,12 +54171,12 @@ var require_dist4 = __commonJS((exports) => {
       let { host } = opts;
       const { port, lookup: lookupFn = dns.lookup } = opts;
       if (shouldLookup) {
-        host = await new Promise((resolve8, reject) => {
+        host = await new Promise((resolve9, reject) => {
           lookupFn(host, {}, (err, res) => {
             if (err) {
               reject(err);
             } else {
-              resolve8(res);
+              resolve9(res);
             }
           });
         });
@@ -54788,7 +55183,7 @@ var require_netUtils = __commonJS((exports) => {
     return `${socket.remoteAddress}:${socket.remotePort}`;
   }
   function upgradeSocket(socket, options) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const tlsOptions = Object.assign({}, options, {
         socket
       });
@@ -54798,7 +55193,7 @@ var require_netUtils = __commonJS((exports) => {
           reject(tlsSocket.authorizationError);
         } else {
           tlsSocket.removeAllListeners("error");
-          resolve8(tlsSocket);
+          resolve9(tlsSocket);
         }
       }).once("error", (error) => {
         reject(error);
@@ -54890,7 +55285,7 @@ var require_transfer = __commonJS((exports) => {
     };
   }
   function connectForPassiveTransfer(host, port, ftp) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       let socket = ftp._newSocket();
       const handleConnErr = function(err) {
         err.message = "Can't open data connection in passive mode: " + err.message;
@@ -54913,7 +55308,7 @@ var require_transfer = __commonJS((exports) => {
         socket.removeListener("error", handleConnErr);
         socket.removeListener("timeout", handleTimeout);
         ftp.dataSocket = socket;
-        resolve8();
+        resolve9();
       });
     });
   }
@@ -56991,7 +57386,7 @@ var require_util2 = __commonJS((exports) => {
     return path;
   }
   exports.normalize = normalize2;
-  function join29(aRoot, aPath) {
+  function join31(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -57023,7 +57418,7 @@ var require_util2 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join29;
+  exports.join = join31;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -57196,7 +57591,7 @@ var require_util2 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join29(urlGenerate(parsed), sourceURL);
+      sourceURL = join31(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -58928,7 +59323,7 @@ var require_escodegen = __commonJS((exports) => {
     function noEmptySpace() {
       return space ? space : " ";
     }
-    function join29(left, right) {
+    function join31(left, right) {
       var leftSource, rightSource, leftCharCode, rightCharCode;
       leftSource = toSourceNodeWhenNeeded(left).toString();
       if (leftSource.length === 0) {
@@ -59269,8 +59664,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
         }
-        result = join29(result, operator);
-        result = [join29(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
+        result = join31(result, operator);
+        result = [join31(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
       });
       result.push(this.maybeBlock(stmt.body, flags));
       return result;
@@ -59408,11 +59803,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (stmt.id) {
-          result = join29(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+          result = join31(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
         }
         if (stmt.superClass) {
-          fragment = join29("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-          result = join29(result, fragment);
+          fragment = join31("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+          result = join31(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -59425,9 +59820,9 @@ var require_escodegen = __commonJS((exports) => {
         return escapeDirective(stmt.directive) + this.semicolon(flags);
       },
       DoWhileStatement: function(stmt, flags) {
-        var result = join29("do", this.maybeBlock(stmt.body, S_TFFF));
+        var result = join31("do", this.maybeBlock(stmt.body, S_TFFF));
         result = this.maybeBlockSuffix(stmt.body, result);
-        return join29(result, [
+        return join31(result, [
           "while" + space + "(",
           this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
           ")" + this.semicolon(flags)
@@ -59463,11 +59858,11 @@ var require_escodegen = __commonJS((exports) => {
       ExportDefaultDeclaration: function(stmt, flags) {
         var result = ["export"], bodyFlags;
         bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-        result = join29(result, "default");
+        result = join31(result, "default");
         if (isStatement(stmt.declaration)) {
-          result = join29(result, this.generateStatement(stmt.declaration, bodyFlags));
+          result = join31(result, this.generateStatement(stmt.declaration, bodyFlags));
         } else {
-          result = join29(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+          result = join31(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
         }
         return result;
       },
@@ -59475,15 +59870,15 @@ var require_escodegen = __commonJS((exports) => {
         var result = ["export"], bodyFlags, that = this;
         bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
         if (stmt.declaration) {
-          return join29(result, this.generateStatement(stmt.declaration, bodyFlags));
+          return join31(result, this.generateStatement(stmt.declaration, bodyFlags));
         }
         if (stmt.specifiers) {
           if (stmt.specifiers.length === 0) {
-            result = join29(result, "{" + space + "}");
+            result = join31(result, "{" + space + "}");
           } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-            result = join29(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+            result = join31(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
           } else {
-            result = join29(result, "{");
+            result = join31(result, "{");
             withIndent(function(indent2) {
               var i, iz;
               result.push(newline);
@@ -59501,7 +59896,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(base + "}");
           }
           if (stmt.source) {
-            result = join29(result, [
+            result = join31(result, [
               "from" + space,
               this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
               this.semicolon(flags)
@@ -59585,7 +59980,7 @@ var require_escodegen = __commonJS((exports) => {
         ];
         cursor = 0;
         if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-          result = join29(result, [
+          result = join31(result, [
             this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
           ]);
           ++cursor;
@@ -59595,7 +59990,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(",");
           }
           if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-            result = join29(result, [
+            result = join31(result, [
               space,
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
@@ -59624,7 +60019,7 @@ var require_escodegen = __commonJS((exports) => {
             }
           }
         }
-        result = join29(result, [
+        result = join31(result, [
           "from" + space,
           this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
           this.semicolon(flags)
@@ -59678,7 +60073,7 @@ var require_escodegen = __commonJS((exports) => {
         return result;
       },
       ThrowStatement: function(stmt, flags) {
-        return [join29("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+        return [join31("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
       },
       TryStatement: function(stmt, flags) {
         var result, i, iz, guardedHandlers;
@@ -59686,7 +60081,7 @@ var require_escodegen = __commonJS((exports) => {
         result = this.maybeBlockSuffix(stmt.block, result);
         if (stmt.handlers) {
           for (i = 0, iz = stmt.handlers.length;i < iz; ++i) {
-            result = join29(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+            result = join31(result, this.generateStatement(stmt.handlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
             }
@@ -59694,7 +60089,7 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           guardedHandlers = stmt.guardedHandlers || [];
           for (i = 0, iz = guardedHandlers.length;i < iz; ++i) {
-            result = join29(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+            result = join31(result, this.generateStatement(guardedHandlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
             }
@@ -59702,13 +60097,13 @@ var require_escodegen = __commonJS((exports) => {
           if (stmt.handler) {
             if (Array.isArray(stmt.handler)) {
               for (i = 0, iz = stmt.handler.length;i < iz; ++i) {
-                result = join29(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                result = join31(result, this.generateStatement(stmt.handler[i], S_TFFF));
                 if (stmt.finalizer || i + 1 !== iz) {
                   result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                 }
               }
             } else {
-              result = join29(result, this.generateStatement(stmt.handler, S_TFFF));
+              result = join31(result, this.generateStatement(stmt.handler, S_TFFF));
               if (stmt.finalizer) {
                 result = this.maybeBlockSuffix(stmt.handler.body, result);
               }
@@ -59716,7 +60111,7 @@ var require_escodegen = __commonJS((exports) => {
           }
         }
         if (stmt.finalizer) {
-          result = join29(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+          result = join31(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
         }
         return result;
       },
@@ -59750,7 +60145,7 @@ var require_escodegen = __commonJS((exports) => {
         withIndent(function() {
           if (stmt.test) {
             result = [
-              join29("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+              join31("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
               ":"
             ];
           } else {
@@ -59798,9 +60193,9 @@ var require_escodegen = __commonJS((exports) => {
           result.push(this.maybeBlock(stmt.consequent, S_TFFF));
           result = this.maybeBlockSuffix(stmt.consequent, result);
           if (stmt.alternate.type === Syntax.IfStatement) {
-            result = join29(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+            result = join31(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
           } else {
-            result = join29(result, join29("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+            result = join31(result, join31("else", this.maybeBlock(stmt.alternate, bodyFlags)));
           }
         } else {
           result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -59902,7 +60297,7 @@ var require_escodegen = __commonJS((exports) => {
       },
       ReturnStatement: function(stmt, flags) {
         if (stmt.argument) {
-          return [join29("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+          return [join31("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
         }
         return ["return" + this.semicolon(flags)];
       },
@@ -59984,14 +60379,14 @@ var require_escodegen = __commonJS((exports) => {
         if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
           result = [fragment, noEmptySpace(), expr.operator];
         } else {
-          result = join29(fragment, expr.operator);
+          result = join31(fragment, expr.operator);
         }
         fragment = this.generateExpression(expr.right, rightPrecedence, flags);
         if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") {
           result.push(noEmptySpace());
           result.push(fragment);
         } else {
-          result = join29(result, fragment);
+          result = join31(result, fragment);
         }
         if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
           return ["(", result, ")"];
@@ -60031,7 +60426,7 @@ var require_escodegen = __commonJS((exports) => {
         var result, length, i, iz, itemFlags;
         length = expr["arguments"].length;
         itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF;
-        result = join29("new", this.generateExpression(expr.callee, Precedence.New, itemFlags));
+        result = join31("new", this.generateExpression(expr.callee, Precedence.New, itemFlags));
         if (!(flags & F_ALLOW_UNPARATH_NEW) || parentheses || length > 0) {
           result.push("(");
           for (i = 0, iz = length;i < iz; ++i) {
@@ -60078,11 +60473,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment, rightCharCode, leftSource, leftCharCode;
         fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
         if (space === "") {
-          result = join29(expr.operator, fragment);
+          result = join31(expr.operator, fragment);
         } else {
           result = [expr.operator];
           if (expr.operator.length > 2) {
-            result = join29(result, fragment);
+            result = join31(result, fragment);
           } else {
             leftSource = toSourceNodeWhenNeeded(result).toString();
             leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -60105,12 +60500,12 @@ var require_escodegen = __commonJS((exports) => {
           result = "yield";
         }
         if (expr.argument) {
-          result = join29(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
+          result = join31(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
         }
         return parenthesize(result, Precedence.Yield, precedence);
       },
       AwaitExpression: function(expr, precedence, flags) {
-        var result = join29(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
+        var result = join31(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
         return parenthesize(result, Precedence.Await, precedence);
       },
       UpdateExpression: function(expr, precedence, flags) {
@@ -60182,11 +60577,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (expr.id) {
-          result = join29(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+          result = join31(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
         }
         if (expr.superClass) {
-          fragment = join29("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-          result = join29(result, fragment);
+          fragment = join31("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+          result = join31(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(expr.body, S_TFFT));
@@ -60201,7 +60596,7 @@ var require_escodegen = __commonJS((exports) => {
         }
         if (expr.kind === "get" || expr.kind === "set") {
           fragment = [
-            join29(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+            join31(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
             this.generateFunctionBody(expr.value)
           ];
         } else {
@@ -60211,7 +60606,7 @@ var require_escodegen = __commonJS((exports) => {
             this.generateFunctionBody(expr.value)
           ];
         }
-        return join29(result, fragment);
+        return join31(result, fragment);
       },
       Property: function(expr, precedence, flags) {
         if (expr.kind === "get" || expr.kind === "set") {
@@ -60405,7 +60800,7 @@ var require_escodegen = __commonJS((exports) => {
             for (i = 0, iz = expr.blocks.length;i < iz; ++i) {
               fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT);
               if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
-                result = join29(result, fragment);
+                result = join31(result, fragment);
               } else {
                 result.push(fragment);
               }
@@ -60413,13 +60808,13 @@ var require_escodegen = __commonJS((exports) => {
           });
         }
         if (expr.filter) {
-          result = join29(result, "if" + space);
+          result = join31(result, "if" + space);
           fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-          result = join29(result, ["(", fragment, ")"]);
+          result = join31(result, ["(", fragment, ")"]);
         }
         if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
           fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-          result = join29(result, fragment);
+          result = join31(result, fragment);
         }
         result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
         return result;
@@ -60435,8 +60830,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
         }
-        fragment = join29(fragment, expr.of ? "of" : "in");
-        fragment = join29(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+        fragment = join31(fragment, expr.of ? "of" : "in");
+        fragment = join31(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
         return ["for" + space + "(", fragment, ")"];
       },
       SpreadElement: function(expr, precedence, flags) {
@@ -66924,11 +67319,11 @@ var require_tslib = __commonJS((exports, module) => {
     };
     __awaiter2 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve8) {
-          resolve8(value);
+        return value instanceof P ? value : new P(function(resolve9) {
+          resolve9(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve8, reject) {
+      return new (P || (P = Promise))(function(resolve9, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -66944,7 +67339,7 @@ var require_tslib = __commonJS((exports, module) => {
           }
         }
         function step(result) {
-          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -67173,14 +67568,14 @@ var require_tslib = __commonJS((exports, module) => {
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve8, reject) {
-            v = o[n](v), settle(resolve8, reject, v.done, v.value);
+          return new Promise(function(resolve9, reject) {
+            v = o[n](v), settle(resolve9, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve8, reject, d, v) {
+      function settle(resolve9, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve8({ value: v2, done: d });
+          resolve9({ value: v2, done: d });
         }, reject);
       }
     };
@@ -70419,12 +70814,12 @@ var require_util3 = __commonJS((exports) => {
   exports.isGMT = exports.dnsLookup = undefined;
   var dns_1 = __require("dns");
   function dnsLookup(host, opts) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       (0, dns_1.lookup)(host, opts, (err, res) => {
         if (err) {
           reject(err);
         } else {
-          resolve8(res);
+          resolve9(res);
         }
       });
     });
@@ -70998,10 +71393,10 @@ var require_myIpAddress = __commonJS((exports) => {
   var ip_1 = require_ip();
   var net_1 = __importDefault(__require("net"));
   async function myIpAddress() {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const socket = net_1.default.connect({ host: "8.8.8.8", port: 53 });
       const onError = () => {
-        resolve8(ip_1.ip.address());
+        resolve9(ip_1.ip.address());
       };
       socket.once("error", onError);
       socket.once("connect", () => {
@@ -71009,9 +71404,9 @@ var require_myIpAddress = __commonJS((exports) => {
         const addr = socket.address();
         socket.destroy();
         if (typeof addr === "string") {
-          resolve8(addr);
+          resolve9(addr);
         } else if (addr.address) {
-          resolve8(addr.address);
+          resolve9(addr.address);
         } else {
           reject(new Error("Expected a `string`"));
         }
@@ -71525,8 +71920,8 @@ var require_deferred_promise = __commonJS((exports) => {
       this.context = args.context;
       this.owner = args.context.runtime;
       this.handle = args.promiseHandle;
-      this.settled = new Promise((resolve8) => {
-        this.onSettled = resolve8;
+      this.settled = new Promise((resolve9) => {
+        this.onSettled = resolve9;
       });
       this.resolveHandle = args.resolveHandle;
       this.rejectHandle = args.rejectHandle;
@@ -71918,13 +72313,13 @@ var require_context = __commonJS((exports) => {
       if (vmResolveResult.error) {
         return Promise.resolve(vmResolveResult);
       }
-      return new Promise((resolve8) => {
+      return new Promise((resolve9) => {
         lifetime_1.Scope.withScope((scope) => {
           const resolveHandle = scope.manage(this.newFunction("resolve", (value) => {
-            resolve8({ value: value && value.dup() });
+            resolve9({ value: value && value.dup() });
           }));
           const rejectHandle = scope.manage(this.newFunction("reject", (error) => {
-            resolve8({ error: error && error.dup() });
+            resolve9({ error: error && error.dup() });
           }));
           const promiseHandle = scope.manage(vmResolveResult.value);
           const promiseThenHandle = scope.manage(this.getProp(promiseHandle, "then"));
@@ -74038,13 +74433,13 @@ import * as http from "http";
 import * as https from "https";
 import { URL as URL2, urlToHttpOptions } from "url";
 function headHttpRequest(url) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const request3 = httpRequest(url, "HEAD", (response) => {
       response.resume();
-      resolve8(response.statusCode === 200);
+      resolve9(response.statusCode === 200);
     }, false);
     request3.on("error", () => {
-      resolve8(false);
+      resolve9(false);
     });
   });
 }
@@ -74072,7 +74467,7 @@ function httpRequest(url, method, response, keepAlive = true) {
   return request3;
 }
 function downloadFile(url, destinationPath, progressCallback) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let downloadedBytes = 0;
     let totalBytes = 0;
     function onData(chunk) {
@@ -74088,7 +74483,7 @@ function downloadFile(url, destinationPath, progressCallback) {
       }
       const file = createWriteStream(destinationPath);
       file.on("close", () => {
-        return resolve8();
+        return resolve9();
       });
       file.on("error", (error) => {
         return reject(error);
@@ -74113,7 +74508,7 @@ async function getJSON(url) {
   }
 }
 function getText(url) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const request3 = httpRequest(url, "GET", (response) => {
       let data = "";
       if (response.statusCode && response.statusCode >= 400) {
@@ -74124,7 +74519,7 @@ function getText(url) {
       });
       response.on("end", () => {
         try {
-          return resolve8(String(data));
+          return resolve9(String(data));
         } catch {
           return reject(new Error(`Failed to read text response from ${url}`));
         }
@@ -74141,7 +74536,7 @@ var init_httpUtil = __esm(() => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 import os from "os";
 import path from "path";
 function folder(platform2) {
@@ -74231,7 +74626,7 @@ function getChromeWindowsLocation(channel2, locationsPrefixes) {
 }
 function getWslVariable(variable) {
   try {
-    const result = execSync8(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
+    const result = execSync9(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf-8"
     }).trim();
@@ -74242,7 +74637,7 @@ function getWslVariable(variable) {
   return;
 }
 function getWslLocation(channel2) {
-  const wslVersion = execSync8("wslinfo --version", {
+  const wslVersion = execSync9("wslinfo --version", {
     stdio: ["ignore", "pipe", "ignore"],
     encoding: "utf-8"
   }).trim();
@@ -74258,7 +74653,7 @@ function getWslLocation(channel2) {
   }
   const windowsPath = getChromeWindowsLocation(channel2, wslPrefixes);
   return windowsPath.map((path2) => {
-    return execSync8(`wslpath "${path2}"`).toString().trim();
+    return execSync9(`wslpath "${path2}"`).toString().trim();
   });
 }
 function getChromeLinuxOrWslLocation(channel2) {
@@ -75345,7 +75740,7 @@ class Process {
     if (opts.onExit) {
       this.#onExitHook = opts.onExit;
     }
-    this.#browserProcessExiting = new Promise((resolve8, reject) => {
+    this.#browserProcessExiting = new Promise((resolve9, reject) => {
       this.#browserProcess.once("exit", async () => {
         debugLaunch(`Browser process ${this.#browserProcess.pid} onExit`);
         this.#clearListeners();
@@ -75356,7 +75751,7 @@ class Process {
           reject(err);
           return;
         }
-        resolve8();
+        resolve9();
       });
     });
   }
@@ -75466,7 +75861,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
     return [...this.#logs];
   }
   waitForLineOutput(regex, timeout2 = 0) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const onClose = (errorOrCode) => {
         cleanup();
         reject(new Error([
@@ -75504,7 +75899,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
           return;
         }
         cleanup();
-        resolve8(match[1]);
+        resolve9(match[1]);
       }
     });
   }
@@ -76034,7 +76429,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     let stream;
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -76046,7 +76441,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve8();
+        resolve9();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -77407,7 +77802,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       debug4("opening", this.zipPath, "with opts", this.opts);
       this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
       this.canceled = false;
-      return new Promise((resolve8, reject) => {
+      return new Promise((resolve9, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -77416,7 +77811,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug4("zip extraction complete");
-            resolve8();
+            resolve9();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -78758,8 +79153,8 @@ var require_streamx = __commonJS((exports, module) => {
           return this;
         },
         next() {
-          return new Promise(function(resolve8, reject) {
-            promiseResolve = resolve8;
+          return new Promise(function(resolve9, reject) {
+            promiseResolve = resolve9;
             promiseReject = reject;
             const data = stream.read();
             if (data !== null)
@@ -78796,14 +79191,14 @@ var require_streamx = __commonJS((exports, module) => {
       }
       function destroy(err) {
         stream.destroy(err);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           if (stream._duplexState & DESTROYED)
-            return resolve8({ value: undefined, done: true });
+            return resolve9({ value: undefined, done: true });
           stream.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve8({ value: undefined, done: true });
+              resolve9({ value: undefined, done: true });
           });
         });
       }
@@ -78855,8 +79250,8 @@ var require_streamx = __commonJS((exports, module) => {
         return Promise.resolve(true);
       if (state.drains === null)
         state.drains = [];
-      return new Promise((resolve8) => {
-        state.drains.push({ writes, resolve: resolve8 });
+      return new Promise((resolve9) => {
+        state.drains.push({ writes, resolve: resolve9 });
       });
     }
     write(data) {
@@ -78970,11 +79365,11 @@ var require_streamx = __commonJS((exports, module) => {
     cb(null);
   }
   function pipelinePromise(...streams) {
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       return pipeline(...streams, (err) => {
         if (err)
           return reject(err);
-        resolve8();
+        resolve9();
       });
     });
   }
@@ -79688,16 +80083,16 @@ var require_extract = __commonJS((exports, module) => {
         entryCallback = null;
         cb(err);
       }
-      function onnext(resolve8, reject) {
+      function onnext(resolve9, reject) {
         if (error) {
           return reject(error);
         }
         if (entryStream) {
-          resolve8({ value: entryStream, done: false });
+          resolve9({ value: entryStream, done: false });
           entryStream = null;
           return;
         }
-        promiseResolve = resolve8;
+        promiseResolve = resolve9;
         promiseReject = reject;
         consumeCallback(null);
         if (extract._finished && promiseResolve) {
@@ -79728,14 +80123,14 @@ var require_extract = __commonJS((exports, module) => {
       function destroy(err) {
         extract.destroy(err);
         consumeCallback(err);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           if (extract.destroyed)
-            return resolve8({ value: undefined, done: true });
+            return resolve9({ value: undefined, done: true });
           extract.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve8({ value: undefined, done: true });
+              resolve9({ value: undefined, done: true });
           });
         });
       }
@@ -80533,7 +80928,7 @@ var init_fileUtil = __esm(() => {
 // node_modules/@puppeteer/browsers/lib/esm/install.js
 import assert2 from "assert";
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync26 } from "fs";
 import { mkdir as mkdir2, unlink } from "fs/promises";
 import os5 from "os";
 import path8 from "path";
@@ -80586,7 +80981,7 @@ async function installWithProviders(options) {
         continue;
       }
       debugInstall(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync33(browserRoot)) {
+      if (!existsSync35(browserRoot)) {
         await mkdir2(browserRoot, { recursive: true });
       }
       return await installUrl(url, options, provider);
@@ -80619,7 +81014,7 @@ async function installDeps(installedBrowser) {
     return;
   }
   const depsPath = path8.join(path8.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync33(depsPath)) {
+  if (!existsSync35(depsPath)) {
     debugInstall(`deb.deps file was not found at ${depsPath}`);
     return;
   }
@@ -80661,11 +81056,11 @@ async function installUrl(url, options, provider) {
   const cache = new Cache(options.cacheDir);
   const browserRoot = cache.browserRoot(options.browser);
   const archivePath = path8.join(browserRoot, `${options.buildId}-${fileName}`);
-  if (!existsSync33(browserRoot)) {
+  if (!existsSync35(browserRoot)) {
     await mkdir2(browserRoot, { recursive: true });
   }
   if (!options.unpack) {
-    if (existsSync33(archivePath)) {
+    if (existsSync35(archivePath)) {
       return archivePath;
     }
     debugInstall(`Downloading binary from ${url}`);
@@ -80686,8 +81081,8 @@ async function installUrl(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
   }
   try {
-    if (existsSync33(outputPath)) {
-      if (!existsSync33(installedBrowser.executablePath)) {
+    if (existsSync35(outputPath)) {
+      if (!existsSync35(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup(installedBrowser);
@@ -80696,7 +81091,7 @@ async function installUrl(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync33(archivePath)) {
+    if (!existsSync35(archivePath)) {
       debugInstall(`Downloading binary from ${url}`);
       try {
         debugTime("download");
@@ -80725,7 +81120,7 @@ async function installUrl(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync33(archivePath)) {
+    if (existsSync35(archivePath)) {
       await unlink(archivePath);
     }
   }
@@ -80736,7 +81131,7 @@ async function runSetup(installedBrowser) {
       debugTime("permissions");
       const browserDir = path8.dirname(installedBrowser.executablePath);
       const setupExePath = path8.join(browserDir, "setup.exe");
-      if (!existsSync33(setupExePath)) {
+      if (!existsSync35(setupExePath)) {
         return;
       }
       spawnSync4(path8.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
@@ -81117,19 +81512,19 @@ var init_cliui = __esm(() => {
 });
 
 // node_modules/escalade/sync/index.mjs
-import { dirname as dirname13, resolve as resolve9 } from "path";
+import { dirname as dirname14, resolve as resolve10 } from "path";
 import { readdirSync as readdirSync11, statSync as statSync12 } from "fs";
 function sync_default(start, callback) {
-  let dir = resolve9(".", start);
+  let dir = resolve10(".", start);
   let tmp, stats = statSync12(dir);
   if (!stats.isDirectory()) {
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   while (true) {
     tmp = callback(dir, readdirSync11(dir));
     if (tmp)
-      return resolve9(dir, tmp);
-    dir = dirname13(tmp = dir);
+      return resolve10(dir, tmp);
+    dir = dirname14(tmp = dir);
     if (tmp === dir)
       break;
   }
@@ -82075,7 +82470,7 @@ var init_yargs_parser = __esm(() => {
 
 // node_modules/yargs-parser/build/lib/index.js
 import { format } from "util";
-import { normalize as normalize2, resolve as resolve10 } from "path";
+import { normalize as normalize2, resolve as resolve11 } from "path";
 var _a3, _b, _c, minNodeVersion, nodeVersion, env, parser, yargsParser = function Parser(args, opts) {
   const result = parser.parse(args.slice(), opts);
   return result.argv;
@@ -82098,7 +82493,7 @@ var init_lib2 = __esm(() => {
     },
     format,
     normalize: normalize2,
-    resolve: resolve10,
+    resolve: resolve11,
     require: (path9) => {
       if (true) {
         return __require(path9);
@@ -82150,7 +82545,7 @@ var init_yerror = __esm(() => {
 // node_modules/y18n/build/lib/platform-shims/node.js
 import { readFileSync as readFileSync27, statSync as statSync13, writeFile } from "fs";
 import { format as format2 } from "util";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var node_default;
 var init_node = __esm(() => {
   node_default = {
@@ -82159,7 +82554,7 @@ var init_node = __esm(() => {
       writeFile
     },
     format: format2,
-    resolve: resolve11,
+    resolve: resolve12,
     exists: (file) => {
       try {
         return statSync13(file).isFile();
@@ -82342,7 +82737,7 @@ import { notStrictEqual, strictEqual } from "assert";
 import { inspect } from "util";
 import { readFileSync as readFileSync28 } from "fs";
 import { fileURLToPath } from "url";
-import { basename as basename8, dirname as dirname14, extname as extname3, relative as relative8, resolve as resolve12 } from "path";
+import { basename as basename8, dirname as dirname15, extname as extname3, relative as relative8, resolve as resolve13 } from "path";
 var REQUIRE_ERROR = "require is not supported by ESM", REQUIRE_DIRECTORY_ERROR = "loading a directory of commands is not supported yet for ESM", __dirname2, mainFilename, esm_default;
 var init_esm = __esm(() => {
   init_cliui();
@@ -82375,10 +82770,10 @@ var init_esm = __esm(() => {
     Parser: lib_default,
     path: {
       basename: basename8,
-      dirname: dirname14,
+      dirname: dirname15,
       extname: extname3,
       relative: relative8,
-      resolve: resolve12
+      resolve: resolve13
     },
     process: {
       argv: () => process.argv,
@@ -82400,7 +82795,7 @@ var init_esm = __esm(() => {
       return [...str].length;
     },
     y18n: y18n_default({
-      directory: resolve12(__dirname2, "../../../locales"),
+      directory: resolve13(__dirname2, "../../../locales"),
       updateFiles: false
     })
   };
@@ -84648,12 +85043,12 @@ var init_yargs_factory = __esm(() => {
     async getCompletion(args, done) {
       argsert("<array> [function]", [args, done], arguments.length);
       if (!done) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
             if (err)
               reject(err);
             else
-              resolve13(completions);
+              resolve14(completions);
           });
         });
       } else {
@@ -86088,9 +86483,9 @@ async function getConnectionTransport(options) {
       throw new Error("Could not detect required browser platform");
     }
     const { convertPuppeteerChannelToBrowsersChannel: convertPuppeteerChannelToBrowsersChannel2 } = await Promise.resolve().then(() => (init_LaunchOptions(), exports_LaunchOptions));
-    const { join: join30 } = await import("path");
+    const { join: join32 } = await import("path");
     const userDataDir = resolveDefaultUserDataDir3(Browser7.CHROME, platform2, convertPuppeteerChannelToBrowsersChannel2(options.channel));
-    const portPath = join30(userDataDir, "DevToolsActivePort");
+    const portPath = join32(userDataDir, "DevToolsActivePort");
     try {
       const fileContent = await environment.value.fs.promises.readFile(portPath, "ascii");
       const [rawPort, rawPath] = fileContent.split(`
@@ -86314,9 +86709,9 @@ var init_PipeTransport = __esm(() => {
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import { tmpdir } from "os";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 
 class BrowserLauncher {
   #browser;
@@ -86341,7 +86736,7 @@ class BrowserLauncher {
       ...options,
       protocol
     });
-    if (!existsSync34(launchArgs.executablePath)) {
+    if (!existsSync36(launchArgs.executablePath)) {
       throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
     }
     const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
@@ -86416,7 +86811,7 @@ class BrowserLauncher {
       browserCloseCallback();
       const logs = browserProcess.getRecentLogs().join(`
 `);
-      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync34(join30(launchArgs.userDataDir, "lockfile"))) {
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync36(join32(launchArgs.userDataDir, "lockfile"))) {
         throw new Error(`The browser is already running for ${launchArgs.userDataDir}. Use a different \`userDataDir\` or stop the running browser first.`);
       }
       if (logs.includes("Missing X server") && options.headless === false) {
@@ -86506,12 +86901,12 @@ class BrowserLauncher {
     });
   }
   getProfilePath() {
-    return join30(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+    return join32(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
   }
   resolveExecutablePath(headless, validatePath = true) {
     let executablePath = this.puppeteer.configuration.executablePath;
     if (executablePath) {
-      if (validatePath && !existsSync34(executablePath)) {
+      if (validatePath && !existsSync36(executablePath)) {
         throw new Error(`Tried to find the browser at the configured path (${executablePath}), but no executable was found.`);
       }
       return executablePath;
@@ -86534,7 +86929,7 @@ class BrowserLauncher {
       browser: browserType,
       buildId: this.puppeteer.browserVersion
     });
-    if (validatePath && !existsSync34(executablePath)) {
+    if (validatePath && !existsSync36(executablePath)) {
       const configVersion = this.puppeteer.configuration?.[this.browser]?.version;
       if (configVersion) {
         throw new Error(`Tried to find the browser at the configured path (${executablePath}) for version ${configVersion}, but no executable was found.`);
@@ -87072,7 +87467,7 @@ var init_PuppeteerNode = __esm(() => {
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
 import fs5 from "fs";
 import os8 from "os";
-import { dirname as dirname15 } from "path";
+import { dirname as dirname16 } from "path";
 import { PassThrough } from "stream";
 var import_debug6, __runInitializers22 = function(thisArg, initializers, value) {
   var useValue = arguments.length > 2;
@@ -87146,8 +87541,8 @@ var init_ScreenRecorder = __esm(() => {
       static {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : undefined;
         __esDecorate22(this, _private_writeFrame_descriptor = { value: __setFunctionName5(async function(buffer) {
-          const error = await new Promise((resolve13) => {
-            this.#process.stdin.write(buffer, resolve13);
+          const error = await new Promise((resolve14) => {
+            this.#process.stdin.write(buffer, resolve14);
           });
           if (error) {
             console.log(`ffmpeg failed to write: ${error.message}.`);
@@ -87196,7 +87591,7 @@ var init_ScreenRecorder = __esm(() => {
           filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
         }
         if (path11) {
-          fs5.mkdirSync(dirname15(path11), { recursive: overwrite });
+          fs5.mkdirSync(dirname16(path11), { recursive: overwrite });
         }
         this.#process = spawn2(ffmpegPath, [
           ["-loglevel", "error"],
@@ -87302,8 +87697,8 @@ var init_ScreenRecorder = __esm(() => {
         const [buffer, timestamp] = await this.#lastFrame;
         await Promise.all(Array(Math.max(1, Math.round(this.#fps * (performance.now() - timestamp) / 1000))).fill(buffer).map(this.#writeFrame.bind(this)));
         this.#process.stdin.end();
-        await new Promise((resolve13) => {
-          this.#process.once("close", resolve13);
+        await new Promise((resolve14) => {
+          this.#process.once("close", resolve14);
         });
       }
       async[(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
@@ -87349,17 +87744,17 @@ var init_puppeteer_core = __esm(() => {
 });
 
 // src/core/design-eval/capture.ts
-import { mkdirSync as mkdirSync15, statSync as statSync14, existsSync as existsSync35 } from "fs";
-import { join as join31 } from "path";
+import { mkdirSync as mkdirSync16, statSync as statSync14, existsSync as existsSync37 } from "fs";
+import { join as join33 } from "path";
 function findBrowser() {
   const platform2 = process.platform;
   const paths = CHROME_PATHS[platform2] ?? [];
   for (const p of paths) {
-    if (existsSync35(p))
+    if (existsSync37(p))
       return p;
   }
-  const minkBrowsers = join31(minkRoot(), "browsers");
-  if (existsSync35(minkBrowsers)) {
+  const minkBrowsers = join33(minkRoot(), "browsers");
+  if (existsSync37(minkBrowsers)) {
     const found = findChromeInDir(minkBrowsers);
     if (found)
       return found;
@@ -87380,7 +87775,7 @@ function findChromeInDir(dir) {
   try {
     const entries = readdirSync12(dir);
     for (const entry of entries) {
-      const full = join31(dir, entry);
+      const full = join33(dir, entry);
       try {
         const stat2 = statSync15(full);
         if (stat2.isDirectory()) {
@@ -87428,7 +87823,7 @@ async function captureRoute(page, route, baseUrl, viewport, options) {
     const y = section * viewport.height;
     const clipHeight = Math.min(viewport.height, pageHeight - y);
     const fileName = `${prefix}-${viewport.name}-${section}.jpg`;
-    const filePath = join31(options.outputDir, fileName);
+    const filePath = join33(options.outputDir, fileName);
     await page.screenshot({
       path: filePath,
       type: "jpeg",
@@ -87460,7 +87855,7 @@ async function captureRoute(page, route, baseUrl, viewport, options) {
   return results;
 }
 async function captureAllRoutes(routes, baseUrl, viewports, options, outputDir) {
-  mkdirSync15(outputDir, { recursive: true });
+  mkdirSync16(outputDir, { recursive: true });
   const executablePath = findBrowser();
   const browser = await puppeteer_core_default.launch({
     executablePath,
@@ -88897,9 +89292,9 @@ var exports_wiki = {};
 __export(exports_wiki, {
   wiki: () => wiki
 });
-import { existsSync as existsSync36, statSync as statSync15 } from "fs";
-import { resolve as resolve13 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync38, statSync as statSync15 } from "fs";
+import { resolve as resolve14 } from "path";
+import { homedir as homedir5 } from "os";
 async function wiki(_cwd, args) {
   const sub = args[0];
   switch (sub) {
@@ -88955,7 +89350,7 @@ async function wikiInit(args) {
     console.log(`[mink] initializing vault at ${targetPath}`);
     console.log("  (set a custom path with: mink wiki init /path/to/vault)");
   }
-  const isExisting = existsSync36(targetPath) && statSync15(targetPath).isDirectory();
+  const isExisting = existsSync38(targetPath) && statSync15(targetPath).isDirectory();
   setConfigValue("wiki.path", targetPath);
   ensureVaultStructure();
   seedTemplates(vaultTemplates());
@@ -89165,9 +89560,9 @@ function wikiLinks() {
 }
 function expandPath(raw) {
   if (raw.startsWith("~/")) {
-    return resolve13(homedir4(), raw.slice(2));
+    return resolve14(homedir5(), raw.slice(2));
   }
-  return resolve13(raw);
+  return resolve14(raw);
 }
 var init_wiki = __esm(() => {
   init_vault();
@@ -89183,8 +89578,8 @@ var exports_note = {};
 __export(exports_note, {
   note: () => note
 });
-import { resolve as resolve14 } from "path";
-import { existsSync as existsSync37, readFileSync as readFileSync29 } from "fs";
+import { resolve as resolve15 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync29 } from "fs";
 async function note(cwd, args) {
   if (!isWikiEnabled()) {
     console.error("[mink] wiki feature is disabled");
@@ -89214,8 +89609,8 @@ async function note(cwd, args) {
     return;
   }
   if (parsed.file) {
-    const sourcePath = resolve14(cwd, parsed.file);
-    if (!existsSync37(sourcePath)) {
+    const sourcePath = resolve15(cwd, parsed.file);
+    if (!existsSync39(sourcePath)) {
       console.error(`[mink] file not found: ${sourcePath}`);
       process.exit(1);
     }
@@ -89376,39 +89771,39 @@ var exports_skill = {};
 __export(exports_skill, {
   skill: () => skill
 });
-import { join as join32, resolve as resolve15, dirname as dirname16 } from "path";
-import { homedir as homedir5 } from "os";
+import { join as join34, resolve as resolve16, dirname as dirname17 } from "path";
+import { homedir as homedir6 } from "os";
 import {
-  existsSync as existsSync38,
-  mkdirSync as mkdirSync16,
-  copyFileSync,
+  existsSync as existsSync40,
+  mkdirSync as mkdirSync17,
+  copyFileSync as copyFileSync2,
   unlinkSync as unlinkSync6,
   readdirSync as readdirSync12,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   symlinkSync as symlinkSync2,
   lstatSync as lstatSync2
 } from "fs";
 function getSkillsSourceDir() {
-  let dir = dirname16(new URL(import.meta.url).pathname);
+  let dir = dirname17(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync38(join32(dir, "package.json")) && existsSync38(join32(dir, "skills"))) {
-      return join32(dir, "skills");
+    if (existsSync40(join34(dir, "package.json")) && existsSync40(join34(dir, "skills"))) {
+      return join34(dir, "skills");
     }
-    const parent = dirname16(dir);
+    const parent = dirname17(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve15(dirname16(new URL(import.meta.url).pathname), "../../skills");
+  return resolve16(dirname17(new URL(import.meta.url).pathname), "../../skills");
 }
 function getAvailableSkills() {
   const dir = getSkillsSourceDir();
-  if (!existsSync38(dir))
+  if (!existsSync40(dir))
     return [];
-  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync38(join32(dir, d.name, "SKILL.md"))).map((d) => d.name);
+  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync40(join34(dir, d.name, "SKILL.md"))).map((d) => d.name);
 }
 function isInstalled(skillName) {
-  return existsSync38(join32(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
+  return existsSync40(join34(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
 }
 async function skill(args) {
   const sub = args[0];
@@ -89442,28 +89837,28 @@ function skillInstall(name) {
     console.error("  Expected skills at: " + sourceDir);
     return;
   }
-  mkdirSync16(AGENTS_SKILLS_DIR, { recursive: true });
+  mkdirSync17(AGENTS_SKILLS_DIR, { recursive: true });
   for (const skillName of skills) {
-    const srcDir = join32(sourceDir, skillName);
-    const srcFile = join32(srcDir, "SKILL.md");
-    const destDir = join32(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync38(srcFile)) {
+    const srcDir = join34(sourceDir, skillName);
+    const srcFile = join34(srcDir, "SKILL.md");
+    const destDir = join34(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync40(srcFile)) {
       console.error(`[mink] skill not found: ${skillName}`);
       continue;
     }
-    mkdirSync16(destDir, { recursive: true });
+    mkdirSync17(destDir, { recursive: true });
     copyDirRecursive2(srcDir, destDir);
-    mkdirSync16(CLAUDE_SKILLS_DIR, { recursive: true });
-    const symlink = join32(CLAUDE_SKILLS_DIR, skillName);
+    mkdirSync17(CLAUDE_SKILLS_DIR, { recursive: true });
+    const symlink = join34(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync38(symlink)) {
+      if (existsSync40(symlink)) {
         if (lstatSync2(symlink).isSymbolicLink() || lstatSync2(symlink).isFile()) {
           unlinkSync6(symlink);
         } else {
-          rmSync2(symlink, { recursive: true, force: true });
+          rmSync3(symlink, { recursive: true, force: true });
         }
       }
-      const relativeTarget = join32("..", "..", ".agents", "skills", skillName);
+      const relativeTarget = join34("..", "..", ".agents", "skills", skillName);
       symlinkSync2(relativeTarget, symlink);
     } catch {}
     console.log(`[mink] installed: ${skillName} -> ${destDir}`);
@@ -89474,15 +89869,15 @@ function skillInstall(name) {
 function skillUninstall(name) {
   const skills = name ? [name] : getAvailableSkills();
   for (const skillName of skills) {
-    const destDir = join32(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync38(destDir)) {
+    const destDir = join34(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync40(destDir)) {
       console.log(`[mink] not installed: ${skillName}`);
       continue;
     }
-    rmSync2(destDir, { recursive: true, force: true });
-    const symlink = join32(CLAUDE_SKILLS_DIR, skillName);
+    rmSync3(destDir, { recursive: true, force: true });
+    const symlink = join34(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync38(symlink))
+      if (existsSync40(symlink))
         unlinkSync6(symlink);
     } catch {}
     console.log(`[mink] uninstalled: ${skillName}`);
@@ -89497,7 +89892,7 @@ function skillList() {
   if (installed.length > 0) {
     console.log("  Installed:");
     for (const s of installed) {
-      console.log(`    ${s}  (${join32(AGENTS_SKILLS_DIR, s)})`);
+      console.log(`    ${s}  (${join34(AGENTS_SKILLS_DIR, s)})`);
     }
   }
   if (notInstalled.length > 0) {
@@ -89516,20 +89911,20 @@ function skillList() {
 function copyDirRecursive2(src, dest) {
   const entries = readdirSync12(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join32(src, entry.name);
-    const destPath = join32(dest, entry.name);
+    const srcPath = join34(src, entry.name);
+    const destPath = join34(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync16(destPath, { recursive: true });
+      mkdirSync17(destPath, { recursive: true });
       copyDirRecursive2(srcPath, destPath);
     } else {
-      copyFileSync(srcPath, destPath);
+      copyFileSync2(srcPath, destPath);
     }
   }
 }
 var AGENTS_SKILLS_DIR, CLAUDE_SKILLS_DIR;
 var init_skill = __esm(() => {
-  AGENTS_SKILLS_DIR = join32(homedir5(), ".agents", "skills");
-  CLAUDE_SKILLS_DIR = join32(homedir5(), ".claude", "skills");
+  AGENTS_SKILLS_DIR = join34(homedir6(), ".agents", "skills");
+  CLAUDE_SKILLS_DIR = join34(homedir6(), ".claude", "skills");
 });
 
 // src/commands/agent.ts
@@ -89537,41 +89932,41 @@ var exports_agent = {};
 __export(exports_agent, {
   agent: () => agent
 });
-import { join as join33, resolve as resolve16, dirname as dirname17 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join35, resolve as resolve17, dirname as dirname18 } from "path";
+import { homedir as homedir7 } from "os";
 import {
-  existsSync as existsSync39,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync18,
   readFileSync as readFileSync30,
   writeFileSync as writeFileSync11
 } from "fs";
 import { createHash as createHash4 } from "crypto";
 import { spawnSync as spawnSync6 } from "child_process";
 function getAgentTemplatePath() {
-  let dir = dirname17(new URL(import.meta.url).pathname);
+  let dir = dirname18(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync39(join33(dir, "package.json")) && existsSync39(join33(dir, "agents", TEMPLATE_FILE))) {
-      return join33(dir, "agents", TEMPLATE_FILE);
+    if (existsSync41(join35(dir, "package.json")) && existsSync41(join35(dir, "agents", TEMPLATE_FILE))) {
+      return join35(dir, "agents", TEMPLATE_FILE);
     }
-    const parent = dirname17(dir);
+    const parent = dirname18(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve16(dirname17(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
+  return resolve17(dirname18(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
 }
 function getMinkVersion() {
-  let dir = dirname17(new URL(import.meta.url).pathname);
+  let dir = dirname18(new URL(import.meta.url).pathname);
   while (true) {
-    const pkgPath = join33(dir, "package.json");
-    if (existsSync39(pkgPath)) {
+    const pkgPath = join35(dir, "package.json");
+    if (existsSync41(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync30(pkgPath, "utf-8"));
         if (pkg.name && pkg.version)
           return pkg.version;
       } catch {}
     }
-    const parent = dirname17(dir);
+    const parent = dirname18(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -89589,19 +89984,19 @@ function sha2562(text) {
   return createHash4("sha256").update(text).digest("hex");
 }
 function claudeAgentsDir() {
-  return join33(homedir6(), ".claude", "agents");
+  return join35(homedir7(), ".claude", "agents");
 }
 function installedAgentPath() {
-  return join33(claudeAgentsDir(), INSTALLED_FILE);
+  return join35(claudeAgentsDir(), INSTALLED_FILE);
 }
 function installAgentDefinition(opts) {
   const templatePath = getAgentTemplatePath();
-  if (!existsSync39(templatePath)) {
+  if (!existsSync41(templatePath)) {
     throw new Error(`[mink agent] bundled agent template not found at ${templatePath}
 ` + "  This usually means the package was installed without bundled assets.");
   }
   const installed = installedAgentPath();
-  if (opts.skip && existsSync39(installed)) {
+  if (opts.skip && existsSync41(installed)) {
     return { action: "skipped", path: installed };
   }
   const template = readFileSync30(templatePath, "utf-8");
@@ -89610,14 +90005,14 @@ function installAgentDefinition(opts) {
     VAULT_PATH: resolveVaultPath(),
     MINK_VERSION: getMinkVersion()
   });
-  const exists = existsSync39(installed);
+  const exists = existsSync41(installed);
   if (!opts.force && exists) {
     const current = readFileSync30(installed, "utf-8");
     if (sha2562(current) === sha2562(rendered)) {
       return { action: "unchanged", path: installed };
     }
   }
-  mkdirSync17(claudeAgentsDir(), { recursive: true });
+  mkdirSync18(claudeAgentsDir(), { recursive: true });
   writeFileSync11(installed, rendered);
   return {
     action: exists ? "updated" : "installed",
@@ -89688,8 +90083,8 @@ async function agent(_cwd, rawArgs) {
   }
   const skipUpdate = args.noUpdate || process.env.MINK_AGENT_NO_UPDATE === "1";
   const root = minkRoot();
-  if (!existsSync39(root)) {
-    mkdirSync17(root, { recursive: true });
+  if (!existsSync41(root)) {
+    mkdirSync18(root, { recursive: true });
   }
   let result;
   try {
@@ -89740,13 +90135,13 @@ var init_agent = __esm(() => {
 });
 
 // src/core/sync-merge-drivers.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync2, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync3, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
+import { join as join36 } from "path";
 function logWarning(driver, args, err) {
   try {
     const line = `[${new Date().toISOString()}] ${driver} fallback for ${args.filePath}: ${err instanceof Error ? err.message : String(err)}
 `;
-    appendFileSync2(join34(minkRoot(), "sync-warnings.log"), line);
+    appendFileSync2(join36(minkRoot(), "sync-warnings.log"), line);
   } catch {}
 }
 function readJsonOrNull(path12) {
@@ -89981,7 +90376,7 @@ function mergeDbDriver(args) {
   const tmp = `${args.oursPath}.merge-${process.pid}-${Date.now()}.tmp`;
   let ours = null;
   try {
-    copyFileSync2(args.oursPath, tmp);
+    copyFileSync3(args.oursPath, tmp);
     ours = openDriver(tmp);
     ours.exec("PRAGMA journal_mode = WAL");
     ours.exec("PRAGMA foreign_keys = ON");
@@ -90497,8 +90892,22 @@ switch (command2) {
     sessionStop(sessionPath(cwd));
     break;
   case "init": {
-    const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
-    await init2(cwd);
+    const { init: init2, resolveTargetsFromFlag: resolveTargetsFromFlag2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+    const args = process.argv.slice(3);
+    const agentFlagIndex = args.findIndex((a) => a === "--agent" || a.startsWith("--agent="));
+    let agentValue;
+    if (agentFlagIndex !== -1) {
+      const a = args[agentFlagIndex];
+      agentValue = a.includes("=") ? a.split("=").slice(1).join("=") : args[agentFlagIndex + 1];
+    }
+    const yes = args.includes("--yes") || args.includes("-y");
+    const targets = agentValue ? resolveTargetsFromFlag2(agentValue) : undefined;
+    if (agentValue && (!targets || targets.length === 0)) {
+      console.error(`[mink] unknown --agent value: ${agentValue}`);
+      console.error("  Valid: claude, pi, all (or a comma-separated list)");
+      process.exit(1);
+    }
+    await init2(cwd, { targets, interactive: !yes });
     break;
   }
   case "status": {
@@ -90642,12 +91051,12 @@ switch (command2) {
   case "version":
   case "--version":
   case "-v": {
-    const { resolve: resolve17, dirname: dirname18, basename: basename9 } = await import("path");
+    const { resolve: resolve18, dirname: dirname19, basename: basename9 } = await import("path");
     const bundlePath = new URL(import.meta.url).pathname;
-    const cliPath = resolve17(dirname18(bundlePath));
+    const cliPath = resolve18(dirname19(bundlePath));
     const { readFileSync: readFileSync32 } = await import("fs");
     try {
-      const pkg = JSON.parse(readFileSync32(resolve17(cliPath, "../package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync32(resolve18(cliPath, "../package.json"), "utf-8"));
       console.log(`mink ${pkg.version}`);
     } catch {
       console.log("mink (unknown version)");
@@ -90670,7 +91079,8 @@ switch (command2) {
     console.log("Usage: mink <command> [options]");
     console.log();
     console.log("Commands:");
-    console.log("  init                    Initialize Mink in the current project");
+    console.log("  init [--agent X] [--yes] Initialize Mink in the current project");
+    console.log("                          --agent claude|pi|all (default: detect & prompt)");
     console.log("  status                  Display project health at a glance");
     console.log("  scan [--check]          Force a full file index rescan");
     console.log("  config [key] [value]    Manage global user settings");