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

package/dist/cli.node.js

@@ -4897,6 +4897,342 @@ var init_paths2 = __esm(() => {
   MINK_ROOT2 = resolveMinkRoot2();
 });
 
+// src/core/agent-detect.ts
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync18 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir4 } 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 (existsSync18(join15(cwd, meta.projectDir))) {
+    signals.push(`project config (${meta.projectDir}/)`);
+  }
+  if (existsSync18(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: join15(homedir4(), ".claude"),
+      bin: "claude"
+    },
+    {
+      id: "pi",
+      label: "Pi",
+      projectDir: ".pi",
+      globalDir: join15(homedir4(), ".pi"),
+      bin: "pi"
+    }
+  ];
+});
+
+// src/core/agent-pi.ts
+import { join as join16, resolve as resolve2, dirname as dirname7 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, copyFileSync, rmSync as rmSync2 } from "fs";
+function piExtensionPath(cwd) {
+  return join16(cwd, ".pi", "extensions", "mink.ts");
+}
+function piGuidanceSkillPath(cwd) {
+  return join16(cwd, ".pi", "skills", "mink", "SKILL.md");
+}
+function piNoteSkillPath(cwd) {
+  return join16(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 — 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 — 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 — 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 — 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 (existsSync19(join16(dir, "package.json")) && existsSync19(join16(dir, "skills"))) {
+      return join16(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 = join16(resolveSkillsSourceDir(), "mink-note", "SKILL.md");
+    if (existsSync19(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 — 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 — **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\`) — 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 — 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, {
@@ -4905,14 +5241,14 @@ __export(exports_backup, {
   createBackup: () => createBackup
 });
 import {
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   readdirSync as readdirSync7,
   readFileSync as readFileSync12,
   writeFileSync as writeFileSync5,
-  existsSync as existsSync18,
+  existsSync as existsSync20,
   statSync as statSync7
 } from "fs";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 function formatTimestamp(date) {
   const y = date.getFullYear();
   const mo = String(date.getMonth() + 1).padStart(2, "0");
@@ -4924,15 +5260,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(join15(srcDir, entry.name), join15(destDir, entry.name), excludeDirs);
+      copyDirectoryFiles(join17(srcDir, entry.name), join17(destDir, entry.name), excludeDirs);
     } else if (entry.isFile()) {
-      writeFileSync5(join15(destDir, entry.name), readFileSync12(join15(srcDir, entry.name)));
+      writeFileSync5(join17(destDir, entry.name), readFileSync12(join17(srcDir, entry.name)));
     }
   }
 }
@@ -4941,25 +5277,25 @@ function createBackup(cwd) {
   const dir = backupDirPath(cwd);
   let name = base;
   let suffix = 1;
-  while (existsSync18(join15(dir, name))) {
+  while (existsSync20(join17(dir, name))) {
     name = `${base}-${suffix}`;
     suffix++;
   }
   const src = projectDir(cwd);
-  const dest = join15(dir, name);
+  const dest = join17(dir, name);
   copyDirectoryFiles(src, dest, ["backups"]);
   return name;
 }
 function listBackups(cwd) {
   const dir = backupDirPath(cwd);
-  if (!existsSync18(dir))
+  if (!existsSync20(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 = join15(dir, entry.name);
+    const backupPath = join17(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) {
@@ -4982,8 +5318,8 @@ function listBackups(cwd) {
   return backups;
 }
 function restoreBackup(cwd, backupName) {
-  const backupPath = join15(backupDirPath(cwd), backupName);
-  if (!existsSync18(backupPath)) {
+  const backupPath = join17(backupDirPath(cwd), backupName);
+  if (!existsSync20(backupPath)) {
     throw new Error(`backup not found: ${backupName}`);
   }
   createBackup(cwd);
@@ -4995,7 +5331,7 @@ var init_backup = __esm(() => {
 
 // src/core/scanner.ts
 import { readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { join as join16, relative } from "path";
+import { join as join18, relative } from "path";
 function matchesPattern(name, pattern) {
   if (pattern.includes("*")) {
     const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
@@ -5019,14 +5355,14 @@ function walkDirectory(dir, projectRoot, excludes, results) {
     if (entry.isDirectory()) {
       if (isExcluded(entry.name, excludes))
         continue;
-      walkDirectory(join16(dir, entry.name), projectRoot, excludes, results);
+      walkDirectory(join18(dir, entry.name), projectRoot, excludes, results);
       continue;
     }
     if (entry.isFile()) {
       if (isExcluded(entry.name, excludes))
         continue;
       try {
-        const fullPath = join16(dir, entry.name);
+        const fullPath = join18(dir, entry.name);
         const stat = statSync8(fullPath);
         results.push({
           relativePath: relative(projectRoot, fullPath),
@@ -5449,7 +5785,7 @@ __export(exports_scan, {
 });
 import { readFileSync as readFileSync13 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join17, relative as relative2 } from "path";
+import { join as join19, relative as relative2 } from "path";
 function configRelativePath(cfgPath, cwd) {
   const rel = relative2(cwd, cfgPath);
   return rel.startsWith("..") ? cfgPath : rel;
@@ -5500,7 +5836,7 @@ function scan(cwd, options) {
     if (!stalePaths.has(file.relativePath)) {
       continue;
     }
-    const fullPath = join17(cwd, file.relativePath);
+    const fullPath = join19(cwd, file.relativePath);
     let content;
     try {
       content = readFileSync13(fullPath, "utf-8");
@@ -5589,10 +5925,10 @@ __export(exports_seed, {
   parseGoMod: () => parseGoMod,
   parseCargoToml: () => parseCargoToml
 });
-import { basename as basename4, join as join18 } from "path";
-import { readFileSync as readFileSync14, existsSync as existsSync19 } from "fs";
+import { basename as basename4, join as join20 } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync21 } from "fs";
 function readFile(filePath) {
-  if (!existsSync19(filePath))
+  if (!existsSync21(filePath))
     return null;
   try {
     return readFileSync14(filePath, "utf-8");
@@ -5685,10 +6021,10 @@ function parseGoMod(filePath) {
 }
 function seedLearningMemory(projectRoot) {
   const parsers = [
-    () => parsePackageJson(join18(projectRoot, "package.json")),
-    () => parsePyprojectToml(join18(projectRoot, "pyproject.toml")),
-    () => parseCargoToml(join18(projectRoot, "Cargo.toml")),
-    () => parseGoMod(join18(projectRoot, "go.mod"))
+    () => parsePackageJson(join20(projectRoot, "package.json")),
+    () => parsePyprojectToml(join20(projectRoot, "pyproject.toml")),
+    () => parseCargoToml(join20(projectRoot, "Cargo.toml")),
+    () => parseGoMod(join20(projectRoot, "go.mod"))
   ];
   const infos = parsers.map((fn) => fn()).filter((info) => info !== null);
   const projectName = infos.find((i) => i.projectName)?.projectName ?? basename4(projectRoot);
@@ -5766,34 +6102,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 existsSync20 } from "fs";
-import { resolve as resolve2, dirname as dirname7, basename as basename5, join as join19 } from "path";
+import { execSync as execSync6 } from "child_process";
+import { mkdirSync as mkdirSync10, existsSync as existsSync22 } from "fs";
+import { resolve as resolve3, dirname as dirname8, basename as basename5, join as join21 } 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 join19(selfDir, "cli.js");
+    return join21(selfDir, "cli.js");
   }
-  const packageRoot = resolve2(selfDir, "..", "..");
-  const distShim = join19(packageRoot, "dist", "cli.js");
-  if (existsSync20(distShim))
+  const packageRoot = resolve3(selfDir, "..", "..");
+  const distShim = join21(packageRoot, "dist", "cli.js");
+  if (existsSync22(distShim))
     return distShim;
-  return join19(packageRoot, "src", "cli.ts");
+  return join21(packageRoot, "src", "cli.ts");
 }
 function resolveCliPath() {
   return resolveCliPathFrom(new URL(import.meta.url).pathname);
@@ -5835,13 +6174,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)) {
@@ -5852,17 +6191,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 — ${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 (!existsSync20(dir))
+  if (!existsSync22(dir))
     return false;
-  return existsSync20(join19(dir, "file-index.json"));
+  return existsSync22(join21(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) {
@@ -5871,9 +6239,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);
@@ -5881,6 +6262,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,
@@ -5888,20 +6271,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);
@@ -5913,7 +6305,7 @@ async function init(cwd) {
   scan2(cwd, { check: false });
   const { learningMemoryPath: learningMemoryPath3 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
   const memPath = learningMemoryPath3(cwd);
-  if (!existsSync20(memPath)) {
+  if (!existsSync22(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);
@@ -5922,8 +6314,8 @@ async function init(cwd) {
   if (isWikiEnabled() && isVaultInitialized() && !isNotesProject) {
     try {
       const projectSlug = basename5(cwd);
-      const overviewPath = join19(vaultProjects(projectSlug), "overview.md");
-      if (!existsSync20(overviewPath)) {
+      const overviewPath = join21(vaultProjects(projectSlug), "overview.md");
+      if (!existsSync22(overviewPath)) {
         const now = new Date().toISOString();
         const overview = [
           `---`,
@@ -5975,6 +6367,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
@@ -6049,12 +6444,12 @@ var init_state_counters = __esm(() => {
 });
 
 // src/core/channel-templates.ts
-import { join as join20 } from "path";
-import { existsSync as existsSync21, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
+import { join as join22 } from "path";
+import { existsSync as existsSync23, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11 } from "fs";
 function writeCompanionClaudeMd(vaultPath, overwrite = false) {
-  mkdirSync10(vaultPath, { recursive: true });
-  const claudeMdPath = join20(vaultPath, "CLAUDE.md");
-  if (existsSync21(claudeMdPath) && !overwrite) {
+  mkdirSync11(vaultPath, { recursive: true });
+  const claudeMdPath = join22(vaultPath, "CLAUDE.md");
+  if (existsSync23(claudeMdPath) && !overwrite) {
     return false;
   }
   writeFileSync6(claudeMdPath, COMPANION_CLAUDE_MD);
@@ -6206,8 +6601,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 existsSync22 } from "fs";
-import { dirname as dirname8, join as join21 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync12, existsSync as existsSync24 } from "fs";
+import { dirname as dirname9, join as join23 } from "path";
 import { spawnSync } from "child_process";
 function readChannelPidFile() {
   try {
@@ -6223,7 +6618,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() {
@@ -6353,12 +6748,12 @@ function getChannelLogs() {
     return null;
   if (!screenSessionExists(pidData.session))
     return null;
-  const tmpPath = join21(minkRoot(), `.channel-capture-${Date.now()}-${process.pid}.txt`);
+  const tmpPath = join23(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 (existsSync22(tmpPath))
+    if (existsSync24(tmpPath))
       break;
     const delayUntil = Date.now() + 50;
     while (Date.now() < delayUntil) {}
@@ -6462,7 +6857,7 @@ async function runtimeServe(opts) {
   }
   const { createServer } = await import("node:http");
   const { Readable } = await import("node: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;
@@ -6521,7 +6916,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)
@@ -6539,8 +6934,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");
@@ -6555,7 +6950,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() {
@@ -6580,10 +6975,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,
@@ -6697,9 +7092,9 @@ var exports_status = {};
 __export(exports_status, {
   status: () => status
 });
-import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
 function checkJsonFile(name, filePath, validator) {
-  if (!existsSync24(filePath))
+  if (!existsSync26(filePath))
     return { name, path: filePath, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -6709,7 +7104,7 @@ function checkJsonFile(name, filePath, validator) {
   return { name, path: filePath, status: "ok" };
 }
 function checkDbFile(name, filePath) {
-  if (!existsSync24(filePath))
+  if (!existsSync26(filePath))
     return { name, path: filePath, status: "missing" };
   try {
     const header = readFileSync17(filePath).slice(0, 16).toString("utf-8");
@@ -6724,7 +7119,7 @@ function checkDbFile(name, filePath) {
 function checkShardedText(name, candidatePaths) {
   const canonical = candidatePaths[0];
   for (const p of candidatePaths) {
-    if (!existsSync24(p))
+    if (!existsSync26(p))
       continue;
     try {
       if (statSync9(p).size === 0)
@@ -6817,7 +7212,7 @@ function status(cwd) {
       console.log(`    Decision Log: ${mem.sections["Decision Log"].length}`);
       console.log(`    Total entries: ${total}`);
       const memPath = learningMemoryPath(cwd);
-      if (existsSync24(memPath)) {
+      if (existsSync26(memPath)) {
         const mtime = statSync9(memPath).mtime;
         console.log(`    Canonical last modified: ${mtime.toISOString()}`);
       }
@@ -6866,7 +7261,7 @@ __export(exports_scan2, {
 });
 import { readFileSync as readFileSync18 } from "fs";
 import { createHash as createHash3 } from "crypto";
-import { join as join22, relative as relative3 } from "path";
+import { join as join24, relative as relative3 } from "path";
 function configRelativePath2(cfgPath, cwd) {
   const rel = relative3(cwd, cfgPath);
   return rel.startsWith("..") ? cfgPath : rel;
@@ -6917,7 +7312,7 @@ function scan2(cwd, options) {
     if (!stalePaths.has(file.relativePath)) {
       continue;
     }
-    const fullPath = join22(cwd, file.relativePath);
+    const fullPath = join24(cwd, file.relativePath);
     let content;
     try {
       content = readFileSync18(fullPath, "utf-8");
@@ -7002,12 +7397,12 @@ var exports_reflect2 = {};
 __export(exports_reflect2, {
   reflect: () => reflect2
 });
-import { existsSync as existsSync25 } from "fs";
-import { dirname as dirname10 } from "path";
+import { existsSync as existsSync27 } from "fs";
+import { dirname as dirname11 } from "path";
 function reflect2(_cwd, memoryPath, configPath3) {
-  const projDir = dirname10(memoryPath);
+  const projDir = dirname11(memoryPath);
   const mem = aggregateLearningMemoryAt(projDir);
-  if (totalEntryCount(mem) === 0 && !existsSync25(memoryPath)) {
+  if (totalEntryCount(mem) === 0 && !existsSync27(memoryPath)) {
     console.log("[mink] no learning memory found");
     return null;
   }
@@ -7878,9 +8273,9 @@ __export(exports_self_update, {
   PACKAGE_NAME: () => PACKAGE_NAME
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
-import { dirname as dirname11 } from "path";
-import { join as join23 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync21 } from "fs";
+import { dirname as dirname12 } from "path";
+import { join as join25 } from "path";
 function parseSemver(input) {
   const trimmed = input.trim().replace(/^v/, "");
   if (!trimmed)
@@ -7927,15 +8322,15 @@ function compareSemver(a, b) {
 function getInstallInfo() {
   const selfPath = new URL(import.meta.url).pathname;
   const isDevMode = selfPath.endsWith(".ts");
-  let dir = dirname11(selfPath);
+  let dir = dirname12(selfPath);
   let packageJsonPath = null;
   for (let i = 0;i < 10; i++) {
-    const candidate = join23(dir, "package.json");
-    if (existsSync26(candidate)) {
+    const candidate = join25(dir, "package.json");
+    if (existsSync28(candidate)) {
       packageJsonPath = candidate;
       break;
     }
-    const parent = dirname11(dir);
+    const parent = dirname12(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -8005,7 +8400,7 @@ function buildInstallCommand(pm, version) {
   return ["npm", "install", "-g", ref];
 }
 function selfUpdateLogPath() {
-  return join23(minkRoot(), "self-update.log");
+  return join25(minkRoot(), "self-update.log");
 }
 function appendLogEntry(entry) {
   const path = selfUpdateLogPath();
@@ -8794,21 +9189,21 @@ var init_cron = __esm(() => {
 });
 
 // src/core/vault-templates.ts
-import { join as join24 } from "path";
-import { existsSync as existsSync27, writeFileSync as writeFileSync9, readFileSync as readFileSync22, mkdirSync as mkdirSync13 } from "fs";
+import { join as join26 } from "path";
+import { existsSync as existsSync29, writeFileSync as writeFileSync9, readFileSync as readFileSync22, 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 = join24(templatesDir, `${name}.md`);
-    if (!existsSync27(filePath)) {
+    const filePath = join26(templatesDir, `${name}.md`);
+    if (!existsSync29(filePath)) {
       writeFileSync9(filePath, content);
     }
   }
 }
 function loadTemplate(templatesDir, templateName, vars) {
-  const filePath = join24(templatesDir, `${templateName}.md`);
+  const filePath = join26(templatesDir, `${templateName}.md`);
   let content;
-  if (existsSync27(filePath)) {
+  if (existsSync29(filePath)) {
     content = readFileSync22(filePath, "utf-8");
   } else if (DEFAULT_TEMPLATES[templateName]) {
     content = DEFAULT_TEMPLATES[templateName];
@@ -8962,29 +9357,29 @@ category: resources
 });
 
 // src/core/note-writer.ts
-import { join as join25 } from "path";
-import { existsSync as existsSync28, readFileSync as readFileSync23 } from "fs";
+import { join as join27 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync23 } from "fs";
 import { createHash as createHash4 } from "crypto";
 function sha256(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
 function resolveUniqueNotePath(dir, baseSlug, content) {
   const targetHash = sha256(content);
-  const primary = join25(dir, `${baseSlug}.md`);
-  if (!existsSync28(primary))
+  const primary = join27(dir, `${baseSlug}.md`);
+  if (!existsSync30(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 = join25(dir, `${baseSlug}-${suffix}.md`);
-    if (!existsSync28(candidate))
+    const candidate = join27(dir, `${baseSlug}-${suffix}.md`);
+    if (!existsSync30(candidate))
       return candidate;
     if (sameContent(candidate, targetHash))
       return candidate;
   }
-  return join25(dir, `${baseSlug}-${Date.now()}.md`);
+  return join27(dir, `${baseSlug}-${Date.now()}.md`);
 }
 function sameContent(filePath, expectedHash) {
   try {
@@ -9059,8 +9454,8 @@ ${meta.body}
 }
 function appendToDaily(date, content) {
   const dir = vaultDailyDir();
-  const filePath = join25(dir, `${date}.md`);
-  if (existsSync28(filePath)) {
+  const filePath = join27(dir, `${date}.md`);
+  if (existsSync30(filePath)) {
     const timestamp = new Date().toLocaleTimeString("en-US", {
       hour: "2-digit",
       minute: "2-digit",
@@ -9169,10 +9564,10 @@ var init_design_eval = __esm(() => {
 });
 
 // src/core/dashboard-api.ts
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync24 } from "fs";
 import { readdirSync as readdirSync9, readFileSync as readFileSyncFS, existsSync as fsExistsSync } from "fs";
-import { join as join26, resolve as resolve5, normalize, sep } from "path";
-import { execSync as execSync6 } from "child_process";
+import { join as join28, 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));
 }
@@ -9184,7 +9579,7 @@ function maskSecret(value, showLast = 4) {
   return "••••" + value.slice(-showLast);
 }
 function checkJsonFile2(name, filePath, validator) {
-  if (!existsSync29(filePath))
+  if (!existsSync31(filePath))
     return { name, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -9194,7 +9589,7 @@ function checkJsonFile2(name, filePath, validator) {
   return { name, status: "ok" };
 }
 function checkTextFile(name, filePath) {
-  if (!existsSync29(filePath))
+  if (!existsSync31(filePath))
     return { name, status: "missing" };
   try {
     readFileSync24(filePath, "utf-8");
@@ -9204,7 +9599,7 @@ function checkTextFile(name, filePath) {
   }
 }
 function checkDbFile2(name, filePath) {
-  if (!existsSync29(filePath))
+  if (!existsSync31(filePath))
     return { name, status: "missing" };
   try {
     const header = readFileSync24(filePath).slice(0, 16).toString("utf-8");
@@ -9386,7 +9781,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,
@@ -9398,7 +9793,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"]
@@ -9470,7 +9865,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 = join26(dir, entry.name);
+      const fullPath = join28(dir, entry.name);
       if (entry.isDirectory()) {
         count += countMarkdownIn(fullPath);
       } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
@@ -9499,7 +9894,7 @@ function buildVaultTree(root) {
     for (const entry of entries) {
       if (!entry.isDir)
         continue;
-      const fullPath = join26(dir, entry.name);
+      const fullPath = join28(dir, entry.name);
       const relPath = fullPath.slice(root.length + 1);
       const count = countMarkdownIn(fullPath);
       nodes.push({ name: entry.name, path: relPath, count, depth });
@@ -9584,7 +9979,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;
@@ -9922,7 +10317,7 @@ async function triggerIngestFile(sourcePath, category, tags, dedupKey) {
     if (!isValidCategory(category)) {
       return { success: false, error: `Invalid category: ${category}` };
     }
-    const expanded = sourcePath.startsWith("~/") ? join26(process.env.HOME ?? "", sourcePath.slice(2)) : sourcePath;
+    const expanded = sourcePath.startsWith("~/") ? join28(process.env.HOME ?? "", sourcePath.slice(2)) : sourcePath;
     if (!fsExistsSync(expanded)) {
       return { success: false, error: `Source file not found: ${sourcePath}` };
     }
@@ -10009,8 +10404,8 @@ __export(exports_dashboard_server, {
   startDashboardServer: () => startDashboardServer
 });
 import { watch } from "fs";
-import { existsSync as existsSync30 } from "fs";
-import { basename as basename7, dirname as dirname12, join as join27, extname as extname2 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { basename as basename7, dirname as dirname13, join as join29, extname as extname2 } from "path";
 
 class SSEManager {
   clients = new Map;
@@ -10187,15 +10582,15 @@ async function startDashboardServer(cwd, options = {}) {
       timestamp: new Date().toISOString()
     });
   });
-  const __dir = dirname12(new URL(import.meta.url).pathname);
+  const __dir = dirname13(new URL(import.meta.url).pathname);
   let pkgRoot = __dir;
-  while (pkgRoot !== dirname12(pkgRoot)) {
-    if (existsSync30(join27(pkgRoot, "package.json")))
+  while (pkgRoot !== dirname13(pkgRoot)) {
+    if (existsSync32(join29(pkgRoot, "package.json")))
       break;
-    pkgRoot = dirname12(pkgRoot);
+    pkgRoot = dirname13(pkgRoot);
   }
-  const dashboardOutDir = join27(pkgRoot, "dashboard", "out");
-  const dashboardBuilt = existsSync30(join27(dashboardOutDir, "index.html"));
+  const dashboardOutDir = join29(pkgRoot, "dashboard", "out");
+  const dashboardBuilt = existsSync32(join29(dashboardOutDir, "index.html"));
   let clientIdCounter = 0;
   if (!dashboardBuilt) {
     console.warn("[mink] dashboard not built. Run: cd dashboard && bun run build");
@@ -10225,9 +10620,9 @@ async function startDashboardServer(cwd, options = {}) {
         } else {
           let filePath;
           if (pathname === "/") {
-            filePath = join27(dashboardOutDir, "index.html");
+            filePath = join29(dashboardOutDir, "index.html");
           } else {
-            filePath = join27(dashboardOutDir, pathname);
+            filePath = join29(dashboardOutDir, pathname);
           }
           if (!filePath.startsWith(dashboardOutDir)) {
             return jsonResponse({ error: "Forbidden" }, 403);
@@ -10240,7 +10635,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(join27(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
+          const indexServed = await serveFile(join29(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
           if (indexServed)
             return indexServed;
         }
@@ -10349,7 +10744,7 @@ retry: 3000
             if (!filename || filename.includes("..") || filename.includes("/")) {
               return jsonResponse({ error: "Invalid filename" }, 400);
             }
-            const imgPath = join27(designCapturesDir(resolvedCwd), filename);
+            const imgPath = join29(designCapturesDir(resolvedCwd), filename);
             const served = await serveFile(imgPath, "image/jpeg");
             if (served) {
               served.headers.set("Cache-Control", "public, max-age=60");
@@ -10584,9 +10979,9 @@ __export(exports_dashboard, {
   resolveStartupCwd: () => resolveStartupCwd,
   dashboard: () => dashboard
 });
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 function resolveStartupCwd(cwd, registered = listRegisteredProjects()) {
-  if (existsSync31(projectDir(cwd))) {
+  if (existsSync33(projectDir(cwd))) {
     return { kind: "active", cwd };
   }
   if (registered.length === 0) {
@@ -10623,18 +11018,18 @@ var init_dashboard = __esm(() => {
 });
 
 // src/commands/init.ts
-import { mkdirSync as mkdirSync14, existsSync as existsSync32 } from "fs";
-import { resolve as resolve6, dirname as dirname13, basename as basename8, join as join28 } from "path";
+import { mkdirSync as mkdirSync15, existsSync as existsSync34 } from "fs";
+import { resolve as resolve7, dirname as dirname14, basename as basename8, join as join30 } from "path";
 function resolveCliPathFrom2(selfPath) {
-  const selfDir = dirname13(selfPath);
+  const selfDir = dirname14(selfPath);
   if (selfPath.endsWith("dist/cli.js") || selfPath.endsWith("dist/cli.bun.js") || selfPath.endsWith("dist/cli.node.js")) {
-    return join28(selfDir, "cli.js");
+    return join30(selfDir, "cli.js");
   }
-  const packageRoot = resolve6(selfDir, "..", "..");
-  const distShim = join28(packageRoot, "dist", "cli.js");
-  if (existsSync32(distShim))
+  const packageRoot = resolve7(selfDir, "..", "..");
+  const distShim = join30(packageRoot, "dist", "cli.js");
+  if (existsSync34(distShim))
     return distShim;
-  return join28(packageRoot, "src", "cli.ts");
+  return join30(packageRoot, "src", "cli.ts");
 }
 function resolveCliPath2() {
   return resolveCliPathFrom2(new URL(import.meta.url).pathname);
@@ -10676,7 +11071,7 @@ function isMinkHook2(entry) {
   return false;
 }
 function mergeHooksIntoSettings2(settingsPath, newHooks) {
-  mkdirSync14(dirname13(settingsPath), { recursive: true });
+  mkdirSync15(dirname14(settingsPath), { recursive: true });
   const existing = safeReadJson(settingsPath) ?? {};
   const existingHooks = existing.hooks ?? {};
   for (const [event, entries] of Object.entries(newHooks)) {
@@ -10694,13 +11089,16 @@ var init_init2 = __esm(() => {
   init_device();
   init_git_identity();
   init_vault();
+  init_agent_detect();
+  init_agent_pi();
+  init_prompt();
 });
 
 // src/core/daemon-service.ts
-import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname14, join as join29 } from "path";
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync35, mkdirSync as mkdirSync16, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname15, join as join31 } from "path";
 function detectPlatform() {
   if (process.platform === "linux")
     return "systemd";
@@ -10710,11 +11108,11 @@ function detectPlatform() {
 }
 function resolveServiceInvocation() {
   const entry = process.argv[1];
-  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync33(entry)) {
+  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync35(entry)) {
     return {
       executable: entry,
       args: ["daemon", "start"],
-      pathDir: dirname14(entry)
+      pathDir: dirname15(entry)
     };
   }
   const cliPath = resolveCliPath2();
@@ -10722,17 +11120,17 @@ function resolveServiceInvocation() {
   return {
     executable: interpreter,
     args: [cliPath, "daemon", "start"],
-    pathDir: dirname14(interpreter)
+    pathDir: dirname15(interpreter)
   };
 }
 function servicePaths(platform2) {
-  const home = homedir4();
+  const home = homedir5();
   if (platform2 === "systemd") {
-    const unitDir2 = join29(home, ".config", "systemd", "user");
-    return { unitDir: unitDir2, unitFile: join29(unitDir2, "mink-daemon.service") };
+    const unitDir2 = join31(home, ".config", "systemd", "user");
+    return { unitDir: unitDir2, unitFile: join31(unitDir2, "mink-daemon.service") };
   }
-  const unitDir = join29(home, "Library", "LaunchAgents");
-  return { unitDir, unitFile: join29(unitDir, "com.mink.daemon.plist") };
+  const unitDir = join31(home, "Library", "LaunchAgents");
+  return { unitDir, unitFile: join31(unitDir, "com.mink.daemon.plist") };
 }
 function renderSystemdUnit(inv) {
   const execStart = [inv.executable, ...inv.args].join(" ");
@@ -10806,17 +11204,17 @@ function installService(options = {}) {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (existsSync33(paths.unitFile) && !options.force) {
+  if (existsSync35(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();
-  mkdirSync15(paths.unitDir, { recursive: true });
+  mkdirSync16(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:");
@@ -10839,24 +11237,24 @@ function uninstallService() {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (!existsSync33(paths.unitFile)) {
+  if (!existsSync35(paths.unitFile)) {
     console.log(`[mink] no unit file at ${paths.unitFile} — 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}`);
@@ -10871,7 +11269,7 @@ var exports_daemon = {};
 __export(exports_daemon, {
   daemon: () => daemon
 });
-import { readFileSync as readFileSync25, existsSync as existsSync34 } from "fs";
+import { readFileSync as readFileSync25, existsSync as existsSync36 } from "fs";
 async function daemon(cwd, args) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -10887,7 +11285,7 @@ async function daemon(cwd, args) {
       break;
     case "logs": {
       const logPath = schedulerLogPath();
-      if (!existsSync34(logPath)) {
+      if (!existsSync36(logPath)) {
         console.log("[mink] no log file found");
         return;
       }
@@ -11159,13 +11557,13 @@ function printValidKeys() {
   }
 }
 function readLineFromStdin() {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const chunks = [];
     process.stdin.resume();
     process.stdin.setEncoding("utf-8");
     process.stdin.once("data", (data) => {
       process.stdin.pause();
-      resolve8(String(data).trim());
+      resolve9(String(data).trim());
     });
   });
 }
@@ -11240,7 +11638,7 @@ var exports_update = {};
 __export(exports_update, {
   update: () => update
 });
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 function parseArgs(args) {
   let dryRun = false;
   let project = null;
@@ -11298,7 +11696,7 @@ async function update(cwd, args) {
     }
     const backupName = createBackup(target.cwd);
     console.log(`  backup: ${backupName}`);
-    const settingsPath = resolve8(target.cwd, ".claude", "settings.json");
+    const settingsPath = resolve9(target.cwd, ".claude", "settings.json");
     mergeHooksIntoSettings2(settingsPath, newHooks);
     console.log("  hooks: updated");
     const metaPath = projectMetaPath(target.cwd);
@@ -11474,7 +11872,7 @@ var init_restore = __esm(() => {
 
 // src/core/design-eval/server-detect.ts
 import { readFileSync as readFileSync26 } from "fs";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 async function probePort(port) {
   try {
     const controller = new AbortController;
@@ -11496,7 +11894,7 @@ async function findRunningServer(ports = DEFAULT_PROBE_PORTS) {
 }
 function detectDevCommand(cwd) {
   try {
-    const raw = readFileSync26(join30(cwd, "package.json"), "utf-8");
+    const raw = readFileSync26(join32(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts;
     if (!scripts || typeof scripts !== "object")
@@ -11516,10 +11914,10 @@ var init_server_detect = __esm(() => {
 });
 
 // src/core/design-eval/route-detect.ts
-import { existsSync as existsSync35, readdirSync as readdirSync10, statSync as statSync12 } from "fs";
-import { join as join31, relative as relative8, sep as sep2 } from "path";
+import { existsSync as existsSync37, readdirSync as readdirSync10, statSync as statSync12 } from "fs";
+import { join as join33, relative as relative8, sep as sep2 } from "path";
 function detectFramework(cwd) {
-  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync35(join31(cwd, `${name}.${ext}`))) || existsSync35(join31(cwd, name));
+  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync37(join33(cwd, `${name}.${ext}`))) || existsSync37(join33(cwd, name));
   if (has("next.config"))
     return "nextjs";
   if (has("svelte.config"))
@@ -11544,8 +11942,8 @@ function detectRoutes(cwd) {
 }
 function detectNextRoutes(cwd) {
   const routes = [];
-  const appDir = join31(cwd, "app");
-  if (existsSync35(appDir)) {
+  const appDir = join33(cwd, "app");
+  if (existsSync37(appDir)) {
     const pageFiles = findFiles(appDir, /^page\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative8(appDir, file);
@@ -11556,8 +11954,8 @@ function detectNextRoutes(cwd) {
       routes.push(route);
     }
   }
-  const pagesDir = join31(cwd, "pages");
-  if (existsSync35(pagesDir)) {
+  const pagesDir = join33(cwd, "pages");
+  if (existsSync37(pagesDir)) {
     const pageFiles = findFiles(pagesDir, /\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative8(pagesDir, file);
@@ -11576,8 +11974,8 @@ function detectNextRoutes(cwd) {
   return unique.length > 0 ? unique.sort() : ["/"];
 }
 function detectSvelteKitRoutes(cwd) {
-  const routesDir = join31(cwd, "src", "routes");
-  if (!existsSync35(routesDir))
+  const routesDir = join33(cwd, "src", "routes");
+  if (!existsSync37(routesDir))
     return ["/"];
   const routes = [];
   const pageFiles = findFiles(routesDir, /^\+page\.svelte$/);
@@ -11592,8 +11990,8 @@ function detectSvelteKitRoutes(cwd) {
   return routes.length > 0 ? routes.sort() : ["/"];
 }
 function detectNuxtRoutes(cwd) {
-  const pagesDir = join31(cwd, "pages");
-  if (!existsSync35(pagesDir))
+  const pagesDir = join33(cwd, "pages");
+  if (!existsSync37(pagesDir))
     return ["/"];
   const routes = [];
   const vueFiles = findFiles(pagesDir, /\.vue$/);
@@ -11619,7 +12017,7 @@ function findFiles(dir, pattern) {
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
-      const full = join31(current, entry);
+      const full = join33(current, entry);
       try {
         const stat2 = statSync12(full);
         if (stat2.isDirectory()) {
@@ -11647,11 +12045,11 @@ function __extends(d, b) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve9) {
-      resolve9(value);
+    return value instanceof P ? value : new P(function(resolve10) {
+      resolve10(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve9, reject) {
+  return new (P || (P = Promise))(function(resolve10, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -11667,7 +12065,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -11850,14 +12248,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve9, reject) {
-        v = o[n](v), settle(resolve9, reject, v.done, v.value);
+      return new Promise(function(resolve10, reject) {
+        v = o[n](v), settle(resolve10, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve9, reject, d, v) {
+  function settle(resolve10, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve9({ value: v2, done: d });
+      resolve10({ value: v2, done: d });
     }, reject);
   }
 }
@@ -12388,7 +12786,7 @@ function of() {
 }
 function lastValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve9, reject) {
+  return new Promise(function(resolve10, reject) {
     var _hasValue = false;
     var _value;
     source.subscribe({
@@ -12399,9 +12797,9 @@ function lastValueFrom(source, config22) {
       error: reject,
       complete: function() {
         if (_hasValue) {
-          resolve9(_value);
+          resolve10(_value);
         } else if (hasConfig) {
-          resolve9(config22.defaultValue);
+          resolve10(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -12411,16 +12809,16 @@ function lastValueFrom(source, config22) {
 }
 function firstValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve9, reject) {
+  return new Promise(function(resolve10, reject) {
     var subscriber = new SafeSubscriber({
       next: function(value) {
-        resolve9(value);
+        resolve10(value);
         subscriber.unsubscribe();
       },
       error: reject,
       complete: function() {
         if (hasConfig) {
-          resolve9(config22.defaultValue);
+          resolve10(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -13472,7 +13870,7 @@ var init_rxjs = __esm(() => {
     Observable2.prototype.forEach = function(next, promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve9, reject) {
+      return new promiseCtor(function(resolve10, reject) {
         var subscriber = new SafeSubscriber({
           next: function(value) {
             try {
@@ -13483,7 +13881,7 @@ var init_rxjs = __esm(() => {
             }
           },
           error: reject,
-          complete: resolve9
+          complete: resolve10
         });
         _this.subscribe(subscriber);
       });
@@ -13505,14 +13903,14 @@ var init_rxjs = __esm(() => {
     Observable2.prototype.toPromise = function(promiseCtor) {
       var _this = this;
       promiseCtor = getPromiseCtor(promiseCtor);
-      return new promiseCtor(function(resolve9, reject) {
+      return new promiseCtor(function(resolve10, reject) {
         var value;
         _this.subscribe(function(x) {
           return value = x;
         }, function(err) {
           return reject(err);
         }, function() {
-          return resolve9(value);
+          return resolve10(value);
         });
       });
     };
@@ -15438,8 +15836,8 @@ class Deferred {
   #isRejected = false;
   #value;
   #resolve;
-  #taskPromise = new Promise((resolve9) => {
-    this.#resolve = resolve9;
+  #taskPromise = new Promise((resolve10) => {
+    this.#resolve = resolve10;
   });
   #timeoutId;
   #timeoutError;
@@ -15528,12 +15926,12 @@ var init_Mutex = __esm(() => {
       return new Mutex.Guard(this, onRelease);
     }
     release() {
-      const resolve9 = this.#acquirers.shift();
-      if (!resolve9) {
+      const resolve10 = this.#acquirers.shift();
+      if (!resolve10) {
         this.#locked = false;
         return;
       }
-      resolve9();
+      resolve10();
     }
   };
 });
@@ -17277,12 +17675,12 @@ var init_locators = __esm(() => {
       }
       return defer(() => {
         return from(handle.evaluate((element) => {
-          return new Promise((resolve9) => {
+          return new Promise((resolve10) => {
             window.requestAnimationFrame(() => {
               const rect1 = element.getBoundingClientRect();
               window.requestAnimationFrame(() => {
                 const rect2 = element.getBoundingClientRect();
-                resolve9([
+                resolve10([
                   {
                     x: rect1.x,
                     y: rect1.y,
@@ -18573,9 +18971,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((resolve9) => {
+            const visibleRatio = await new Promise((resolve10) => {
               const observer = new IntersectionObserver((entries) => {
-                resolve9(entries[0].intersectionRatio);
+                resolve10(entries[0].intersectionRatio);
                 observer.disconnect();
               });
               observer.observe(element);
@@ -18969,7 +19367,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((resolve9, reject) => {
+          return await new Promise((resolve10, reject) => {
             const script = document.createElement("script");
             script.type = type2;
             script.text = content2;
@@ -18982,12 +19380,12 @@ var init_Frame = __esm(() => {
             if (url) {
               script.src = url;
               script.addEventListener("load", () => {
-                resolve9(script);
+                resolve10(script);
               }, { once: true });
               document.head.appendChild(script);
             } else {
               document.head.appendChild(script);
-              resolve9(script);
+              resolve10(script);
             }
           });
         }, { ...options, type, content }));
@@ -19004,7 +19402,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((resolve9, reject) => {
+          return await new Promise((resolve10, reject) => {
             let element;
             if (!url) {
               element = document.createElement("style");
@@ -19016,7 +19414,7 @@ var init_Frame = __esm(() => {
               element = link;
             }
             element.addEventListener("load", () => {
-              resolve9(element);
+              resolve10(element);
             }, { once: true });
             element.addEventListener("error", (event) => {
               reject(new Error(event.message ?? "Could not load style"));
@@ -19870,9 +20268,9 @@ var init_Page = __esm(() => {
         ++this.#screencastSessionCount;
         if (!this.#startScreencastPromise) {
           this.#startScreencastPromise = this.mainFrame().client.send("Page.startScreencast", { format: "png" }).then(() => {
-            return new Promise((resolve9) => {
+            return new Promise((resolve10) => {
               return this.mainFrame().client.once("Page.screencastFrame", () => {
-                return resolve9();
+                return resolve10();
               });
             });
           });
@@ -22530,11 +22928,11 @@ function addPageBinding(type, name, prefix) {
           return value instanceof Node;
         })
       }));
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         callPuppeteer.callbacks.set(seq, {
           resolve(value) {
             callPuppeteer.args.delete(seq);
-            resolve9(value);
+            resolve10(value);
           },
           reject(value) {
             callPuppeteer.args.delete(seq);
@@ -25997,8 +26395,8 @@ var init_Input2 = __esm(() => {
       if (typeof delay === "number") {
         await Promise.all(actions);
         actions.length = 0;
-        await new Promise((resolve9) => {
-          setTimeout(resolve9, delay);
+        await new Promise((resolve10) => {
+          setTimeout(resolve10, delay);
         });
       }
       actions.push(this.up({ ...options, clickCount }));
@@ -26018,9 +26416,9 @@ var init_Input2 = __esm(() => {
       });
     }
     async drag(start, target) {
-      const promise = new Promise((resolve9) => {
+      const promise = new Promise((resolve10) => {
         this.#client.once("Input.dragIntercepted", (event) => {
-          return resolve9(event.data);
+          return resolve10(event.data);
         });
       });
       await this.move(start.x, start.y);
@@ -26061,8 +26459,8 @@ var init_Input2 = __esm(() => {
       await this.dragEnter(target, data);
       await this.dragOver(target, data);
       if (delay) {
-        await new Promise((resolve9) => {
-          return setTimeout(resolve9, delay);
+        await new Promise((resolve10) => {
+          return setTimeout(resolve10, delay);
         });
       }
       await this.drop(target, data);
@@ -26874,9 +27272,9 @@ var init_Page2 = __esm(() => {
     async captureHeapSnapshot(options) {
       const { createWriteStream } = environment.value.fs;
       const stream = createWriteStream(options.path);
-      const streamPromise = new Promise((resolve9, reject) => {
+      const streamPromise = new Promise((resolve10, reject) => {
         stream.on("error", reject);
-        stream.on("finish", resolve9);
+        stream.on("finish", resolve10);
       });
       const client = this.#primaryTargetClient;
       await client.send("HeapProfiler.enable");
@@ -28389,10 +28787,10 @@ __export(exports_BrowserWebSocketTransport, {
 
 class BrowserWebSocketTransport {
   static create(url) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const ws = new WebSocket(url);
       ws.addEventListener("open", () => {
-        return resolve9(new BrowserWebSocketTransport(ws));
+        return resolve10(new BrowserWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -31226,11 +31624,11 @@ var require_BrowsingContextProcessor = __commonJS((exports) => {
       }
       const parentCdpClient = context2.cdpTarget.parentCdpClient;
       try {
-        const detachedFromTargetPromise = new Promise((resolve9) => {
+        const detachedFromTargetPromise = new Promise((resolve10) => {
           const onContextDestroyed = (event) => {
             if (event.targetId === params.context) {
               parentCdpClient.off("Target.detachedFromTarget", onContextDestroyed);
-              resolve9();
+              resolve10();
             }
           };
           parentCdpClient.on("Target.detachedFromTarget", onContextDestroyed);
@@ -32550,7 +32948,7 @@ var require_ActionDispatcher = __commonJS((exports) => {
         }
       }
       const promises = [
-        new Promise((resolve9) => setTimeout(resolve9, this.#tickDuration))
+        new Promise((resolve10) => setTimeout(resolve10, this.#tickDuration))
       ];
       for (const option of options) {
         promises.push(this.#dispatchAction(option));
@@ -33149,8 +33547,8 @@ var require_Mutex = __commonJS((exports) => {
     acquire() {
       const state = { resolved: false };
       if (this.#locked) {
-        return new Promise((resolve9) => {
-          this.#acquirers.push(() => resolve9(this.#release.bind(this, state)));
+        return new Promise((resolve10) => {
+          this.#acquirers.push(() => resolve10(this.#release.bind(this, state)));
         });
       }
       this.#locked = true;
@@ -33161,12 +33559,12 @@ var require_Mutex = __commonJS((exports) => {
         throw new Error("Cannot release more than once.");
       }
       state.resolved = true;
-      const resolve9 = this.#acquirers.shift();
-      if (!resolve9) {
+      const resolve10 = this.#acquirers.shift();
+      if (!resolve10) {
         this.#locked = false;
         return;
       }
-      resolve9();
+      resolve10();
     }
     async run(action) {
       const release = await this.acquire();
@@ -34293,8 +34691,8 @@ var require_ChannelProxy = __commonJS((exports) => {
         let queueNonEmptyResolver = null;
         return {
           async getMessage() {
-            const onMessage = queue.length > 0 ? Promise.resolve() : new Promise((resolve9) => {
-              queueNonEmptyResolver = resolve9;
+            const onMessage = queue.length > 0 ? Promise.resolve() : new Promise((resolve10) => {
+              queueNonEmptyResolver = resolve10;
             });
             await onMessage;
             return queue.shift();
@@ -34380,7 +34778,7 @@ var require_ChannelProxy = __commonJS((exports) => {
         functionDeclaration: String((id) => {
           const w = window;
           if (w[id] === undefined) {
-            return new Promise((resolve9) => w[id] = resolve9);
+            return new Promise((resolve10) => w[id] = resolve10);
           }
           const channelProxy = w[id];
           delete w[id];
@@ -35731,8 +36129,8 @@ var require_Deferred = __commonJS((exports) => {
       return this.#result;
     }
     constructor() {
-      this.#promise = new Promise((resolve9, reject) => {
-        this.#resolve = resolve9;
+      this.#promise = new Promise((resolve10, reject) => {
+        this.#resolve = resolve10;
         this.#reject = reject;
       });
       this.#promise.catch((_error) => {});
@@ -40057,11 +40455,11 @@ var require_BrowsingContextStorage = __commonJS((exports) => {
       if (this.#contexts.has(browsingContextId)) {
         return Promise.resolve(this.getContext(browsingContextId));
       }
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const listener = (event) => {
           if (event.browsingContext.id === browsingContextId) {
             this.#eventEmitter.off("added", listener);
-            resolve9(event.browsingContext);
+            resolve10(event.browsingContext);
           }
         };
         this.#eventEmitter.on("added", listener);
@@ -43557,8 +43955,8 @@ var init_ExposedFunction = __esm(() => {
       const functionDeclaration = stringifyFunction(interpolateFunction((callback) => {
         Object.assign(globalThis, {
           [PLACEHOLDER("name")]: function(...args) {
-            return new Promise((resolve9, reject) => {
-              callback([resolve9, reject, args]);
+            return new Promise((resolve10, reject) => {
+              callback([resolve10, reject, args]);
             });
           }
         });
@@ -43646,8 +44044,8 @@ var init_ExposedFunction = __esm(() => {
           return;
         }
         try {
-          await dataHandle.evaluate(([resolve9], result2) => {
-            resolve9(result2);
+          await dataHandle.evaluate(([resolve10], result2) => {
+            resolve10(result2);
           }, result);
         } catch (error) {
           debugError(error);
@@ -50939,7 +51337,7 @@ __export(exports_NodeWebSocketTransport, {
 
 class NodeWebSocketTransport {
   static create(url, headers) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const ws = new wrapper_default(url, [], {
         followRedirects: true,
         perMessageDeflate: false,
@@ -50951,7 +51349,7 @@ class NodeWebSocketTransport {
         }
       });
       ws.addEventListener("open", () => {
-        return resolve9(new NodeWebSocketTransport(ws));
+        return resolve10(new NodeWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -53843,8 +54241,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((resolve9, reject) => {
-      req2.once("response", resolve9).once("error", reject).end();
+    const promise = new Promise((resolve10, reject) => {
+      req2.once("response", resolve10).once("error", reject).end();
     });
     req2.then = promise.then.bind(promise);
     return req2;
@@ -54215,7 +54613,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((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       let buffersLength = 0;
       const buffers = [];
       function read() {
@@ -54284,7 +54682,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
         }
         debug2("got proxy server response: %o %o", firstLine, headers);
         cleanup();
-        resolve9({
+        resolve10({
           connect: {
             statusCode,
             statusText,
@@ -56388,11 +56786,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(resolve9) {
-        resolve9(value);
+      return value instanceof P ? value : new P(function(resolve10) {
+        resolve10(value);
       });
     }
-    return new (P || (P = Promise))(function(resolve9, reject) {
+    return new (P || (P = Promise))(function(resolve10, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -56408,7 +56806,7 @@ var require_socksclient = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -56435,13 +56833,13 @@ var require_socksclient = __commonJS((exports) => {
       this.setState(constants_1.SocksClientState.Created);
     }
     static createConnection(options, callback) {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         try {
           (0, helpers_1.validateSocksClientOptions)(options, ["connect"]);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve9(err);
+            return resolve10(err);
           } else {
             return reject(err);
           }
@@ -56452,16 +56850,16 @@ var require_socksclient = __commonJS((exports) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(null, info);
-            resolve9(info);
+            resolve10(info);
           } else {
-            resolve9(info);
+            resolve10(info);
           }
         });
         client.once("error", (err) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(err);
-            resolve9(err);
+            resolve10(err);
           } else {
             reject(err);
           }
@@ -56469,13 +56867,13 @@ var require_socksclient = __commonJS((exports) => {
       });
     }
     static createConnectionChain(options, callback) {
-      return new Promise((resolve9, reject) => __awaiter2(this, undefined, undefined, function* () {
+      return new Promise((resolve10, reject) => __awaiter2(this, undefined, undefined, function* () {
         try {
           (0, helpers_1.validateSocksClientChainOptions)(options);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve9(err);
+            return resolve10(err);
           } else {
             return reject(err);
           }
@@ -56501,14 +56899,14 @@ var require_socksclient = __commonJS((exports) => {
           }
           if (typeof callback === "function") {
             callback(null, { socket: sock });
-            resolve9({ socket: sock });
+            resolve10({ socket: sock });
           } else {
-            resolve9({ socket: sock });
+            resolve10({ socket: sock });
           }
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            resolve9(err);
+            resolve10(err);
           } else {
             reject(err);
           }
@@ -57108,12 +57506,12 @@ var require_dist4 = __commonJS((exports) => {
       let { host } = opts;
       const { port, lookup: lookupFn = dns.lookup } = opts;
       if (shouldLookup) {
-        host = await new Promise((resolve9, reject) => {
+        host = await new Promise((resolve10, reject) => {
           lookupFn(host, {}, (err, res) => {
             if (err) {
               reject(err);
             } else {
-              resolve9(res);
+              resolve10(res);
             }
           });
         });
@@ -58120,7 +58518,7 @@ var require_netUtils = __commonJS((exports) => {
     return `${socket.remoteAddress}:${socket.remotePort}`;
   }
   function upgradeSocket(socket, options) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const tlsOptions = Object.assign({}, options, {
         socket
       });
@@ -58130,7 +58528,7 @@ var require_netUtils = __commonJS((exports) => {
           reject(tlsSocket.authorizationError);
         } else {
           tlsSocket.removeAllListeners("error");
-          resolve9(tlsSocket);
+          resolve10(tlsSocket);
         }
       }).once("error", (error) => {
         reject(error);
@@ -58222,7 +58620,7 @@ var require_transfer = __commonJS((exports) => {
     };
   }
   function connectForPassiveTransfer(host, port, ftp) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       let socket = ftp._newSocket();
       const handleConnErr = function(err) {
         err.message = "Can't open data connection in passive mode: " + err.message;
@@ -58245,7 +58643,7 @@ var require_transfer = __commonJS((exports) => {
         socket.removeListener("error", handleConnErr);
         socket.removeListener("timeout", handleTimeout);
         ftp.dataSocket = socket;
-        resolve9();
+        resolve10();
       });
     });
   }
@@ -60323,7 +60721,7 @@ var require_util2 = __commonJS((exports) => {
     return path;
   }
   exports.normalize = normalize2;
-  function join32(aRoot, aPath) {
+  function join34(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -60355,7 +60753,7 @@ var require_util2 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join32;
+  exports.join = join34;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -60528,7 +60926,7 @@ var require_util2 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join32(urlGenerate(parsed), sourceURL);
+      sourceURL = join34(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -62260,7 +62658,7 @@ var require_escodegen = __commonJS((exports) => {
     function noEmptySpace() {
       return space ? space : " ";
     }
-    function join32(left, right) {
+    function join34(left, right) {
       var leftSource, rightSource, leftCharCode, rightCharCode;
       leftSource = toSourceNodeWhenNeeded(left).toString();
       if (leftSource.length === 0) {
@@ -62601,8 +62999,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
         }
-        result = join32(result, operator);
-        result = [join32(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
+        result = join34(result, operator);
+        result = [join34(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
       });
       result.push(this.maybeBlock(stmt.body, flags));
       return result;
@@ -62740,11 +63138,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (stmt.id) {
-          result = join32(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+          result = join34(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
         }
         if (stmt.superClass) {
-          fragment = join32("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-          result = join32(result, fragment);
+          fragment = join34("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+          result = join34(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -62757,9 +63155,9 @@ var require_escodegen = __commonJS((exports) => {
         return escapeDirective(stmt.directive) + this.semicolon(flags);
       },
       DoWhileStatement: function(stmt, flags) {
-        var result = join32("do", this.maybeBlock(stmt.body, S_TFFF));
+        var result = join34("do", this.maybeBlock(stmt.body, S_TFFF));
         result = this.maybeBlockSuffix(stmt.body, result);
-        return join32(result, [
+        return join34(result, [
           "while" + space + "(",
           this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
           ")" + this.semicolon(flags)
@@ -62795,11 +63193,11 @@ var require_escodegen = __commonJS((exports) => {
       ExportDefaultDeclaration: function(stmt, flags) {
         var result = ["export"], bodyFlags;
         bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-        result = join32(result, "default");
+        result = join34(result, "default");
         if (isStatement(stmt.declaration)) {
-          result = join32(result, this.generateStatement(stmt.declaration, bodyFlags));
+          result = join34(result, this.generateStatement(stmt.declaration, bodyFlags));
         } else {
-          result = join32(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+          result = join34(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
         }
         return result;
       },
@@ -62807,15 +63205,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 join32(result, this.generateStatement(stmt.declaration, bodyFlags));
+          return join34(result, this.generateStatement(stmt.declaration, bodyFlags));
         }
         if (stmt.specifiers) {
           if (stmt.specifiers.length === 0) {
-            result = join32(result, "{" + space + "}");
+            result = join34(result, "{" + space + "}");
           } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-            result = join32(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+            result = join34(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
           } else {
-            result = join32(result, "{");
+            result = join34(result, "{");
             withIndent(function(indent2) {
               var i, iz;
               result.push(newline);
@@ -62833,7 +63231,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(base + "}");
           }
           if (stmt.source) {
-            result = join32(result, [
+            result = join34(result, [
               "from" + space,
               this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
               this.semicolon(flags)
@@ -62917,7 +63315,7 @@ var require_escodegen = __commonJS((exports) => {
         ];
         cursor = 0;
         if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-          result = join32(result, [
+          result = join34(result, [
             this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
           ]);
           ++cursor;
@@ -62927,7 +63325,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(",");
           }
           if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-            result = join32(result, [
+            result = join34(result, [
               space,
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
@@ -62956,7 +63354,7 @@ var require_escodegen = __commonJS((exports) => {
             }
           }
         }
-        result = join32(result, [
+        result = join34(result, [
           "from" + space,
           this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
           this.semicolon(flags)
@@ -63010,7 +63408,7 @@ var require_escodegen = __commonJS((exports) => {
         return result;
       },
       ThrowStatement: function(stmt, flags) {
-        return [join32("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+        return [join34("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
       },
       TryStatement: function(stmt, flags) {
         var result, i, iz, guardedHandlers;
@@ -63018,7 +63416,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 = join32(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+            result = join34(result, this.generateStatement(stmt.handlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
             }
@@ -63026,7 +63424,7 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           guardedHandlers = stmt.guardedHandlers || [];
           for (i = 0, iz = guardedHandlers.length;i < iz; ++i) {
-            result = join32(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+            result = join34(result, this.generateStatement(guardedHandlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
             }
@@ -63034,13 +63432,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 = join32(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                result = join34(result, this.generateStatement(stmt.handler[i], S_TFFF));
                 if (stmt.finalizer || i + 1 !== iz) {
                   result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                 }
               }
             } else {
-              result = join32(result, this.generateStatement(stmt.handler, S_TFFF));
+              result = join34(result, this.generateStatement(stmt.handler, S_TFFF));
               if (stmt.finalizer) {
                 result = this.maybeBlockSuffix(stmt.handler.body, result);
               }
@@ -63048,7 +63446,7 @@ var require_escodegen = __commonJS((exports) => {
           }
         }
         if (stmt.finalizer) {
-          result = join32(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+          result = join34(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
         }
         return result;
       },
@@ -63082,7 +63480,7 @@ var require_escodegen = __commonJS((exports) => {
         withIndent(function() {
           if (stmt.test) {
             result = [
-              join32("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+              join34("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
               ":"
             ];
           } else {
@@ -63130,9 +63528,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 = join32(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+            result = join34(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
           } else {
-            result = join32(result, join32("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+            result = join34(result, join34("else", this.maybeBlock(stmt.alternate, bodyFlags)));
           }
         } else {
           result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -63234,7 +63632,7 @@ var require_escodegen = __commonJS((exports) => {
       },
       ReturnStatement: function(stmt, flags) {
         if (stmt.argument) {
-          return [join32("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+          return [join34("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
         }
         return ["return" + this.semicolon(flags)];
       },
@@ -63316,14 +63714,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 = join32(fragment, expr.operator);
+          result = join34(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 = join32(result, fragment);
+          result = join34(result, fragment);
         }
         if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
           return ["(", result, ")"];
@@ -63363,7 +63761,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 = join32("new", this.generateExpression(expr.callee, Precedence.New, itemFlags));
+        result = join34("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) {
@@ -63410,11 +63808,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment, rightCharCode, leftSource, leftCharCode;
         fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
         if (space === "") {
-          result = join32(expr.operator, fragment);
+          result = join34(expr.operator, fragment);
         } else {
           result = [expr.operator];
           if (expr.operator.length > 2) {
-            result = join32(result, fragment);
+            result = join34(result, fragment);
           } else {
             leftSource = toSourceNodeWhenNeeded(result).toString();
             leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -63437,12 +63835,12 @@ var require_escodegen = __commonJS((exports) => {
           result = "yield";
         }
         if (expr.argument) {
-          result = join32(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
+          result = join34(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
         }
         return parenthesize(result, Precedence.Yield, precedence);
       },
       AwaitExpression: function(expr, precedence, flags) {
-        var result = join32(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
+        var result = join34(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
         return parenthesize(result, Precedence.Await, precedence);
       },
       UpdateExpression: function(expr, precedence, flags) {
@@ -63514,11 +63912,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (expr.id) {
-          result = join32(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+          result = join34(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
         }
         if (expr.superClass) {
-          fragment = join32("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-          result = join32(result, fragment);
+          fragment = join34("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+          result = join34(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(expr.body, S_TFFT));
@@ -63533,7 +63931,7 @@ var require_escodegen = __commonJS((exports) => {
         }
         if (expr.kind === "get" || expr.kind === "set") {
           fragment = [
-            join32(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+            join34(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
             this.generateFunctionBody(expr.value)
           ];
         } else {
@@ -63543,7 +63941,7 @@ var require_escodegen = __commonJS((exports) => {
             this.generateFunctionBody(expr.value)
           ];
         }
-        return join32(result, fragment);
+        return join34(result, fragment);
       },
       Property: function(expr, precedence, flags) {
         if (expr.kind === "get" || expr.kind === "set") {
@@ -63737,7 +64135,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 = join32(result, fragment);
+                result = join34(result, fragment);
               } else {
                 result.push(fragment);
               }
@@ -63745,13 +64143,13 @@ var require_escodegen = __commonJS((exports) => {
           });
         }
         if (expr.filter) {
-          result = join32(result, "if" + space);
+          result = join34(result, "if" + space);
           fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-          result = join32(result, ["(", fragment, ")"]);
+          result = join34(result, ["(", fragment, ")"]);
         }
         if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
           fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-          result = join32(result, fragment);
+          result = join34(result, fragment);
         }
         result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
         return result;
@@ -63767,8 +64165,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
         }
-        fragment = join32(fragment, expr.of ? "of" : "in");
-        fragment = join32(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+        fragment = join34(fragment, expr.of ? "of" : "in");
+        fragment = join34(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
         return ["for" + space + "(", fragment, ")"];
       },
       SpreadElement: function(expr, precedence, flags) {
@@ -70256,11 +70654,11 @@ var require_tslib = __commonJS((exports, module) => {
     };
     __awaiter2 = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve9) {
-          resolve9(value);
+        return value instanceof P ? value : new P(function(resolve10) {
+          resolve10(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve9, reject) {
+      return new (P || (P = Promise))(function(resolve10, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -70276,7 +70674,7 @@ var require_tslib = __commonJS((exports, module) => {
           }
         }
         function step(result) {
-          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve10(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -70505,14 +70903,14 @@ var require_tslib = __commonJS((exports, module) => {
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve9, reject) {
-            v = o[n](v), settle(resolve9, reject, v.done, v.value);
+          return new Promise(function(resolve10, reject) {
+            v = o[n](v), settle(resolve10, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve9, reject, d, v) {
+      function settle(resolve10, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve9({ value: v2, done: d });
+          resolve10({ value: v2, done: d });
         }, reject);
       }
     };
@@ -73751,12 +74149,12 @@ var require_util3 = __commonJS((exports) => {
   exports.isGMT = exports.dnsLookup = undefined;
   var dns_1 = __require("dns");
   function dnsLookup(host, opts) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       (0, dns_1.lookup)(host, opts, (err, res) => {
         if (err) {
           reject(err);
         } else {
-          resolve9(res);
+          resolve10(res);
         }
       });
     });
@@ -74330,10 +74728,10 @@ var require_myIpAddress = __commonJS((exports) => {
   var ip_1 = require_ip();
   var net_1 = __importDefault(__require("net"));
   async function myIpAddress() {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const socket = net_1.default.connect({ host: "8.8.8.8", port: 53 });
       const onError = () => {
-        resolve9(ip_1.ip.address());
+        resolve10(ip_1.ip.address());
       };
       socket.once("error", onError);
       socket.once("connect", () => {
@@ -74341,9 +74739,9 @@ var require_myIpAddress = __commonJS((exports) => {
         const addr = socket.address();
         socket.destroy();
         if (typeof addr === "string") {
-          resolve9(addr);
+          resolve10(addr);
         } else if (addr.address) {
-          resolve9(addr.address);
+          resolve10(addr.address);
         } else {
           reject(new Error("Expected a `string`"));
         }
@@ -74857,8 +75255,8 @@ var require_deferred_promise = __commonJS((exports) => {
       this.context = args.context;
       this.owner = args.context.runtime;
       this.handle = args.promiseHandle;
-      this.settled = new Promise((resolve9) => {
-        this.onSettled = resolve9;
+      this.settled = new Promise((resolve10) => {
+        this.onSettled = resolve10;
       });
       this.resolveHandle = args.resolveHandle;
       this.rejectHandle = args.rejectHandle;
@@ -75250,13 +75648,13 @@ var require_context = __commonJS((exports) => {
       if (vmResolveResult.error) {
         return Promise.resolve(vmResolveResult);
       }
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         lifetime_1.Scope.withScope((scope) => {
           const resolveHandle = scope.manage(this.newFunction("resolve", (value) => {
-            resolve9({ value: value && value.dup() });
+            resolve10({ value: value && value.dup() });
           }));
           const rejectHandle = scope.manage(this.newFunction("reject", (error) => {
-            resolve9({ error: error && error.dup() });
+            resolve10({ error: error && error.dup() });
           }));
           const promiseHandle = scope.manage(vmResolveResult.value);
           const promiseThenHandle = scope.manage(this.getProp(promiseHandle, "then"));
@@ -77370,13 +77768,13 @@ import * as http from "node:http";
 import * as https from "node:https";
 import { URL as URL2, urlToHttpOptions } from "node:url";
 function headHttpRequest(url) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const request3 = httpRequest(url, "HEAD", (response) => {
       response.resume();
-      resolve9(response.statusCode === 200);
+      resolve10(response.statusCode === 200);
     }, false);
     request3.on("error", () => {
-      resolve9(false);
+      resolve10(false);
     });
   });
 }
@@ -77404,7 +77802,7 @@ function httpRequest(url, method, response, keepAlive = true) {
   return request3;
 }
 function downloadFile(url, destinationPath, progressCallback) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let downloadedBytes = 0;
     let totalBytes = 0;
     function onData(chunk) {
@@ -77420,7 +77818,7 @@ function downloadFile(url, destinationPath, progressCallback) {
       }
       const file = createWriteStream(destinationPath);
       file.on("close", () => {
-        return resolve9();
+        return resolve10();
       });
       file.on("error", (error) => {
         return reject(error);
@@ -77445,7 +77843,7 @@ async function getJSON(url) {
   }
 }
 function getText(url) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const request3 = httpRequest(url, "GET", (response) => {
       let data = "";
       if (response.statusCode && response.statusCode >= 400) {
@@ -77456,7 +77854,7 @@ function getText(url) {
       });
       response.on("end", () => {
         try {
-          return resolve9(String(data));
+          return resolve10(String(data));
         } catch {
           return reject(new Error(`Failed to read text response from ${url}`));
         }
@@ -77473,7 +77871,7 @@ var init_httpUtil = __esm(() => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js
-import { execSync as execSync8 } from "node:child_process";
+import { execSync as execSync9 } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 function folder(platform2) {
@@ -77563,7 +77961,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();
@@ -77574,7 +77972,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();
@@ -77590,7 +77988,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) {
@@ -78677,7 +79075,7 @@ class Process {
     if (opts.onExit) {
       this.#onExitHook = opts.onExit;
     }
-    this.#browserProcessExiting = new Promise((resolve9, reject) => {
+    this.#browserProcessExiting = new Promise((resolve10, reject) => {
       this.#browserProcess.once("exit", async () => {
         debugLaunch(`Browser process ${this.#browserProcess.pid} onExit`);
         this.#clearListeners();
@@ -78688,7 +79086,7 @@ class Process {
           reject(err);
           return;
         }
-        resolve9();
+        resolve10();
       });
     });
   }
@@ -78798,7 +79196,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
     return [...this.#logs];
   }
   waitForLineOutput(regex, timeout2 = 0) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const onClose = (errorOrCode) => {
         cleanup();
         reject(new Error([
@@ -78836,7 +79234,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
           return;
         }
         cleanup();
-        resolve9(match[1]);
+        resolve10(match[1]);
       }
     });
   }
@@ -79366,7 +79764,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     let stream;
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -79378,7 +79776,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve9();
+        resolve10();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -80739,7 +81137,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((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -80748,7 +81146,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug4("zip extraction complete");
-            resolve9();
+            resolve10();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -82090,8 +82488,8 @@ var require_streamx = __commonJS((exports, module) => {
           return this;
         },
         next() {
-          return new Promise(function(resolve9, reject) {
-            promiseResolve = resolve9;
+          return new Promise(function(resolve10, reject) {
+            promiseResolve = resolve10;
             promiseReject = reject;
             const data = stream.read();
             if (data !== null)
@@ -82128,14 +82526,14 @@ var require_streamx = __commonJS((exports, module) => {
       }
       function destroy(err) {
         stream.destroy(err);
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           if (stream._duplexState & DESTROYED)
-            return resolve9({ value: undefined, done: true });
+            return resolve10({ value: undefined, done: true });
           stream.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve9({ value: undefined, done: true });
+              resolve10({ value: undefined, done: true });
           });
         });
       }
@@ -82187,8 +82585,8 @@ var require_streamx = __commonJS((exports, module) => {
         return Promise.resolve(true);
       if (state.drains === null)
         state.drains = [];
-      return new Promise((resolve9) => {
-        state.drains.push({ writes, resolve: resolve9 });
+      return new Promise((resolve10) => {
+        state.drains.push({ writes, resolve: resolve10 });
       });
     }
     write(data) {
@@ -82302,11 +82700,11 @@ var require_streamx = __commonJS((exports, module) => {
     cb(null);
   }
   function pipelinePromise(...streams) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       return pipeline(...streams, (err) => {
         if (err)
           return reject(err);
-        resolve9();
+        resolve10();
       });
     });
   }
@@ -83020,16 +83418,16 @@ var require_extract = __commonJS((exports, module) => {
         entryCallback = null;
         cb(err);
       }
-      function onnext(resolve9, reject) {
+      function onnext(resolve10, reject) {
         if (error) {
           return reject(error);
         }
         if (entryStream) {
-          resolve9({ value: entryStream, done: false });
+          resolve10({ value: entryStream, done: false });
           entryStream = null;
           return;
         }
-        promiseResolve = resolve9;
+        promiseResolve = resolve10;
         promiseReject = reject;
         consumeCallback(null);
         if (extract._finished && promiseResolve) {
@@ -83060,14 +83458,14 @@ var require_extract = __commonJS((exports, module) => {
       function destroy(err) {
         extract.destroy(err);
         consumeCallback(err);
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           if (extract.destroyed)
-            return resolve9({ value: undefined, done: true });
+            return resolve10({ value: undefined, done: true });
           extract.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve9({ value: undefined, done: true });
+              resolve10({ value: undefined, done: true });
           });
         });
       }
@@ -83865,7 +84263,7 @@ var init_fileUtil = __esm(() => {
 // node_modules/@puppeteer/browsers/lib/esm/install.js
 import assert2 from "node:assert";
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync36, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync38, readFileSync as readFileSync27 } from "node:fs";
 import { mkdir as mkdir2, unlink } from "node:fs/promises";
 import os5 from "node:os";
 import path8 from "node:path";
@@ -83918,7 +84316,7 @@ async function installWithProviders(options) {
         continue;
       }
       debugInstall(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync36(browserRoot)) {
+      if (!existsSync38(browserRoot)) {
         await mkdir2(browserRoot, { recursive: true });
       }
       return await installUrl(url, options, provider);
@@ -83951,7 +84349,7 @@ async function installDeps(installedBrowser) {
     return;
   }
   const depsPath = path8.join(path8.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync36(depsPath)) {
+  if (!existsSync38(depsPath)) {
     debugInstall(`deb.deps file was not found at ${depsPath}`);
     return;
   }
@@ -83993,11 +84391,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 (!existsSync36(browserRoot)) {
+  if (!existsSync38(browserRoot)) {
     await mkdir2(browserRoot, { recursive: true });
   }
   if (!options.unpack) {
-    if (existsSync36(archivePath)) {
+    if (existsSync38(archivePath)) {
       return archivePath;
     }
     debugInstall(`Downloading binary from ${url}`);
@@ -84018,8 +84416,8 @@ async function installUrl(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
   }
   try {
-    if (existsSync36(outputPath)) {
-      if (!existsSync36(installedBrowser.executablePath)) {
+    if (existsSync38(outputPath)) {
+      if (!existsSync38(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup(installedBrowser);
@@ -84028,7 +84426,7 @@ async function installUrl(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync36(archivePath)) {
+    if (!existsSync38(archivePath)) {
       debugInstall(`Downloading binary from ${url}`);
       try {
         debugTime("download");
@@ -84057,7 +84455,7 @@ async function installUrl(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync36(archivePath)) {
+    if (existsSync38(archivePath)) {
       await unlink(archivePath);
     }
   }
@@ -84068,7 +84466,7 @@ async function runSetup(installedBrowser) {
       debugTime("permissions");
       const browserDir = path8.dirname(installedBrowser.executablePath);
       const setupExePath = path8.join(browserDir, "setup.exe");
-      if (!existsSync36(setupExePath)) {
+      if (!existsSync38(setupExePath)) {
         return;
       }
       spawnSync4(path8.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
@@ -84449,19 +84847,19 @@ var init_cliui = __esm(() => {
 });
 
 // node_modules/escalade/sync/index.mjs
-import { dirname as dirname15, resolve as resolve10 } from "path";
+import { dirname as dirname16, resolve as resolve11 } from "path";
 import { readdirSync as readdirSync11, statSync as statSync13 } from "fs";
 function sync_default(start, callback) {
-  let dir = resolve10(".", start);
+  let dir = resolve11(".", start);
   let tmp, stats = statSync13(dir);
   if (!stats.isDirectory()) {
-    dir = dirname15(dir);
+    dir = dirname16(dir);
   }
   while (true) {
     tmp = callback(dir, readdirSync11(dir));
     if (tmp)
-      return resolve10(dir, tmp);
-    dir = dirname15(tmp = dir);
+      return resolve11(dir, tmp);
+    dir = dirname16(tmp = dir);
     if (tmp === dir)
       break;
   }
@@ -85407,7 +85805,7 @@ var init_yargs_parser = __esm(() => {
 
 // node_modules/yargs-parser/build/lib/index.js
 import { format } from "util";
-import { normalize as normalize2, resolve as resolve11 } from "path";
+import { normalize as normalize2, resolve as resolve12 } 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;
@@ -85430,7 +85828,7 @@ var init_lib2 = __esm(() => {
     },
     format,
     normalize: normalize2,
-    resolve: resolve11,
+    resolve: resolve12,
     require: (path9) => {
       if (true) {
         return __require(path9);
@@ -85482,7 +85880,7 @@ var init_yerror = __esm(() => {
 // node_modules/y18n/build/lib/platform-shims/node.js
 import { readFileSync as readFileSync28, statSync as statSync14, writeFile } from "fs";
 import { format as format2 } from "util";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var node_default;
 var init_node = __esm(() => {
   node_default = {
@@ -85491,7 +85889,7 @@ var init_node = __esm(() => {
       writeFile
     },
     format: format2,
-    resolve: resolve12,
+    resolve: resolve13,
     exists: (file) => {
       try {
         return statSync14(file).isFile();
@@ -85674,7 +86072,7 @@ import { notStrictEqual, strictEqual } from "assert";
 import { inspect } from "util";
 import { readFileSync as readFileSync29 } from "fs";
 import { fileURLToPath } from "url";
-import { basename as basename9, dirname as dirname16, extname as extname3, relative as relative9, resolve as resolve13 } from "path";
+import { basename as basename9, dirname as dirname17, extname as extname3, relative as relative9, resolve as resolve14 } 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();
@@ -85707,10 +86105,10 @@ var init_esm = __esm(() => {
     Parser: lib_default,
     path: {
       basename: basename9,
-      dirname: dirname16,
+      dirname: dirname17,
       extname: extname3,
       relative: relative9,
-      resolve: resolve13
+      resolve: resolve14
     },
     process: {
       argv: () => process.argv,
@@ -85732,7 +86130,7 @@ var init_esm = __esm(() => {
       return [...str].length;
     },
     y18n: y18n_default({
-      directory: resolve13(__dirname2, "../../../locales"),
+      directory: resolve14(__dirname2, "../../../locales"),
       updateFiles: false
     })
   };
@@ -87980,12 +88378,12 @@ var init_yargs_factory = __esm(() => {
     async getCompletion(args, done) {
       argsert("<array> [function]", [args, done], arguments.length);
       if (!done) {
-        return new Promise((resolve14, reject) => {
+        return new Promise((resolve15, reject) => {
           __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
             if (err)
               reject(err);
             else
-              resolve14(completions);
+              resolve15(completions);
           });
         });
       } else {
@@ -89420,9 +89818,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: join33 } = await import("node:path");
+    const { join: join35 } = await import("node:path");
     const userDataDir = resolveDefaultUserDataDir3(Browser7.CHROME, platform2, convertPuppeteerChannelToBrowsersChannel2(options.channel));
-    const portPath = join33(userDataDir, "DevToolsActivePort");
+    const portPath = join35(userDataDir, "DevToolsActivePort");
     try {
       const fileContent = await environment.value.fs.promises.readFile(portPath, "ascii");
       const [rawPort, rawPath] = fileContent.split(`
@@ -89646,9 +90044,9 @@ var init_PipeTransport = __esm(() => {
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js
-import { existsSync as existsSync37 } from "node:fs";
+import { existsSync as existsSync39 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join33 } from "node:path";
+import { join as join35 } from "node:path";
 
 class BrowserLauncher {
   #browser;
@@ -89673,7 +90071,7 @@ class BrowserLauncher {
       ...options,
       protocol
     });
-    if (!existsSync37(launchArgs.executablePath)) {
+    if (!existsSync39(launchArgs.executablePath)) {
       throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
     }
     const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
@@ -89748,7 +90146,7 @@ class BrowserLauncher {
       browserCloseCallback();
       const logs = browserProcess.getRecentLogs().join(`
 `);
-      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync37(join33(launchArgs.userDataDir, "lockfile"))) {
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync39(join35(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) {
@@ -89838,12 +90236,12 @@ class BrowserLauncher {
     });
   }
   getProfilePath() {
-    return join33(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+    return join35(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
   }
   resolveExecutablePath(headless, validatePath = true) {
     let executablePath = this.puppeteer.configuration.executablePath;
     if (executablePath) {
-      if (validatePath && !existsSync37(executablePath)) {
+      if (validatePath && !existsSync39(executablePath)) {
         throw new Error(`Tried to find the browser at the configured path (${executablePath}), but no executable was found.`);
       }
       return executablePath;
@@ -89866,7 +90264,7 @@ class BrowserLauncher {
       browser: browserType,
       buildId: this.puppeteer.browserVersion
     });
-    if (validatePath && !existsSync37(executablePath)) {
+    if (validatePath && !existsSync39(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.`);
@@ -90404,7 +90802,7 @@ var init_PuppeteerNode = __esm(() => {
 import { spawn as spawn2, spawnSync as spawnSync5 } from "node:child_process";
 import fs5 from "node:fs";
 import os8 from "node:os";
-import { dirname as dirname17 } from "node:path";
+import { dirname as dirname18 } from "node:path";
 import { PassThrough } from "node:stream";
 var import_debug6, __runInitializers22 = function(thisArg, initializers, value) {
   var useValue = arguments.length > 2;
@@ -90478,8 +90876,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((resolve14) => {
-            this.#process.stdin.write(buffer, resolve14);
+          const error = await new Promise((resolve15) => {
+            this.#process.stdin.write(buffer, resolve15);
           });
           if (error) {
             console.log(`ffmpeg failed to write: ${error.message}.`);
@@ -90528,7 +90926,7 @@ var init_ScreenRecorder = __esm(() => {
           filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
         }
         if (path11) {
-          fs5.mkdirSync(dirname17(path11), { recursive: overwrite });
+          fs5.mkdirSync(dirname18(path11), { recursive: overwrite });
         }
         this.#process = spawn2(ffmpegPath, [
           ["-loglevel", "error"],
@@ -90634,8 +91032,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((resolve14) => {
-          this.#process.once("close", resolve14);
+        await new Promise((resolve15) => {
+          this.#process.once("close", resolve15);
         });
       }
       async[(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
@@ -90681,17 +91079,17 @@ var init_puppeteer_core = __esm(() => {
 });
 
 // src/core/design-eval/capture.ts
-import { mkdirSync as mkdirSync16, statSync as statSync15, existsSync as existsSync38 } from "fs";
-import { join as join34 } from "path";
+import { mkdirSync as mkdirSync17, statSync as statSync15, existsSync as existsSync40 } from "fs";
+import { join as join36 } from "path";
 function findBrowser() {
   const platform2 = process.platform;
   const paths = CHROME_PATHS[platform2] ?? [];
   for (const p of paths) {
-    if (existsSync38(p))
+    if (existsSync40(p))
       return p;
   }
-  const minkBrowsers = join34(minkRoot(), "browsers");
-  if (existsSync38(minkBrowsers)) {
+  const minkBrowsers = join36(minkRoot(), "browsers");
+  if (existsSync40(minkBrowsers)) {
     const found = findChromeInDir(minkBrowsers);
     if (found)
       return found;
@@ -90712,7 +91110,7 @@ function findChromeInDir(dir) {
   try {
     const entries = readdirSync12(dir);
     for (const entry of entries) {
-      const full = join34(dir, entry);
+      const full = join36(dir, entry);
       try {
         const stat2 = statSync16(full);
         if (stat2.isDirectory()) {
@@ -90760,7 +91158,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 = join34(options.outputDir, fileName);
+    const filePath = join36(options.outputDir, fileName);
     await page.screenshot({
       path: filePath,
       type: "jpeg",
@@ -90792,7 +91190,7 @@ async function captureRoute(page, route, baseUrl, viewport, options) {
   return results;
 }
 async function captureAllRoutes(routes, baseUrl, viewports, options, outputDir) {
-  mkdirSync16(outputDir, { recursive: true });
+  mkdirSync17(outputDir, { recursive: true });
   const executablePath = findBrowser();
   const browser = await puppeteer_core_default.launch({
     executablePath,
@@ -92229,9 +92627,9 @@ var exports_wiki = {};
 __export(exports_wiki, {
   wiki: () => wiki
 });
-import { existsSync as existsSync39, statSync as statSync16 } from "fs";
-import { resolve as resolve14 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync41, statSync as statSync16 } from "fs";
+import { resolve as resolve15 } from "path";
+import { homedir as homedir6 } from "os";
 async function wiki(_cwd, args) {
   const sub = args[0];
   switch (sub) {
@@ -92287,7 +92685,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 = existsSync39(targetPath) && statSync16(targetPath).isDirectory();
+  const isExisting = existsSync41(targetPath) && statSync16(targetPath).isDirectory();
   setConfigValue("wiki.path", targetPath);
   ensureVaultStructure();
   seedTemplates(vaultTemplates());
@@ -92497,9 +92895,9 @@ function wikiLinks() {
 }
 function expandPath(raw) {
   if (raw.startsWith("~/")) {
-    return resolve14(homedir5(), raw.slice(2));
+    return resolve15(homedir6(), raw.slice(2));
   }
-  return resolve14(raw);
+  return resolve15(raw);
 }
 var init_wiki = __esm(() => {
   init_vault();
@@ -92515,8 +92913,8 @@ var exports_note = {};
 __export(exports_note, {
   note: () => note
 });
-import { resolve as resolve15 } from "path";
-import { existsSync as existsSync40, readFileSync as readFileSync30 } from "fs";
+import { resolve as resolve16 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync30 } from "fs";
 async function note(cwd, args) {
   if (!isWikiEnabled()) {
     console.error("[mink] wiki feature is disabled");
@@ -92546,8 +92944,8 @@ async function note(cwd, args) {
     return;
   }
   if (parsed.file) {
-    const sourcePath = resolve15(cwd, parsed.file);
-    if (!existsSync40(sourcePath)) {
+    const sourcePath = resolve16(cwd, parsed.file);
+    if (!existsSync42(sourcePath)) {
       console.error(`[mink] file not found: ${sourcePath}`);
       process.exit(1);
     }
@@ -92708,39 +93106,39 @@ var exports_skill = {};
 __export(exports_skill, {
   skill: () => skill
 });
-import { join as join35, resolve as resolve16, dirname as dirname18 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join37, resolve as resolve17, dirname as dirname19 } from "path";
+import { homedir as homedir7 } from "os";
 import {
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync17,
-  copyFileSync,
+  existsSync as existsSync43,
+  mkdirSync as mkdirSync18,
+  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 = dirname18(new URL(import.meta.url).pathname);
+  let dir = dirname19(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync41(join35(dir, "package.json")) && existsSync41(join35(dir, "skills"))) {
-      return join35(dir, "skills");
+    if (existsSync43(join37(dir, "package.json")) && existsSync43(join37(dir, "skills"))) {
+      return join37(dir, "skills");
     }
-    const parent = dirname18(dir);
+    const parent = dirname19(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve16(dirname18(new URL(import.meta.url).pathname), "../../skills");
+  return resolve17(dirname19(new URL(import.meta.url).pathname), "../../skills");
 }
 function getAvailableSkills() {
   const dir = getSkillsSourceDir();
-  if (!existsSync41(dir))
+  if (!existsSync43(dir))
     return [];
-  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync41(join35(dir, d.name, "SKILL.md"))).map((d) => d.name);
+  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync43(join37(dir, d.name, "SKILL.md"))).map((d) => d.name);
 }
 function isInstalled(skillName) {
-  return existsSync41(join35(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
+  return existsSync43(join37(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
 }
 async function skill(args) {
   const sub = args[0];
@@ -92774,28 +93172,28 @@ function skillInstall(name) {
     console.error("  Expected skills at: " + sourceDir);
     return;
   }
-  mkdirSync17(AGENTS_SKILLS_DIR, { recursive: true });
+  mkdirSync18(AGENTS_SKILLS_DIR, { recursive: true });
   for (const skillName of skills) {
-    const srcDir = join35(sourceDir, skillName);
-    const srcFile = join35(srcDir, "SKILL.md");
-    const destDir = join35(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync41(srcFile)) {
+    const srcDir = join37(sourceDir, skillName);
+    const srcFile = join37(srcDir, "SKILL.md");
+    const destDir = join37(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync43(srcFile)) {
       console.error(`[mink] skill not found: ${skillName}`);
       continue;
     }
-    mkdirSync17(destDir, { recursive: true });
+    mkdirSync18(destDir, { recursive: true });
     copyDirRecursive2(srcDir, destDir);
-    mkdirSync17(CLAUDE_SKILLS_DIR, { recursive: true });
-    const symlink = join35(CLAUDE_SKILLS_DIR, skillName);
+    mkdirSync18(CLAUDE_SKILLS_DIR, { recursive: true });
+    const symlink = join37(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync41(symlink)) {
+      if (existsSync43(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 = join35("..", "..", ".agents", "skills", skillName);
+      const relativeTarget = join37("..", "..", ".agents", "skills", skillName);
       symlinkSync2(relativeTarget, symlink);
     } catch {}
     console.log(`[mink] installed: ${skillName} -> ${destDir}`);
@@ -92806,15 +93204,15 @@ function skillInstall(name) {
 function skillUninstall(name) {
   const skills = name ? [name] : getAvailableSkills();
   for (const skillName of skills) {
-    const destDir = join35(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync41(destDir)) {
+    const destDir = join37(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync43(destDir)) {
       console.log(`[mink] not installed: ${skillName}`);
       continue;
     }
-    rmSync2(destDir, { recursive: true, force: true });
-    const symlink = join35(CLAUDE_SKILLS_DIR, skillName);
+    rmSync3(destDir, { recursive: true, force: true });
+    const symlink = join37(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync41(symlink))
+      if (existsSync43(symlink))
         unlinkSync6(symlink);
     } catch {}
     console.log(`[mink] uninstalled: ${skillName}`);
@@ -92829,7 +93227,7 @@ function skillList() {
   if (installed.length > 0) {
     console.log("  Installed:");
     for (const s of installed) {
-      console.log(`    ${s}  (${join35(AGENTS_SKILLS_DIR, s)})`);
+      console.log(`    ${s}  (${join37(AGENTS_SKILLS_DIR, s)})`);
     }
   }
   if (notInstalled.length > 0) {
@@ -92848,20 +93246,20 @@ function skillList() {
 function copyDirRecursive2(src, dest) {
   const entries = readdirSync12(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join35(src, entry.name);
-    const destPath = join35(dest, entry.name);
+    const srcPath = join37(src, entry.name);
+    const destPath = join37(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync17(destPath, { recursive: true });
+      mkdirSync18(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 = join35(homedir6(), ".agents", "skills");
-  CLAUDE_SKILLS_DIR = join35(homedir6(), ".claude", "skills");
+  AGENTS_SKILLS_DIR = join37(homedir7(), ".agents", "skills");
+  CLAUDE_SKILLS_DIR = join37(homedir7(), ".claude", "skills");
 });
 
 // src/commands/agent.ts
@@ -92869,41 +93267,41 @@ var exports_agent = {};
 __export(exports_agent, {
   agent: () => agent
 });
-import { join as join36, resolve as resolve17, dirname as dirname19 } from "path";
-import { homedir as homedir7 } from "os";
+import { join as join38, resolve as resolve18, dirname as dirname20 } from "path";
+import { homedir as homedir8 } from "os";
 import {
-  existsSync as existsSync42,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync19,
   readFileSync as readFileSync31,
   writeFileSync as writeFileSync11
 } from "fs";
 import { createHash as createHash5 } from "crypto";
 import { spawnSync as spawnSync6 } from "child_process";
 function getAgentTemplatePath() {
-  let dir = dirname19(new URL(import.meta.url).pathname);
+  let dir = dirname20(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync42(join36(dir, "package.json")) && existsSync42(join36(dir, "agents", TEMPLATE_FILE))) {
-      return join36(dir, "agents", TEMPLATE_FILE);
+    if (existsSync44(join38(dir, "package.json")) && existsSync44(join38(dir, "agents", TEMPLATE_FILE))) {
+      return join38(dir, "agents", TEMPLATE_FILE);
     }
-    const parent = dirname19(dir);
+    const parent = dirname20(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve17(dirname19(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
+  return resolve18(dirname20(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
 }
 function getMinkVersion() {
-  let dir = dirname19(new URL(import.meta.url).pathname);
+  let dir = dirname20(new URL(import.meta.url).pathname);
   while (true) {
-    const pkgPath = join36(dir, "package.json");
-    if (existsSync42(pkgPath)) {
+    const pkgPath = join38(dir, "package.json");
+    if (existsSync44(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync31(pkgPath, "utf-8"));
         if (pkg.name && pkg.version)
           return pkg.version;
       } catch {}
     }
-    const parent = dirname19(dir);
+    const parent = dirname20(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -92921,19 +93319,19 @@ function sha2562(text) {
   return createHash5("sha256").update(text).digest("hex");
 }
 function claudeAgentsDir() {
-  return join36(homedir7(), ".claude", "agents");
+  return join38(homedir8(), ".claude", "agents");
 }
 function installedAgentPath() {
-  return join36(claudeAgentsDir(), INSTALLED_FILE);
+  return join38(claudeAgentsDir(), INSTALLED_FILE);
 }
 function installAgentDefinition(opts) {
   const templatePath = getAgentTemplatePath();
-  if (!existsSync42(templatePath)) {
+  if (!existsSync44(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 && existsSync42(installed)) {
+  if (opts.skip && existsSync44(installed)) {
     return { action: "skipped", path: installed };
   }
   const template = readFileSync31(templatePath, "utf-8");
@@ -92942,14 +93340,14 @@ function installAgentDefinition(opts) {
     VAULT_PATH: resolveVaultPath(),
     MINK_VERSION: getMinkVersion()
   });
-  const exists = existsSync42(installed);
+  const exists = existsSync44(installed);
   if (!opts.force && exists) {
     const current = readFileSync31(installed, "utf-8");
     if (sha2562(current) === sha2562(rendered)) {
       return { action: "unchanged", path: installed };
     }
   }
-  mkdirSync18(claudeAgentsDir(), { recursive: true });
+  mkdirSync19(claudeAgentsDir(), { recursive: true });
   writeFileSync11(installed, rendered);
   return {
     action: exists ? "updated" : "installed",
@@ -93020,8 +93418,8 @@ async function agent(_cwd, rawArgs) {
   }
   const skipUpdate = args.noUpdate || process.env.MINK_AGENT_NO_UPDATE === "1";
   const root = minkRoot();
-  if (!existsSync42(root)) {
-    mkdirSync18(root, { recursive: true });
+  if (!existsSync44(root)) {
+    mkdirSync19(root, { recursive: true });
   }
   let result;
   try {
@@ -93072,13 +93470,13 @@ var init_agent = __esm(() => {
 });
 
 // src/core/sync-merge-drivers.ts
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync2, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
-import { join as join37 } from "path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync3, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
+import { join as join39 } 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(join37(minkRoot(), "sync-warnings.log"), line);
+    appendFileSync2(join39(minkRoot(), "sync-warnings.log"), line);
   } catch {}
 }
 function readJsonOrNull(path12) {
@@ -93313,7 +93711,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");
@@ -93829,8 +94227,22 @@ switch (command2) {
     sessionStop(sessionPath2(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": {
@@ -93974,12 +94386,12 @@ switch (command2) {
   case "version":
   case "--version":
   case "-v": {
-    const { resolve: resolve18, dirname: dirname20, basename: basename10 } = await import("path");
+    const { resolve: resolve19, dirname: dirname21, basename: basename10 } = await import("path");
     const bundlePath = new URL(import.meta.url).pathname;
-    const cliPath = resolve18(dirname20(bundlePath));
+    const cliPath = resolve19(dirname21(bundlePath));
     const { readFileSync: readFileSync33 } = await import("fs");
     try {
-      const pkg = JSON.parse(readFileSync33(resolve18(cliPath, "../package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync33(resolve19(cliPath, "../package.json"), "utf-8"));
       console.log(`mink ${pkg.version}`);
     } catch {
       console.log("mink (unknown version)");
@@ -94002,7 +94414,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");