@drewpayment/mink 0.13.0-beta.1 → 0.13.0-beta.3

package/dist/cli.bun.js

@@ -421,6 +421,41 @@ var init_config = __esm(() => {
       envVar: "MINK_PROJECTS_IDENTITY",
       description: "Project identity strategy: path-derived (legacy) or git-remote (stable across machines)",
       scope: "shared"
+    },
+    {
+      key: "compression.enabled",
+      default: "false",
+      envVar: "MINK_COMPRESSION_ENABLED",
+      description: "Enable tool-output compression (spec 21). Off until inline compression ships.",
+      scope: "shared"
+    },
+    {
+      key: "compression.threshold-tokens",
+      default: "800",
+      envVar: "MINK_COMPRESSION_THRESHOLD_TOKENS",
+      description: "Minimum estimated token size before a tool output is eligible for compression",
+      scope: "shared"
+    },
+    {
+      key: "compression.min-savings-ratio",
+      default: "0.25",
+      envVar: "MINK_COMPRESSION_MIN_SAVINGS_RATIO",
+      description: "Discard a compression attempt unless it saves at least this fraction of tokens",
+      scope: "shared"
+    },
+    {
+      key: "compression.holdout-fraction",
+      default: "0.1",
+      envVar: "MINK_COMPRESSION_HOLDOUT_FRACTION",
+      description: "Fraction of eligible outputs left uncompressed as a measured control group",
+      scope: "shared"
+    },
+    {
+      key: "compression.retention-hours",
+      default: "168",
+      envVar: "MINK_COMPRESSION_RETENTION_HOURS",
+      description: "How long compressed originals stay retrievable before eviction",
+      scope: "shared"
     }
   ];
   VALID_KEYS = new Set(CONFIG_KEYS.map((k) => k.key));
@@ -3095,7 +3130,7 @@ function readMeta(db, key) {
 function writeMeta(db, key, value) {
   db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
 }
-var SCHEMA_VERSION = 1, INITIAL_SCHEMA = `
+var SCHEMA_VERSION = 3, INITIAL_SCHEMA = `
 CREATE TABLE IF NOT EXISTS meta (
   key   TEXT PRIMARY KEY,
   value TEXT NOT NULL
@@ -3257,6 +3292,55 @@ CREATE TABLE IF NOT EXISTS counters (
   file_index_hits   INTEGER NOT NULL DEFAULT 0,
   file_index_misses INTEGER NOT NULL DEFAULT 0
 );
+
+-- Tool-output compression measurement (spec 21). One row per compression
+-- decision: either a compressed arm (compressed_tokens < original_tokens) or a
+-- holdout arm (left uncompressed for control, compressed_tokens = original_tokens).
+-- These are append-only telemetry, independent of session lifecycle, written at
+-- the moment a tool output is processed. New table \u2192 applied to existing DBs via
+-- IF NOT EXISTS on the next open.
+CREATE TABLE IF NOT EXISTS ledger_compressions (
+  id                TEXT PRIMARY KEY,
+  created_at        TEXT NOT NULL,
+  tool_name         TEXT NOT NULL,
+  content_kind      TEXT NOT NULL,
+  original_tokens   INTEGER NOT NULL DEFAULT 0,
+  compressed_tokens INTEGER NOT NULL DEFAULT 0,
+  holdout           INTEGER NOT NULL DEFAULT 0,
+  device_id         TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_ledger_compressions_created ON ledger_compressions(created_at);
+CREATE INDEX IF NOT EXISTS idx_ledger_compressions_device  ON ledger_compressions(device_id);
+
+-- Per-device compression aggregates, summed across devices like ledger_lifetime.
+-- measured_savings only credits compressed arms (holdout arms save nothing by
+-- construction), so the reported figure is a true measured delta, not an estimate.
+CREATE TABLE IF NOT EXISTS ledger_compression_lifetime (
+  device_id               TEXT PRIMARY KEY,
+  total_events            INTEGER NOT NULL DEFAULT 0,
+  total_holdout_events    INTEGER NOT NULL DEFAULT 0,
+  total_original_tokens   INTEGER NOT NULL DEFAULT 0,
+  total_compressed_tokens INTEGER NOT NULL DEFAULT 0,
+  total_measured_savings  INTEGER NOT NULL DEFAULT 0
+);
+
+-- Reversible-compression cache (spec 21 \xA7Reversibility). When a tool output is
+-- compressed, the original is stored here keyed by a short retrieval token and
+-- embedded in the compressed result; "mink retrieve <token>" returns it
+-- byte-exact. Rows expire after the configured retention window; an expired or
+-- unknown token is a graceful miss. This is a local cache, not synced state, so
+-- (unlike other tables) it carries no merge semantics beyond device_id for audit.
+CREATE TABLE IF NOT EXISTS compression_cache (
+  token        TEXT PRIMARY KEY,
+  created_at   TEXT NOT NULL,
+  expires_at   TEXT NOT NULL,
+  tool_name    TEXT NOT NULL,
+  content_kind TEXT NOT NULL,
+  content      TEXT NOT NULL,
+  size_bytes   INTEGER NOT NULL,
+  device_id    TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_compression_cache_expires ON compression_cache(expires_at);
 `;
 
 // src/storage/migrate-json.ts
@@ -3640,7 +3724,8 @@ class TokenLedgerRepo {
   snapshot() {
     const ledger = {
       lifetime: this.lifetime(),
-      sessions: this.activeSessions()
+      sessions: this.activeSessions(),
+      compression: this.compressionLifetime()
     };
     const flagRows = this.db.prepare("SELECT pattern, detected_at, details FROM waste_flags ORDER BY detected_at").all();
     if (flagRows.length > 0) {
@@ -3674,6 +3759,110 @@ class TokenLedgerRepo {
       }
     });
   }
+  recordCompression(event, deviceId = getOrCreateDeviceId()) {
+    const id = event.id ?? crypto.randomUUID();
+    const createdAt = event.createdAt ?? new Date().toISOString();
+    const holdout = event.holdout ? 1 : 0;
+    const savings = event.holdout ? 0 : Math.max(0, event.originalTokens - event.compressedTokens);
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT OR REPLACE INTO ledger_compressions
+          (id, created_at, tool_name, content_kind,
+           original_tokens, compressed_tokens, holdout, device_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, createdAt, event.toolName, event.contentKind, event.originalTokens, event.compressedTokens, holdout, deviceId);
+      this.db.prepare(`
+        INSERT INTO ledger_compression_lifetime
+          (device_id, total_events, total_holdout_events,
+           total_original_tokens, total_compressed_tokens, total_measured_savings)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(device_id) DO UPDATE SET
+          total_events            = ledger_compression_lifetime.total_events            + excluded.total_events,
+          total_holdout_events    = ledger_compression_lifetime.total_holdout_events    + excluded.total_holdout_events,
+          total_original_tokens   = ledger_compression_lifetime.total_original_tokens   + excluded.total_original_tokens,
+          total_compressed_tokens = ledger_compression_lifetime.total_compressed_tokens + excluded.total_compressed_tokens,
+          total_measured_savings  = ledger_compression_lifetime.total_measured_savings  + excluded.total_measured_savings
+      `).run(deviceId, 1, holdout, event.originalTokens, event.compressedTokens, savings);
+    });
+  }
+  compressionLifetime() {
+    const row = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(total_events),            0) AS totalEvents,
+        COALESCE(SUM(total_holdout_events),    0) AS totalHoldoutEvents,
+        COALESCE(SUM(total_original_tokens),   0) AS totalOriginalTokens,
+        COALESCE(SUM(total_compressed_tokens), 0) AS totalCompressedTokens,
+        COALESCE(SUM(total_measured_savings),  0) AS totalMeasuredSavings
+      FROM ledger_compression_lifetime
+    `).get();
+    return {
+      totalEvents: Number(row?.totalEvents ?? 0),
+      totalHoldoutEvents: Number(row?.totalHoldoutEvents ?? 0),
+      totalOriginalTokens: Number(row?.totalOriginalTokens ?? 0),
+      totalCompressedTokens: Number(row?.totalCompressedTokens ?? 0),
+      totalMeasuredSavings: Number(row?.totalMeasuredSavings ?? 0)
+    };
+  }
+  compressionEvents(limit = 100) {
+    const rows = this.db.prepare(`
+      SELECT id, created_at, tool_name, content_kind,
+             original_tokens, compressed_tokens, holdout
+      FROM ledger_compressions
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(limit);
+    return rows.map((r) => ({
+      id: String(r.id),
+      createdAt: String(r.created_at),
+      toolName: String(r.tool_name),
+      contentKind: String(r.content_kind),
+      originalTokens: Number(r.original_tokens),
+      compressedTokens: Number(r.compressed_tokens),
+      holdout: Number(r.holdout) === 1
+    }));
+  }
+  compressionArms() {
+    const row = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(CASE WHEN holdout = 0 THEN 1 END),                 0) AS cEvents,
+        COALESCE(SUM(CASE WHEN holdout = 0 THEN original_tokens END),   0) AS cOriginal,
+        COALESCE(SUM(CASE WHEN holdout = 0 THEN compressed_tokens END), 0) AS cCompressed,
+        COALESCE(SUM(CASE WHEN holdout = 1 THEN 1 END),                 0) AS hEvents,
+        COALESCE(SUM(CASE WHEN holdout = 1 THEN original_tokens END),   0) AS hOriginal
+      FROM ledger_compressions
+    `).get();
+    return {
+      compressed: {
+        events: Number(row?.cEvents ?? 0),
+        originalTokens: Number(row?.cOriginal ?? 0),
+        compressedTokens: Number(row?.cCompressed ?? 0)
+      },
+      holdout: {
+        events: Number(row?.hEvents ?? 0),
+        originalTokens: Number(row?.hOriginal ?? 0)
+      }
+    };
+  }
+  compressionBreakdown(dimension) {
+    const rows = this.db.prepare(`
+      SELECT
+        ${dimension} AS key,
+        COUNT(*) AS events,
+        COALESCE(SUM(original_tokens),   0) AS originalTokens,
+        COALESCE(SUM(compressed_tokens), 0) AS compressedTokens,
+        COALESCE(SUM(CASE WHEN holdout = 0 THEN original_tokens - compressed_tokens END), 0) AS savings
+      FROM ledger_compressions
+      GROUP BY ${dimension}
+      ORDER BY savings DESC
+    `).all();
+    return rows.map((r) => ({
+      key: String(r.key),
+      events: Number(r.events),
+      originalTokens: Number(r.originalTokens),
+      compressedTokens: Number(r.compressedTokens),
+      savings: Number(r.savings)
+    }));
+  }
   insertSessionRow(summary, deviceId, archived) {
     this.db.prepare(`
       INSERT OR REPLACE INTO ledger_sessions
@@ -4448,6 +4637,28 @@ function estimateTokens2(content, filePath) {
   }
   return Math.ceil(content.length / ratio);
 }
+function countTokens(text) {
+  if (!text)
+    return 0;
+  const segments = text.match(/[A-Za-z]+|[0-9]+|[^A-Za-z0-9]/g);
+  if (!segments)
+    return 0;
+  let tokens = 0;
+  for (const seg of segments) {
+    const first = seg.charCodeAt(0);
+    if (first >= 65 && first <= 90 || first >= 97 && first <= 122) {
+      tokens += Math.ceil(seg.length / 4);
+    } else if (first >= 48 && first <= 57) {
+      tokens += Math.ceil(seg.length / 3);
+    } else if (seg === `
+`) {
+      tokens += 1;
+    } else if (seg === " " || seg === "\t" || seg === "\r") {} else {
+      tokens += 1;
+    }
+  }
+  return tokens;
+}
 var CODE_EXTENSIONS, PROSE_EXTENSIONS, BINARY_EXTENSIONS;
 var init_token_estimate = __esm(() => {
   CODE_EXTENSIONS = new Set([
@@ -4727,342 +4938,6 @@ var init_reflect = __esm(() => {
   init_fs_utils();
 });
 
-// src/core/agent-detect.ts
-import { execSync as execSync5 } from "child_process";
-import { existsSync as existsSync17 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir3 } from "os";
-function commandExists(bin) {
-  try {
-    const probe = process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`;
-    execSync5(probe, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectAgent(meta, cwd) {
-  const signals = [];
-  if (existsSync17(join14(cwd, meta.projectDir))) {
-    signals.push(`project config (${meta.projectDir}/)`);
-  }
-  if (existsSync17(meta.globalDir)) {
-    signals.push("global config");
-  }
-  if (commandExists(meta.bin)) {
-    signals.push("on PATH");
-  }
-  return { ...meta, detected: signals.length > 0, signals };
-}
-function detectAgents(cwd) {
-  return AGENTS.map((m) => detectAgent(m, cwd));
-}
-function resolveTargetsFromFlag(flag) {
-  const normalized = flag.trim().toLowerCase();
-  if (normalized === "all")
-    return AGENTS.map((a) => a.id);
-  const ids = normalized.split(",").map((s) => s.trim()).filter(Boolean);
-  const valid = AGENTS.map((a) => a.id);
-  const resolved = ids.filter((id) => valid.includes(id));
-  return resolved;
-}
-var AGENTS;
-var init_agent_detect = __esm(() => {
-  AGENTS = [
-    {
-      id: "claude",
-      label: "Claude Code",
-      projectDir: ".claude",
-      globalDir: join14(homedir3(), ".claude"),
-      bin: "claude"
-    },
-    {
-      id: "pi",
-      label: "Pi",
-      projectDir: ".pi",
-      globalDir: join14(homedir3(), ".pi"),
-      bin: "pi"
-    }
-  ];
-});
-
-// src/core/agent-pi.ts
-import { join as join15, resolve as resolve2, dirname as dirname7 } from "path";
-import { existsSync as existsSync18, mkdirSync as mkdirSync8, copyFileSync, rmSync as rmSync2 } from "fs";
-function piExtensionPath(cwd) {
-  return join15(cwd, ".pi", "extensions", "mink.ts");
-}
-function piGuidanceSkillPath(cwd) {
-  return join15(cwd, ".pi", "skills", "mink", "SKILL.md");
-}
-function piNoteSkillPath(cwd) {
-  return join15(cwd, ".pi", "skills", "mink-note", "SKILL.md");
-}
-function buildPiExtension(cliPath) {
-  const isTsSource = cliPath.endsWith(".ts");
-  const cmd = isTsSource ? "bun" : "mink";
-  const baseArgs = isTsSource ? JSON.stringify(["run", cliPath]) : "[]";
-  return `// AUTO-GENERATED by \`mink init\`. Do not edit \u2014 re-run \`mink init\` to refresh.
-//
-// Mink adapter for the Pi coding agent. Routes Pi lifecycle and tool events
-// into the \`mink\` CLI so Pi shares the same ~/.mink state, file index, ledger,
-// and wiki as every other assistant wired to this project.
-//
-// Field shapes confirmed against pi source (earendil-works/pi,
-// packages/coding-agent): read params {path, offset, limit}; write {path,
-// content}; edit {path, edits:[{oldText,newText}]} (with legacy file_path /
-// top-level oldText,newText). tool_call/tool_result events expose toolName,
-// toolCallId, input; tool_result also exposes content (a content-block array),
-// details, isError. Advisories are surfaced by returning a modified result from
-// the tool_result handler \u2014 the documented mechanism. pi.exec has no stdin, so
-// the canonical payload is piped to \`mink\` via a spawned child process. Every
-// host-API access is defensive: the adapter never throws into Pi or blocks a
-// tool \u2014 a failure degrades to "no advisory".
-
-import { spawn } from "node:child_process";
-
-const MINK_CMD = ${JSON.stringify(cmd)};
-const MINK_BASE_ARGS = ${baseArgs};
-const TIMEOUT_MS = 5000;
-
-function runMink(sub, payload, cwd) {
-  return new Promise((res) => {
-    let done = false;
-    const finish = (out) => {
-      if (done) return;
-      done = true;
-      res(out);
-    };
-    try {
-      const child = spawn(MINK_CMD, [...MINK_BASE_ARGS, sub], {
-        cwd,
-        stdio: ["pipe", "ignore", "pipe"],
-      });
-      let stderr = "";
-      child.stderr?.on("data", (d) => {
-        stderr += d.toString();
-      });
-      child.on("error", () => finish(""));
-      child.on("close", () => finish(stderr.trim()));
-      const timer = setTimeout(() => {
-        try {
-          child.kill();
-        } catch {}
-        finish("");
-      }, TIMEOUT_MS);
-      timer.unref?.();
-      try {
-        child.stdin?.end(payload ? JSON.stringify(payload) : "");
-      } catch {}
-    } catch {
-      finish("");
-    }
-  });
-}
-
-// Pi's edit tool takes an array of { oldText, newText } replacements (legacy
-// inputs may put oldText/newText/new_string at the top level). Concatenate the
-// replacement text so Mink's write-enforcement sees everything being written.
-function editNewText(input) {
-  if (Array.isArray(input.edits)) {
-    return input.edits
-      .map((e) => e?.newText ?? e?.new_string ?? "")
-      .filter(Boolean)
-      .join("\\n");
-  }
-  return input.newText ?? input.new_string ?? input.replacement ?? "";
-}
-
-// Resolve Pi's tool name + arguments to Mink's canonical operation. Only the
-// three file operations matter; anything else returns null and is ignored.
-function toolInfo(event) {
-  const name = String(event?.toolName ?? event?.tool ?? event?.name ?? "").toLowerCase();
-  const input = event?.input ?? event?.arguments ?? {};
-  const filePath = input.path ?? input.file_path ?? input.filePath;
-  if (!filePath) return null;
-  if (name === "read") return { op: "read", filePath };
-  if (name === "write") return { op: "write", filePath, content: input.content ?? input.text ?? "" };
-  if (name === "edit") return { op: "edit", filePath, newString: editNewText(input) };
-  return null;
-}
-
-// A tool_result's content is an array of content blocks ({ type, text }); pull
-// the text out so Mink's post-read can estimate tokens from real content.
-function resultContent(event) {
-  const c = event?.content;
-  if (typeof c === "string") return c;
-  if (Array.isArray(c)) {
-    const text = c
-      .map((b) => (typeof b === "string" ? b : b?.text ?? ""))
-      .filter(Boolean)
-      .join("\\n");
-    return text || null;
-  }
-  return null;
-}
-
-function prePayload(info) {
-  if (info.op === "read")
-    return { sub: "pre-read", payload: { tool_name: "Read", tool_input: { file_path: info.filePath } } };
-  if (info.op === "write")
-    return {
-      sub: "pre-write",
-      payload: { tool_name: "Write", tool_input: { file_path: info.filePath, content: info.content } },
-    };
-  return {
-    sub: "pre-write",
-    payload: { tool_name: "Edit", tool_input: { file_path: info.filePath, new_string: info.newString } },
-  };
-}
-
-function postPayload(info, content) {
-  if (info.op === "read")
-    return {
-      sub: "post-read",
-      payload: {
-        tool_name: "Read",
-        tool_input: { file_path: info.filePath },
-        tool_output: content == null ? undefined : { content },
-      },
-    };
-  if (info.op === "write")
-    return {
-      sub: "post-write",
-      payload: { tool_name: "Write", tool_input: { file_path: info.filePath, content: info.content } },
-    };
-  return {
-    sub: "post-write",
-    payload: { tool_name: "Edit", tool_input: { file_path: info.filePath, new_string: info.newString } },
-  };
-}
-
-export default function (pi) {
-  const cwd = pi?.ctx?.cwd || process.cwd();
-  const pending = new Map();
-  const keyOf = (event) => event?.toolCallId ?? event?.id ?? event?.callId ?? "";
-
-  pi.on?.("session_start", (event) => {
-    // Skip hot-reloads so an extension reload mid-task doesn't reset the
-    // ephemeral session state; every genuinely new/resumed session starts fresh.
-    if (event?.reason === "reload") return;
-    void runMink("session-start", null, cwd);
-  });
-  pi.on?.("agent_end", () => {
-    void runMink("session-stop", null, cwd);
-  });
-  pi.on?.("session_shutdown", () => {
-    void runMink("session-stop", null, cwd);
-  });
-
-  pi.on?.("tool_call", async (event) => {
-    const info = toolInfo(event);
-    if (!info) return;
-    const { sub, payload } = prePayload(info);
-    const advisory = await runMink(sub, payload, cwd);
-    if (advisory) pending.set(keyOf(event), advisory);
-  });
-
-  pi.on?.("tool_result", async (event) => {
-    const info = toolInfo(event);
-    if (!info) return;
-    const { sub, payload } = postPayload(info, resultContent(event));
-    const post = await runMink(sub, payload, cwd);
-    const pre = pending.get(keyOf(event)) ?? "";
-    pending.delete(keyOf(event));
-    const advisory = [pre, post].filter(Boolean).join("\\n");
-    if (!advisory) return;
-
-    // Surface Mink's advisory into the model's context by appending a text
-    // block to the tool result \u2014 the parity of Claude feeding hook stderr back.
-    const base = Array.isArray(event.content)
-      ? event.content
-      : typeof event.content === "string"
-        ? [{ type: "text", text: event.content }]
-        : [];
-    return {
-      content: [...base, { type: "text", text: advisory }],
-      details: event.details,
-      isError: event.isError,
-    };
-  });
-}
-`;
-}
-function resolveSkillsSourceDir() {
-  let dir = dirname7(new URL(import.meta.url).pathname);
-  while (true) {
-    if (existsSync18(join15(dir, "package.json")) && existsSync18(join15(dir, "skills"))) {
-      return join15(dir, "skills");
-    }
-    const parent = dirname7(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  return resolve2(dirname7(new URL(import.meta.url).pathname), "../../skills");
-}
-function installPi(cwd, cliPath) {
-  const extensionPath = piExtensionPath(cwd);
-  mkdirSync8(dirname7(extensionPath), { recursive: true });
-  atomicWriteText(extensionPath, buildPiExtension(cliPath));
-  const guidancePath = piGuidanceSkillPath(cwd);
-  mkdirSync8(dirname7(guidancePath), { recursive: true });
-  atomicWriteText(guidancePath, PI_GUIDANCE_SKILL);
-  let notePath = null;
-  try {
-    const src = join15(resolveSkillsSourceDir(), "mink-note", "SKILL.md");
-    if (existsSync18(src)) {
-      notePath = piNoteSkillPath(cwd);
-      mkdirSync8(dirname7(notePath), { recursive: true });
-      copyFileSync(src, notePath);
-    }
-  } catch {
-    notePath = null;
-  }
-  return { extensionPath, guidancePath, notePath };
-}
-var PI_GUIDANCE_SKILL = `---
-name: mink
-description: Mink context management is active in this project. Read this to understand how Mink memory, write enforcement, and note capture work under Pi.
----
-
-# Mink \u2014 context management for this project
-
-This project uses **Mink** (\`@drewpayment/mink\`) for cross-session context management.
-
-## How it works
-- Mink runs automatically through a Pi extension at \`.pi/extensions/mink.ts\` that hooks session start/stop and every read/edit/write tool call.
-- All state lives in \`~/.mink/\` on the user's machine \u2014 **not** in this repository. Do not create or write to any in-repo state directory (no \`.wolf/\`, \`.mink/\`, etc.).
-- Read intelligence, write enforcement, bug memory, and the token ledger are handled by the extension. You do not need to manually read or update any state files.
-- Mink shares one \`~/.mink/\` state across every assistant wired to this project, so history is unified whether the user runs Pi or another assistant.
-
-## When to act on Mink
-- If the user asks to "save a note", "remember this", "log this to my wiki", or similar, use the \`mink-note\` skill (\`/skill:mink-note\`) \u2014 it captures into the user's \`~/.mink/\` vault.
-- If the extension surfaces a learning, past bug, or repeat-read warning in context, treat that as authoritative project memory and follow it.
-- The \`mink dashboard\` and \`mink agent\` commands are user tools \u2014 do not invoke them on the user's behalf.
-`;
-var init_agent_pi = __esm(() => {
-  init_fs_utils();
-});
-
-// src/core/prompt.ts
-import { createInterface } from "readline";
-function stdinIsInteractive() {
-  const stdin = process.stdin;
-  const stdout = process.stdout;
-  return Boolean(stdin.isTTY) && Boolean(stdout.isTTY) && process.env.MINK_NO_PROMPT !== "1" && !process.env.CI;
-}
-function ask(question) {
-  return new Promise((resolve3) => {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve3(answer);
-    });
-  });
-}
-var init_prompt = () => {};
-
 // src/core/backup.ts
 var exports_backup = {};
 __export(exports_backup, {
@@ -5071,14 +4946,14 @@ __export(exports_backup, {
   createBackup: () => createBackup
 });
 import {
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync7,
   readFileSync as readFileSync12,
   writeFileSync as writeFileSync5,
-  existsSync as existsSync19,
+  existsSync as existsSync17,
   statSync as statSync7
 } from "fs";
-import { join as join16 } from "path";
+import { join as join14 } from "path";
 function formatTimestamp(date) {
   const y = date.getFullYear();
   const mo = String(date.getMonth() + 1).padStart(2, "0");
@@ -5090,15 +4965,15 @@ function formatTimestamp(date) {
   return `${y}${mo}${d}-${h}${mi}${s}${ms}`;
 }
 function copyDirectoryFiles(srcDir, destDir, excludeDirs) {
-  mkdirSync9(destDir, { recursive: true });
+  mkdirSync8(destDir, { recursive: true });
   const entries = readdirSync7(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
       if (excludeDirs.includes(entry.name))
         continue;
-      copyDirectoryFiles(join16(srcDir, entry.name), join16(destDir, entry.name), excludeDirs);
+      copyDirectoryFiles(join14(srcDir, entry.name), join14(destDir, entry.name), excludeDirs);
     } else if (entry.isFile()) {
-      writeFileSync5(join16(destDir, entry.name), readFileSync12(join16(srcDir, entry.name)));
+      writeFileSync5(join14(destDir, entry.name), readFileSync12(join14(srcDir, entry.name)));
     }
   }
 }
@@ -5107,25 +4982,25 @@ function createBackup(cwd) {
   const dir = backupDirPath(cwd);
   let name = base;
   let suffix = 1;
-  while (existsSync19(join16(dir, name))) {
+  while (existsSync17(join14(dir, name))) {
     name = `${base}-${suffix}`;
     suffix++;
   }
   const src = projectDir(cwd);
-  const dest = join16(dir, name);
+  const dest = join14(dir, name);
   copyDirectoryFiles(src, dest, ["backups"]);
   return name;
 }
 function listBackups(cwd) {
   const dir = backupDirPath(cwd);
-  if (!existsSync19(dir))
+  if (!existsSync17(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 = join16(dir, entry.name);
+    const backupPath = join14(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) {
@@ -5148,8 +5023,8 @@ function listBackups(cwd) {
   return backups;
 }
 function restoreBackup(cwd, backupName) {
-  const backupPath = join16(backupDirPath(cwd), backupName);
-  if (!existsSync19(backupPath)) {
+  const backupPath = join14(backupDirPath(cwd), backupName);
+  if (!existsSync17(backupPath)) {
     throw new Error(`backup not found: ${backupName}`);
   }
   createBackup(cwd);
@@ -5161,7 +5036,7 @@ var init_backup = __esm(() => {
 
 // src/core/scanner.ts
 import { readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { join as join17, relative } from "path";
+import { join as join15, relative } from "path";
 function matchesPattern(name, pattern) {
   if (pattern.includes("*")) {
     const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
@@ -5185,14 +5060,14 @@ function walkDirectory(dir, projectRoot, excludes, results) {
     if (entry.isDirectory()) {
       if (isExcluded(entry.name, excludes))
         continue;
-      walkDirectory(join17(dir, entry.name), projectRoot, excludes, results);
+      walkDirectory(join15(dir, entry.name), projectRoot, excludes, results);
       continue;
     }
     if (entry.isFile()) {
       if (isExcluded(entry.name, excludes))
         continue;
       try {
-        const fullPath = join17(dir, entry.name);
+        const fullPath = join15(dir, entry.name);
         const stat = statSync8(fullPath);
         results.push({
           relativePath: relative(projectRoot, fullPath),
@@ -5615,7 +5490,7 @@ __export(exports_scan, {
 });
 import { readFileSync as readFileSync13 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join18, relative as relative2 } from "path";
+import { join as join16, relative as relative2 } from "path";
 function configRelativePath(cfgPath, cwd) {
   const rel = relative2(cwd, cfgPath);
   return rel.startsWith("..") ? cfgPath : rel;
@@ -5666,7 +5541,7 @@ function scan(cwd, options) {
     if (!stalePaths.has(file.relativePath)) {
       continue;
     }
-    const fullPath = join18(cwd, file.relativePath);
+    const fullPath = join16(cwd, file.relativePath);
     let content;
     try {
       content = readFileSync13(fullPath, "utf-8");
@@ -5755,10 +5630,10 @@ __export(exports_seed, {
   parseGoMod: () => parseGoMod,
   parseCargoToml: () => parseCargoToml
 });
-import { basename as basename4, join as join19 } from "path";
-import { readFileSync as readFileSync14, existsSync as existsSync20 } from "fs";
+import { basename as basename4, join as join17 } from "path";
+import { readFileSync as readFileSync14, existsSync as existsSync18 } from "fs";
 function readFile(filePath) {
-  if (!existsSync20(filePath))
+  if (!existsSync18(filePath))
     return null;
   try {
     return readFileSync14(filePath, "utf-8");
@@ -5851,10 +5726,10 @@ function parseGoMod(filePath) {
 }
 function seedLearningMemory(projectRoot) {
   const parsers = [
-    () => parsePackageJson(join19(projectRoot, "package.json")),
-    () => parsePyprojectToml(join19(projectRoot, "pyproject.toml")),
-    () => parseCargoToml(join19(projectRoot, "Cargo.toml")),
-    () => parseGoMod(join19(projectRoot, "go.mod"))
+    () => parsePackageJson(join17(projectRoot, "package.json")),
+    () => parsePyprojectToml(join17(projectRoot, "pyproject.toml")),
+    () => parseCargoToml(join17(projectRoot, "Cargo.toml")),
+    () => parseGoMod(join17(projectRoot, "go.mod"))
   ];
   const infos = parsers.map((fn) => fn()).filter((info) => info !== null);
   const projectName = infos.find((i) => i.projectName)?.projectName ?? basename4(projectRoot);
@@ -5932,37 +5807,34 @@ 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 execSync6 } from "child_process";
-import { mkdirSync as mkdirSync10, existsSync as existsSync21 } from "fs";
-import { resolve as resolve3, dirname as dirname8, basename as basename5, join as join20 } from "path";
+import { execSync as execSync5 } from "child_process";
+import { mkdirSync as mkdirSync9, existsSync as existsSync19 } from "fs";
+import { resolve as resolve2, dirname as dirname7, basename as basename5, join as join18 } from "path";
 function detectRuntime() {
   try {
-    execSync6("bun --version", { stdio: "ignore" });
+    execSync5("bun --version", { stdio: "ignore" });
     return "bun";
   } catch {
     return "node";
   }
 }
 function resolveCliPathFrom(selfPath) {
-  const selfDir = dirname8(selfPath);
+  const selfDir = dirname7(selfPath);
   if (selfPath.endsWith("dist/cli.js") || selfPath.endsWith("dist/cli.bun.js") || selfPath.endsWith("dist/cli.node.js")) {
-    return join20(selfDir, "cli.js");
+    return join18(selfDir, "cli.js");
   }
-  const packageRoot = resolve3(selfDir, "..", "..");
-  const distShim = join20(packageRoot, "dist", "cli.js");
-  if (existsSync21(distShim))
+  const packageRoot = resolve2(selfDir, "..", "..");
+  const distShim = join18(packageRoot, "dist", "cli.js");
+  if (existsSync19(distShim))
     return distShim;
-  return join20(packageRoot, "src", "cli.ts");
+  return join18(packageRoot, "src", "cli.ts");
 }
 function resolveCliPath() {
   return resolveCliPathFrom(new URL(import.meta.url).pathname);
@@ -5982,12 +5854,14 @@ function buildHooksConfig(cliPath) {
     PostToolUse: [
       { matcher: "Read", hooks: hook(`${prefix} post-read`) },
       { matcher: "Edit", hooks: hook(`${prefix} post-write`) },
-      { matcher: "Write", hooks: hook(`${prefix} post-write`) }
+      { matcher: "Write", hooks: hook(`${prefix} post-write`) },
+      { matcher: "Bash", hooks: hook(`${prefix} post-tool`) },
+      { matcher: "Grep", hooks: hook(`${prefix} post-tool`) }
     ]
   };
 }
 function isMinkCommand(cmd) {
-  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write");
+  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write") || cmd.includes("post-tool");
   if (!hasMinkSubcommand)
     return false;
   if (/(^|\/|\s)mink\s/.test(cmd))
@@ -6004,13 +5878,13 @@ function isMinkHook(entry) {
   return false;
 }
 function writeMinkRule(cwd) {
-  const rulePath = resolve3(cwd, ".claude", "rules", "mink.md");
-  mkdirSync10(dirname8(rulePath), { recursive: true });
+  const rulePath = resolve2(cwd, ".claude", "rules", "mink.md");
+  mkdirSync9(dirname7(rulePath), { recursive: true });
   atomicWriteText(rulePath, MINK_RULE_CONTENT);
   return rulePath;
 }
 function mergeHooksIntoSettings(settingsPath, newHooks) {
-  mkdirSync10(dirname8(settingsPath), { recursive: true });
+  mkdirSync9(dirname7(settingsPath), { recursive: true });
   const existing = safeReadJson(settingsPath) ?? {};
   const existingHooks = existing.hooks ?? {};
   for (const [event, entries] of Object.entries(newHooks)) {
@@ -6021,46 +5895,17 @@ function mergeHooksIntoSettings(settingsPath, newHooks) {
   existing.hooks = existingHooks;
   atomicWriteJson(settingsPath, existing);
 }
-function installClaude(cwd, cliPath) {
-  const settingsPath = resolve3(cwd, ".claude", "settings.json");
-  mergeHooksIntoSettings(settingsPath, buildHooksConfig(cliPath));
-  const rulePath = writeMinkRule(cwd);
-  return { settingsPath, rulePath };
-}
-async function resolveTargets(cwd, opts) {
-  if (opts.targets && opts.targets.length > 0)
-    return opts.targets;
-  const detected = detectAgents(cwd);
-  const detectedIds = detected.filter((a) => a.detected).map((a) => a.id);
-  if (opts.interactive && stdinIsInteractive()) {
-    return promptForAgents(detected, detectedIds);
-  }
-  return detectedIds.length > 0 ? detectedIds : ["claude"];
-}
-async function promptForAgents(detected, defaults) {
-  const fallback = defaults.length > 0 ? defaults : ["claude"];
-  console.log("Which assistant(s) should Mink work with?");
-  detected.forEach((a, i) => {
-    const tag = a.detected ? `  (detected \u2014 ${a.signals.join(", ")})` : "";
-    console.log(`  ${i + 1}) ${a.label}${tag}`);
-  });
-  const answer = (await ask(`Enter numbers (comma-separated), 'a' for all [default: ${fallback.join(", ")}]: `)).trim().toLowerCase();
-  if (answer === "")
-    return fallback;
-  if (answer === "a" || answer === "all")
-    return AGENTS.map((a) => a.id);
-  const picked = answer.split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n) && n >= 1 && n <= detected.length).map((n) => detected[n - 1].id);
-  return picked.length > 0 ? picked : fallback;
-}
 function isExistingInstallation(cwd) {
   const dir = projectDir(cwd);
-  if (!existsSync21(dir))
+  if (!existsSync19(dir))
     return false;
-  return existsSync21(join20(dir, "file-index.json"));
+  return existsSync19(join18(dir, "file-index.json"));
 }
-async function init(cwd, opts = {}) {
+async function init(cwd) {
   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) {
@@ -6069,22 +5914,9 @@ async function init(cwd, opts = {}) {
     const backupName = createBackup2(cwd);
     console.log(`  backup: ${backupName}`);
   }
-  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 });
+  mergeHooksIntoSettings(settingsPath, hooks);
+  const rulePath = writeMinkRule(cwd);
+  mkdirSync9(dir, { recursive: true });
   const identity = resolveProjectIdentity(cwd);
   const projectId = identity.id;
   const isNotesProject = isWikiEnabled() && isVaultInitialized() && isInsideVault(cwd);
@@ -6092,8 +5924,6 @@ async function init(cwd, opts = {}) {
   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,
@@ -6101,29 +5931,20 @@ async function init(cwd, opts = {}) {
     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(`  agents:   ${agents.join(", ")}`);
-    printWiring();
+    console.log(`  hooks:    ${settingsPath}`);
+    console.log(`  rule:     ${rulePath}`);
   } else {
     console.log(`[mink] initialized`);
     console.log(`  project:  ${projectId} (${identity.source})`);
     console.log(`  state:    ${dir}`);
     console.log(`  runtime:  ${runtime}`);
-    console.log(`  agents:   ${agents.join(", ")}`);
-    printWiring();
+    console.log(`  hooks:    ${settingsPath}`);
+    console.log(`  rule:     ${rulePath}`);
   }
   if (identity.source === "path-derived") {
     const root = getRepoRoot(cwd);
@@ -6135,7 +5956,7 @@ async function init(cwd, opts = {}) {
   scan2(cwd, { check: false });
   const { learningMemoryPath: learningMemoryPath2 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
   const memPath = learningMemoryPath2(cwd);
-  if (!existsSync21(memPath)) {
+  if (!existsSync19(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);
@@ -6144,8 +5965,8 @@ async function init(cwd, opts = {}) {
   if (isWikiEnabled() && isVaultInitialized() && !isNotesProject) {
     try {
       const projectSlug = basename5(cwd);
-      const overviewPath = join20(vaultProjects(projectSlug), "overview.md");
-      if (!existsSync21(overviewPath)) {
+      const overviewPath = join18(vaultProjects(projectSlug), "overview.md");
+      if (!existsSync19(overviewPath)) {
         const now = new Date().toISOString();
         const overview = [
           `---`,
@@ -6197,9 +6018,6 @@ var init_init = __esm(() => {
   init_device();
   init_git_identity();
   init_vault();
-  init_agent_detect();
-  init_agent_pi();
-  init_prompt();
 });
 
 // src/repositories/counters-repo.ts
@@ -6274,12 +6092,12 @@ var init_state_counters = __esm(() => {
 });
 
 // src/core/channel-templates.ts
-import { join as join21 } from "path";
-import { existsSync as existsSync22, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11 } from "fs";
+import { join as join19 } from "path";
+import { existsSync as existsSync20, writeFileSync as writeFileSync6, mkdirSync as mkdirSync10 } from "fs";
 function writeCompanionClaudeMd(vaultPath, overwrite = false) {
-  mkdirSync11(vaultPath, { recursive: true });
-  const claudeMdPath = join21(vaultPath, "CLAUDE.md");
-  if (existsSync22(claudeMdPath) && !overwrite) {
+  mkdirSync10(vaultPath, { recursive: true });
+  const claudeMdPath = join19(vaultPath, "CLAUDE.md");
+  if (existsSync20(claudeMdPath) && !overwrite) {
     return false;
   }
   writeFileSync6(claudeMdPath, COMPANION_CLAUDE_MD);
@@ -6431,8 +6249,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 mkdirSync12, existsSync as existsSync23 } from "fs";
-import { dirname as dirname9, join as join22 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync11, existsSync as existsSync21 } from "fs";
+import { dirname as dirname8, join as join20 } from "path";
 import { spawnSync } from "child_process";
 function readChannelPidFile() {
   try {
@@ -6448,7 +6266,7 @@ function readChannelPidFile() {
 }
 function writeChannelPidFile(data) {
   const pidPath = channelPidPath();
-  mkdirSync12(dirname9(pidPath), { recursive: true });
+  mkdirSync11(dirname8(pidPath), { recursive: true });
   writeFileSync7(pidPath, JSON.stringify(data, null, 2));
 }
 function removeChannelPidFile() {
@@ -6578,12 +6396,12 @@ function getChannelLogs() {
     return null;
   if (!screenSessionExists(pidData.session))
     return null;
-  const tmpPath = join22(minkRoot(), `.channel-capture-${Date.now()}-${process.pid}.txt`);
+  const tmpPath = join20(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 (existsSync23(tmpPath))
+    if (existsSync21(tmpPath))
       break;
     const delayUntil = Date.now() + 50;
     while (Date.now() < delayUntil) {}
@@ -6687,7 +6505,7 @@ async function runtimeServe(opts) {
   }
   const { createServer } = await import("http");
   const { Readable } = await import("stream");
-  return new Promise((resolve4) => {
+  return new Promise((resolve3) => {
     const httpServer = createServer(async (req, res) => {
       const url = `http://${opts.hostname}:${opts.port}${req.url ?? "/"}`;
       const headers = new Headers;
@@ -6746,7 +6564,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;
-      resolve4({
+      resolve3({
         port: boundPort,
         stop: (close) => {
           if (close)
@@ -6764,8 +6582,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 mkdirSync13 } from "fs";
-import { dirname as dirname10, resolve as resolve4 } from "path";
+import { mkdirSync as mkdirSync12 } from "fs";
+import { dirname as dirname9, resolve as resolve3 } from "path";
 function readPidFile() {
   try {
     const raw = readFileSync16(schedulerPidPath(), "utf-8");
@@ -6780,7 +6598,7 @@ function readPidFile() {
 }
 function writePidFile(data) {
   const pidPath = schedulerPidPath();
-  mkdirSync13(dirname10(pidPath), { recursive: true });
+  mkdirSync12(dirname9(pidPath), { recursive: true });
   writeFileSync8(pidPath, JSON.stringify(data, null, 2));
 }
 function removePidFile() {
@@ -6805,10 +6623,10 @@ function startDaemon(cwd) {
   if (existing) {
     removePidFile();
   }
-  const __dir = dirname10(new URL(import.meta.url).pathname);
-  const cliPath = process.argv[1] ?? resolve4(__dir, "../cli.ts");
+  const __dir = dirname9(new URL(import.meta.url).pathname);
+  const cliPath = process.argv[1] ?? resolve3(__dir, "../cli.ts");
   const logPath = schedulerLogPath();
-  mkdirSync13(dirname10(logPath), { recursive: true });
+  mkdirSync12(dirname9(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const proc = runtimeSpawn(["bun", "run", cliPath, "cron", "__daemon"], {
     cwd,
@@ -6922,9 +6740,9 @@ var exports_status = {};
 __export(exports_status, {
   status: () => status
 });
-import { existsSync as existsSync25, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync17, statSync as statSync9 } from "fs";
 function checkJsonFile(name, filePath, validator) {
-  if (!existsSync25(filePath))
+  if (!existsSync23(filePath))
     return { name, path: filePath, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -6934,7 +6752,7 @@ function checkJsonFile(name, filePath, validator) {
   return { name, path: filePath, status: "ok" };
 }
 function checkDbFile(name, filePath) {
-  if (!existsSync25(filePath))
+  if (!existsSync23(filePath))
     return { name, path: filePath, status: "missing" };
   try {
     const header = readFileSync17(filePath).slice(0, 16).toString("utf-8");
@@ -6949,7 +6767,7 @@ function checkDbFile(name, filePath) {
 function checkShardedText(name, candidatePaths) {
   const canonical = candidatePaths[0];
   for (const p of candidatePaths) {
-    if (!existsSync25(p))
+    if (!existsSync23(p))
       continue;
     try {
       if (statSync9(p).size === 0)
@@ -7024,7 +6842,12 @@ function status(cwd) {
     console.log(`    Sessions: ${lt.totalSessions}`);
     console.log(`    Total tokens: ${lt.totalTokens.toLocaleString()}`);
     console.log(`    Reads: ${lt.totalReads}  Writes: ${lt.totalWrites}`);
-    console.log(`    Estimated savings: ${lt.totalEstimatedSavings.toLocaleString()} tokens`);
+    console.log(`    Estimated savings (heuristic): ${lt.totalEstimatedSavings.toLocaleString()} tokens`);
+    const comp = ledger.compression;
+    if (comp && comp.totalEvents > 0) {
+      const ratio = comp.totalOriginalTokens > 0 ? Math.round(comp.totalMeasuredSavings / comp.totalOriginalTokens * 100) : 0;
+      console.log(`    Measured compression savings: ${comp.totalMeasuredSavings.toLocaleString()} tokens` + ` (${ratio}% over ${comp.totalEvents} event${comp.totalEvents === 1 ? "" : "s"}` + `, ${comp.totalHoldoutEvents} held out)`);
+    }
   } catch {
     console.log("  Token ledger: error reading");
   }
@@ -7042,7 +6865,7 @@ function status(cwd) {
       console.log(`    Decision Log: ${mem.sections["Decision Log"].length}`);
       console.log(`    Total entries: ${total}`);
       const memPath = learningMemoryPath(cwd);
-      if (existsSync25(memPath)) {
+      if (existsSync23(memPath)) {
         const mtime = statSync9(memPath).mtime;
         console.log(`    Canonical last modified: ${mtime.toISOString()}`);
       }
@@ -7177,6 +7000,488 @@ var init_pre_read = __esm(() => {
   init_counters_repo();
 });
 
+// src/core/compression.ts
+function numberValue(key, fallback, min, max) {
+  const raw = resolveConfigValue(key).value;
+  const n = Number(raw);
+  if (!Number.isFinite(n))
+    return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function loadCompressionConfig() {
+  return {
+    enabled: resolveConfigValue("compression.enabled").value === "true",
+    thresholdTokens: numberValue("compression.threshold-tokens", 800, 0, Number.MAX_SAFE_INTEGER),
+    minSavingsRatio: numberValue("compression.min-savings-ratio", 0.25, 0, 1),
+    holdoutFraction: numberValue("compression.holdout-fraction", 0.1, 0, 1),
+    retentionHours: numberValue("compression.retention-hours", 168, 0, Number.MAX_SAFE_INTEGER)
+  };
+}
+function isEligible(originalTokens, config) {
+  return config.enabled && originalTokens >= config.thresholdTokens;
+}
+function meetsMinSavings(originalTokens, compressedTokens, config) {
+  if (originalTokens <= 0)
+    return false;
+  const ratio = (originalTokens - compressedTokens) / originalTokens;
+  return ratio >= config.minSavingsRatio;
+}
+function hashUnitInterval(key) {
+  let h = 2166136261;
+  for (let i = 0;i < key.length; i++) {
+    h ^= key.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0) / 4294967296;
+}
+function selectHoldout(eventKey, fraction) {
+  if (fraction <= 0)
+    return false;
+  if (fraction >= 1)
+    return true;
+  return hashUnitInterval(eventKey) < fraction;
+}
+var init_compression = __esm(() => {
+  init_global_config();
+});
+
+// src/core/code-skeleton.ts
+function countChar(s, c) {
+  let n = 0;
+  for (let i = 0;i < s.length; i++)
+    if (s[i] === c)
+      n++;
+  return n;
+}
+function netBraces(line) {
+  let s = line.replace(/\/\/.*$/, "");
+  s = s.replace(/\/\*.*?\*\//g, "");
+  s = s.replace(/"(?:\\.|[^"\\])*"/g, '""');
+  s = s.replace(/'(?:\\.|[^'\\])*'/g, "''");
+  s = s.replace(/`(?:\\.|[^`\\])*`/g, "``");
+  return countChar(s, "{") - countChar(s, "}");
+}
+function stripOpenBrace(sig) {
+  return sig.replace(/\{\s*$/, "").trimEnd();
+}
+function extractCodeSkeleton(content, opts = {}) {
+  const rawLines = content.split(`
+`);
+  const totalLines = rawLines.length > 0 && rawLines[rawLines.length - 1] === "" ? rawLines.length - 1 : rawLines.length;
+  const out = [];
+  let depth = 0;
+  let suppress = Infinity;
+  for (const line of rawLines) {
+    if (out.length >= MAX_SIGNATURES)
+      break;
+    const start = depth;
+    const net = netBraces(line);
+    if (start < suppress) {
+      const isHeading = opts.markdown === true && HEADING.test(line);
+      const captured = isHeading || DECL_ALWAYS.test(line) || DECL_EXPORTED_VAR.test(line) || start >= 1 && MEMBER.test(line);
+      if (captured) {
+        const sig = line.trim();
+        if (net > 0) {
+          if (DESCEND.test(line) && !isHeading) {
+            out.push(INDENT.repeat(start) + stripOpenBrace(sig) + " {");
+          } else {
+            out.push(INDENT.repeat(start) + stripOpenBrace(sig) + " { \u2026 }");
+            suppress = start + 1;
+          }
+        } else {
+          out.push(INDENT.repeat(start) + sig);
+        }
+      }
+    }
+    depth = Math.max(0, depth + net);
+    if (depth < suppress)
+      suppress = Infinity;
+  }
+  if (out.length === 0)
+    return null;
+  return { lines: out, totalLines };
+}
+var MAX_SIGNATURES = 80, INDENT = "  ", DECL_ALWAYS, DECL_EXPORTED_VAR, MEMBER, HEADING, DESCEND;
+var init_code_skeleton = __esm(() => {
+  DECL_ALWAYS = /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|interface|type|enum|namespace|module|def|fn|func|impl|struct|trait)\b/;
+  DECL_EXPORTED_VAR = /^\s*export\s+(?:default\s+)?(?:const|let|var)\b/;
+  MEMBER = /^\s*(?:public\s+|private\s+|protected\s+|readonly\s+|static\s+|async\s+|get\s+|set\s+|#)*[\w$]+\??\s*(?:\(|:|=)/;
+  HEADING = /^#{1,6}\s+\S/;
+  DESCEND = /\b(?:class|interface|enum|namespace|module|struct|trait|impl)\b/;
+});
+
+// src/core/output-compression.ts
+function stripAnsi(s) {
+  return s.replace(ANSI, "");
+}
+function omittedMarker(n) {
+  return `  \u2026 ${n} line${n === 1 ? "" : "s"} omitted \u2014 mink retrieve \u2026`;
+}
+function toLines(content) {
+  const lines = content.split(`
+`);
+  if (lines.length > 0 && lines[lines.length - 1] === "")
+    lines.pop();
+  return lines;
+}
+function compressLog(content) {
+  const lines = toLines(stripAnsi(content));
+  const collapsed = [];
+  let i = 0;
+  while (i < lines.length) {
+    let run = 1;
+    while (i + run < lines.length && lines[i + run] === lines[i])
+      run++;
+    collapsed.push(run > 1 ? `${lines[i]}  (\xD7${run})` : lines[i]);
+    i += run;
+  }
+  if (collapsed.length <= LOG_HEAD + LOG_TAIL) {
+    if (collapsed.length === lines.length)
+      return null;
+    return {
+      compressed: collapsed.join(`
+`),
+      omittedNote: `collapsed ${lines.length - collapsed.length} repeated line(s)`
+    };
+  }
+  const omitted = collapsed.length - LOG_HEAD - LOG_TAIL;
+  const head = collapsed.slice(0, LOG_HEAD);
+  const tail = collapsed.slice(collapsed.length - LOG_TAIL);
+  return {
+    compressed: [...head, omittedMarker(omitted), ...tail].join(`
+`),
+    omittedNote: `${omitted} of ${collapsed.length} log line(s) omitted (middle)`
+  };
+}
+function compressSearch(content) {
+  const lines = toLines(content);
+  const seen = new Set;
+  const perFile = new Map;
+  const omittedByFile = new Map;
+  const out = [];
+  for (const line of lines) {
+    if (seen.has(line))
+      continue;
+    seen.add(line);
+    const colon = line.indexOf(":");
+    const file = colon > 0 ? line.slice(0, colon) : line;
+    const count = perFile.get(file) ?? 0;
+    if (count < SEARCH_MAX_PER_FILE) {
+      perFile.set(file, count + 1);
+      out.push(line);
+    } else {
+      omittedByFile.set(file, (omittedByFile.get(file) ?? 0) + 1);
+    }
+  }
+  let totalOmitted = 0;
+  for (const [file, n] of omittedByFile) {
+    totalOmitted += n;
+    out.push(`  \u2026 +${n} more match(es) in ${file} \u2014 mink retrieve \u2026`);
+  }
+  const dedupRemoved = lines.length - seen.size;
+  if (totalOmitted === 0 && dedupRemoved === 0)
+    return null;
+  const notes = [];
+  if (totalOmitted > 0)
+    notes.push(`${totalOmitted} match(es) capped`);
+  if (dedupRemoved > 0)
+    notes.push(`${dedupRemoved} duplicate(s) removed`);
+  return { compressed: out.join(`
+`), omittedNote: notes.join("; ") };
+}
+function compressFile(filePath, content) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  const markdown = ext === ".md" || ext === ".mdx" || ext === ".markdown";
+  const skeleton = extractCodeSkeleton(content, { markdown });
+  if (!skeleton) {
+    return compressText(content);
+  }
+  const header = `${filePath} \u2014 structural summary ` + `(${skeleton.lines.length} signature(s) of ${skeleton.totalLines} lines)`;
+  return {
+    compressed: [header, ...skeleton.lines].join(`
+`),
+    omittedNote: `bodies elided; ${skeleton.totalLines} lines available via mink retrieve`
+  };
+}
+function crush(value) {
+  if (Array.isArray(value)) {
+    let omitted = 0;
+    const mapEl = (el) => {
+      const r = crush(el);
+      omitted += r.omitted;
+      return r.value;
+    };
+    if (value.length <= JSON_ARRAY_HEAD + JSON_ARRAY_TAIL) {
+      return { value: value.map(mapEl), omitted };
+    }
+    const dropped = value.length - JSON_ARRAY_HEAD - JSON_ARRAY_TAIL;
+    omitted += dropped;
+    const out = [
+      ...value.slice(0, JSON_ARRAY_HEAD).map(mapEl),
+      `\u2026 ${dropped} element(s) omitted \u2014 mink retrieve \u2026`,
+      ...value.slice(value.length - JSON_ARRAY_TAIL).map(mapEl)
+    ];
+    return { value: out, omitted };
+  }
+  if (value && typeof value === "object") {
+    let omitted = 0;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const r = crush(v);
+      omitted += r.omitted;
+      out[k] = r.value;
+    }
+    return { value: out, omitted };
+  }
+  return { value, omitted: 0 };
+}
+function compressJson(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  const { value, omitted } = crush(parsed);
+  if (omitted === 0)
+    return null;
+  return {
+    compressed: JSON.stringify(value, null, 2),
+    omittedNote: `${omitted} array element(s) sampled out`
+  };
+}
+function compressText(content) {
+  const lines = toLines(content);
+  if (lines.length <= TEXT_HEAD + TEXT_TAIL)
+    return null;
+  const omitted = lines.length - TEXT_HEAD - TEXT_TAIL;
+  const head = lines.slice(0, TEXT_HEAD);
+  const tail = lines.slice(lines.length - TEXT_TAIL);
+  return {
+    compressed: [...head, omittedMarker(omitted), ...tail].join(`
+`),
+    omittedNote: `${omitted} of ${lines.length} line(s) omitted (middle)`
+  };
+}
+function detectContentKind(toolName, content, filePath) {
+  const t = toolName.toLowerCase();
+  if (t === "read")
+    return "file";
+  if (t === "grep" || t === "glob")
+    return "search";
+  if (t === "bash")
+    return "log";
+  const head = content.trimStart()[0];
+  if (head === "{" || head === "[") {
+    try {
+      JSON.parse(content);
+      return "json";
+    } catch {}
+  }
+  if (filePath)
+    return "file";
+  return "text";
+}
+function compressOutput(toolName, content, filePath) {
+  const kind = detectContentKind(toolName, content, filePath);
+  let result;
+  switch (kind) {
+    case "search":
+      result = compressSearch(content);
+      break;
+    case "log":
+      result = compressLog(content);
+      break;
+    case "file":
+      result = compressFile(filePath ?? "file", content);
+      break;
+    case "json":
+      result = compressJson(content);
+      break;
+    case "text":
+      result = compressText(content);
+      break;
+  }
+  if (!result)
+    return null;
+  return { kind, compressed: result.compressed, omittedNote: result.omittedNote };
+}
+var SEARCH_MAX_PER_FILE = 5, LOG_HEAD = 40, LOG_TAIL = 40, TEXT_HEAD = 30, TEXT_TAIL = 20, JSON_ARRAY_HEAD = 20, JSON_ARRAY_TAIL = 5, ANSI;
+var init_output_compression = __esm(() => {
+  init_code_skeleton();
+  ANSI = /\u001B\[[0-9;?]*[ -/]*[@-~]/g;
+});
+
+// src/repositories/compression-cache-repo.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+class CompressionCacheRepo {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static for(cwd) {
+    return new CompressionCacheRepo(openProjectDb(cwd));
+  }
+  static newToken() {
+    return `mc-${randomUUID3().slice(0, 8)}`;
+  }
+  store(input, deviceId = getOrCreateDeviceId()) {
+    const token = input.token ?? CompressionCacheRepo.newToken();
+    const now = input.now ?? new Date;
+    const createdAt = now.toISOString();
+    const expiresAt = new Date(now.getTime() + Math.max(0, input.retentionHours) * 3600000).toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO compression_cache
+        (token, created_at, expires_at, tool_name, content_kind,
+         content, size_bytes, device_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(token, createdAt, expiresAt, input.toolName, input.contentKind, input.content, Buffer.byteLength(input.content, "utf-8"), deviceId);
+    return token;
+  }
+  get(token, now = new Date) {
+    const row = this.db.prepare("SELECT * FROM compression_cache WHERE token = ?").get(token);
+    if (!row)
+      return null;
+    const expiresAt = String(row.expires_at);
+    if (expiresAt <= now.toISOString()) {
+      try {
+        this.db.prepare("DELETE FROM compression_cache WHERE token = ?").run(token);
+      } catch {}
+      return null;
+    }
+    return {
+      token: String(row.token),
+      createdAt: String(row.created_at),
+      expiresAt,
+      toolName: String(row.tool_name),
+      contentKind: String(row.content_kind),
+      content: String(row.content),
+      sizeBytes: Number(row.size_bytes)
+    };
+  }
+  evictExpired(now = new Date) {
+    const r = this.db.prepare("DELETE FROM compression_cache WHERE expires_at <= ?").run(now.toISOString());
+    return Number(r.changes);
+  }
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM compression_cache").get();
+    return Number(row.n);
+  }
+}
+var init_compression_cache_repo = __esm(() => {
+  init_db();
+  init_device();
+});
+
+// src/core/compress-tool-output.ts
+function contentKey(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function render(result, token) {
+  return result.compressed + `
+
+` + `\u2014 mink: compressed ${result.kind} output (${result.omittedNote}). ` + `Full original: mink retrieve ${token}`;
+}
+function safeRecord(cwd, toolName, contentKind, originalTokens, compressedTokens, holdout) {
+  try {
+    TokenLedgerRepo.for(cwd).recordCompression({
+      toolName,
+      contentKind,
+      originalTokens,
+      compressedTokens,
+      holdout
+    });
+  } catch {}
+}
+function compressToolOutput(cwd, toolName, output, filePath) {
+  let cfg;
+  try {
+    cfg = loadCompressionConfig();
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled)
+    return null;
+  if (typeof output !== "string" || output.length === 0)
+    return null;
+  const originalTokens = countTokens(output);
+  if (!isEligible(originalTokens, cfg))
+    return null;
+  const eventKey = contentKey(output);
+  if (selectHoldout(eventKey, cfg.holdoutFraction)) {
+    const kind = detectContentKind(toolName, output, filePath);
+    safeRecord(cwd, toolName, kind, originalTokens, originalTokens, true);
+    return null;
+  }
+  const result = compressOutput(toolName, output, filePath);
+  if (!result)
+    return null;
+  const token = CompressionCacheRepo.newToken();
+  const replacement = render(result, token);
+  const compressedTokens = countTokens(replacement);
+  if (!meetsMinSavings(originalTokens, compressedTokens, cfg))
+    return null;
+  try {
+    CompressionCacheRepo.for(cwd).store({
+      toolName,
+      contentKind: result.kind,
+      content: output,
+      retentionHours: cfg.retentionHours,
+      token
+    });
+  } catch {
+    return null;
+  }
+  safeRecord(cwd, toolName, result.kind, originalTokens, compressedTokens, false);
+  return { updatedToolOutput: replacement, token };
+}
+var init_compress_tool_output = __esm(() => {
+  init_compression();
+  init_token_estimate();
+  init_output_compression();
+  init_compression_cache_repo();
+  init_token_ledger_repo();
+});
+
+// src/core/hook-output.ts
+function extractToolOutputText(input) {
+  const tr = input.tool_response;
+  if (tr) {
+    if (typeof tr.content === "string")
+      return tr.content;
+    if (Array.isArray(tr.content)) {
+      const parts = tr.content.map((p) => p && typeof p.text === "string" ? p.text : "").filter((s) => s.length > 0);
+      if (parts.length > 0)
+        return parts.join("");
+    }
+    if (typeof tr.stdout === "string" && tr.stdout.length > 0)
+      return tr.stdout;
+    if (typeof tr.text === "string")
+      return tr.text;
+    const file = tr.file;
+    if (file && typeof file.content === "string")
+      return file.content;
+  }
+  const to = input.tool_output;
+  if (to && typeof to.content === "string")
+    return to.content;
+  return null;
+}
+function emitUpdatedToolOutput(text) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      updatedToolOutput: text
+    }
+  }));
+}
+
 // src/commands/post-read.ts
 var exports_post_read = {};
 __export(exports_post_read, {
@@ -7306,6 +7611,14 @@ async function postRead(cwd) {
       logWriter.appendReadEntry(new Date().toISOString(), filePath, result.indexHit, result.estimatedTokens);
     } catch {}
     atomicWriteJson(sessionPath(cwd), state);
+    const isRanged = input.tool_input.offset != null || input.tool_input.limit != null;
+    if (!isRanged && content && content.length > 0) {
+      try {
+        const outcome = compressToolOutput(cwd, "Read", content, filePath);
+        if (outcome)
+          emitUpdatedToolOutput(outcome.updatedToolOutput);
+      } catch {}
+    }
   } catch {} finally {
     clearTimeout(timer);
   }
@@ -7319,6 +7632,43 @@ var init_post_read = __esm(() => {
   init_description();
   init_action_log();
   init_device();
+  init_compress_tool_output();
+});
+
+// src/commands/post-tool.ts
+var exports_post_tool = {};
+__export(exports_post_tool, {
+  postTool: () => postTool
+});
+function isPostToolUseInput2(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const obj = value;
+  return typeof obj.tool_name === "string";
+}
+function isCompressibleTool(toolName) {
+  return toolName === "Bash" || toolName === "Grep" || toolName === "Glob" || toolName.startsWith("mcp__");
+}
+async function postTool(cwd) {
+  const timer = setTimeout(() => process.exit(0), 5000);
+  try {
+    const input = await readStdinJson();
+    if (!isPostToolUseInput2(input))
+      return;
+    if (!isCompressibleTool(input.tool_name))
+      return;
+    const output = extractToolOutputText(input);
+    if (!output)
+      return;
+    const outcome = compressToolOutput(cwd, input.tool_name, output);
+    if (outcome)
+      emitUpdatedToolOutput(outcome.updatedToolOutput);
+  } catch {} finally {
+    clearTimeout(timer);
+  }
+}
+var init_post_tool = __esm(() => {
+  init_compress_tool_output();
 });
 
 // src/core/pattern-engine.ts
@@ -7557,7 +7907,7 @@ function analyzePostWrite(filePath, fileContent, index) {
     indexEntry
   };
 }
-function isPostToolUseInput2(value) {
+function isPostToolUseInput3(value) {
   if (value === null || typeof value !== "object")
     return false;
   const obj = value;
@@ -7571,7 +7921,7 @@ async function postWrite(cwd) {
   const timer = setTimeout(() => process.exit(0), 1e4);
   try {
     const input = await readStdinJson();
-    if (!isPostToolUseInput2(input))
+    if (!isPostToolUseInput3(input))
       return;
     if (input.tool_name !== "Write" && input.tool_name !== "Edit")
       return;
@@ -7800,6 +8150,35 @@ var init_detect_waste = __esm(() => {
   init_device();
 });
 
+// src/commands/retrieve.ts
+var exports_retrieve = {};
+__export(exports_retrieve, {
+  retrieve: () => retrieve
+});
+function retrieve(cwd, args) {
+  const token = args[0];
+  if (!token) {
+    process.stderr.write(`[mink] usage: mink retrieve <token>
+`);
+    return;
+  }
+  let entry = null;
+  try {
+    entry = CompressionCacheRepo.for(cwd).get(token);
+  } catch {
+    entry = null;
+  }
+  if (!entry) {
+    process.stderr.write(`[mink] no retrievable output for token "${token}" (unknown or expired)
+`);
+    return;
+  }
+  process.stdout.write(entry.content);
+}
+var init_retrieve = __esm(() => {
+  init_compression_cache_repo();
+});
+
 // src/core/cron-parser.ts
 function parseField(field, min, max) {
   const values = new Set;
@@ -7882,9 +8261,9 @@ __export(exports_self_update, {
   PACKAGE_NAME: () => PACKAGE_NAME
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname11 } from "path";
-import { join as join23 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname10 } from "path";
+import { join as join21 } from "path";
 function parseSemver(input) {
   const trimmed = input.trim().replace(/^v/, "");
   if (!trimmed)
@@ -7931,15 +8310,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 = dirname10(selfPath);
   let packageJsonPath = null;
   for (let i = 0;i < 10; i++) {
-    const candidate = join23(dir, "package.json");
-    if (existsSync26(candidate)) {
+    const candidate = join21(dir, "package.json");
+    if (existsSync24(candidate)) {
       packageJsonPath = candidate;
       break;
     }
-    const parent = dirname11(dir);
+    const parent = dirname10(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -8009,7 +8388,7 @@ function buildInstallCommand(pm, version) {
   return ["npm", "install", "-g", ref];
 }
 function selfUpdateLogPath() {
-  return join23(minkRoot(), "self-update.log");
+  return join21(minkRoot(), "self-update.log");
 }
 function appendLogEntry(entry) {
   const path = selfUpdateLogPath();
@@ -8798,21 +9177,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 readFileSync21, mkdirSync as mkdirSync14 } from "fs";
+import { join as join22 } from "path";
+import { existsSync as existsSync25, writeFileSync as writeFileSync9, readFileSync as readFileSync21, mkdirSync as mkdirSync13 } from "fs";
 function seedTemplates(templatesDir) {
-  mkdirSync14(templatesDir, { recursive: true });
+  mkdirSync13(templatesDir, { recursive: true });
   for (const [name, content] of Object.entries(DEFAULT_TEMPLATES)) {
-    const filePath = join24(templatesDir, `${name}.md`);
-    if (!existsSync27(filePath)) {
+    const filePath = join22(templatesDir, `${name}.md`);
+    if (!existsSync25(filePath)) {
       writeFileSync9(filePath, content);
     }
   }
 }
 function loadTemplate(templatesDir, templateName, vars) {
-  const filePath = join24(templatesDir, `${templateName}.md`);
+  const filePath = join22(templatesDir, `${templateName}.md`);
   let content;
-  if (existsSync27(filePath)) {
+  if (existsSync25(filePath)) {
     content = readFileSync21(filePath, "utf-8");
   } else if (DEFAULT_TEMPLATES[templateName]) {
     content = DEFAULT_TEMPLATES[templateName];
@@ -8966,29 +9345,29 @@ category: resources
 });
 
 // src/core/note-writer.ts
-import { join as join25 } from "path";
-import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
+import { join as join23 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
 import { createHash as createHash3 } from "crypto";
 function sha256(content) {
   return createHash3("sha256").update(content).digest("hex");
 }
 function resolveUniqueNotePath(dir, baseSlug, content) {
   const targetHash = sha256(content);
-  const primary = join25(dir, `${baseSlug}.md`);
-  if (!existsSync28(primary))
+  const primary = join23(dir, `${baseSlug}.md`);
+  if (!existsSync26(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 = join23(dir, `${baseSlug}-${suffix}.md`);
+    if (!existsSync26(candidate))
       return candidate;
     if (sameContent(candidate, targetHash))
       return candidate;
   }
-  return join25(dir, `${baseSlug}-${Date.now()}.md`);
+  return join23(dir, `${baseSlug}-${Date.now()}.md`);
 }
 function sameContent(filePath, expectedHash) {
   try {
@@ -9063,8 +9442,8 @@ ${meta.body}
 }
 function appendToDaily(date, content) {
   const dir = vaultDailyDir();
-  const filePath = join25(dir, `${date}.md`);
-  if (existsSync28(filePath)) {
+  const filePath = join23(dir, `${date}.md`);
+  if (existsSync26(filePath)) {
     const timestamp = new Date().toLocaleTimeString("en-US", {
       hour: "2-digit",
       minute: "2-digit",
@@ -9173,10 +9552,10 @@ var init_design_eval = __esm(() => {
 });
 
 // src/core/dashboard-api.ts
-import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
 import { readdirSync as readdirSync9, readFileSync as readFileSyncFS, existsSync as fsExistsSync } from "fs";
-import { join as join26, resolve as resolve6, normalize, sep } from "path";
-import { execSync as execSync7 } from "child_process";
+import { join as join24, resolve as resolve5, normalize, sep } from "path";
+import { execSync as execSync6 } from "child_process";
 function isSecretKey(key) {
   return SECRET_KEY_PATTERNS.some((re) => re.test(key));
 }
@@ -9188,7 +9567,7 @@ function maskSecret(value, showLast = 4) {
   return "\u2022\u2022\u2022\u2022" + value.slice(-showLast);
 }
 function checkJsonFile2(name, filePath, validator) {
-  if (!existsSync29(filePath))
+  if (!existsSync27(filePath))
     return { name, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -9198,7 +9577,7 @@ function checkJsonFile2(name, filePath, validator) {
   return { name, status: "ok" };
 }
 function checkTextFile(name, filePath) {
-  if (!existsSync29(filePath))
+  if (!existsSync27(filePath))
     return { name, status: "missing" };
   try {
     readFileSync23(filePath, "utf-8");
@@ -9208,7 +9587,7 @@ function checkTextFile(name, filePath) {
   }
 }
 function checkDbFile2(name, filePath) {
-  if (!existsSync29(filePath))
+  if (!existsSync27(filePath))
     return { name, status: "missing" };
   try {
     const header = readFileSync23(filePath).slice(0, 16).toString("utf-8");
@@ -9250,14 +9629,26 @@ function loadOverview(cwd) {
     checkTextFile("action-log.md", actionLogPath(cwd)),
     checkJsonFile2("scheduler-manifest.json", schedulerManifestPath(cwd))
   ];
-  return { project, daemon, summary, stateFiles };
+  return { project, daemon, summary, compression: ledger.compression, stateFiles };
 }
 function loadTokenLedgerPanel(cwd) {
   const ledger = aggregateTokenLedger(cwd);
   return {
     lifetime: ledger.lifetime,
     sessions: ledger.sessions,
-    wasteFlags: ledger.wasteFlags ?? []
+    wasteFlags: ledger.wasteFlags ?? [],
+    compression: ledger.compression
+  };
+}
+function loadCompressionPanel(cwd) {
+  const repo = TokenLedgerRepo.for(cwd);
+  return {
+    enabled: loadCompressionConfig().enabled,
+    lifetime: repo.compressionLifetime(),
+    arms: repo.compressionArms(),
+    byKind: repo.compressionBreakdown("content_kind"),
+    byTool: repo.compressionBreakdown("tool_name"),
+    recent: repo.compressionEvents(50)
   };
 }
 function loadFileIndexPanel(cwd) {
@@ -9390,7 +9781,7 @@ function getAheadBehind(branch) {
   if (!branch)
     return { ahead: 0, behind: 0 };
   try {
-    const raw = execSync7(`git rev-list --left-right --count origin/${branch}...${branch}`, { cwd: minkRoot(), timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    const raw = execSync6(`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,
@@ -9402,7 +9793,7 @@ function getAheadBehind(branch) {
 }
 function getPendingChanges() {
   try {
-    const raw = execSync7("git status --porcelain", {
+    const raw = execSync6("git status --porcelain", {
       cwd: minkRoot(),
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -9474,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 = join24(dir, entry.name);
       if (entry.isDirectory()) {
         count += countMarkdownIn(fullPath);
       } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
@@ -9503,7 +9894,7 @@ function buildVaultTree(root) {
     for (const entry of entries) {
       if (!entry.isDir)
         continue;
-      const fullPath = join26(dir, entry.name);
+      const fullPath = join24(dir, entry.name);
       const relPath = fullPath.slice(root.length + 1);
       const count = countMarkdownIn(fullPath);
       nodes.push({ name: entry.name, path: relPath, count, depth });
@@ -9588,7 +9979,7 @@ function resolveVaultRelativePath(relPath) {
   if (!relPath || relPath.includes("\x00"))
     return null;
   const root = resolveVaultPath();
-  const absolute = resolve6(root, relPath);
+  const absolute = resolve5(root, relPath);
   const normalizedRoot = normalize(root) + sep;
   if (!absolute.startsWith(normalizedRoot) && absolute !== normalize(root)) {
     return null;
@@ -9926,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("~/") ? join24(process.env.HOME ?? "", sourcePath.slice(2)) : sourcePath;
     if (!fsExistsSync(expanded)) {
       return { success: false, error: `Source file not found: ${sourcePath}` };
     }
@@ -9986,6 +10377,8 @@ var init_dashboard_api = __esm(() => {
   init_note_writer();
   init_paths();
   init_config();
+  init_token_ledger_repo();
+  init_compression();
   init_design_eval();
   SECRET_KEY_PATTERNS = [/token/i, /secret/i, /password/i, /api[-_]?key/i];
   BOOLEAN_VALUES = new Set(["true", "false"]);
@@ -10013,8 +10406,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 existsSync28 } from "fs";
+import { basename as basename7, dirname as dirname11, join as join25, extname as extname2 } from "path";
 
 class SSEManager {
   clients = new Map;
@@ -10191,15 +10584,15 @@ async function startDashboardServer(cwd, options = {}) {
       timestamp: new Date().toISOString()
     });
   });
-  const __dir = dirname12(new URL(import.meta.url).pathname);
+  const __dir = dirname11(new URL(import.meta.url).pathname);
   let pkgRoot = __dir;
-  while (pkgRoot !== dirname12(pkgRoot)) {
-    if (existsSync30(join27(pkgRoot, "package.json")))
+  while (pkgRoot !== dirname11(pkgRoot)) {
+    if (existsSync28(join25(pkgRoot, "package.json")))
       break;
-    pkgRoot = dirname12(pkgRoot);
+    pkgRoot = dirname11(pkgRoot);
   }
-  const dashboardOutDir = join27(pkgRoot, "dashboard", "out");
-  const dashboardBuilt = existsSync30(join27(dashboardOutDir, "index.html"));
+  const dashboardOutDir = join25(pkgRoot, "dashboard", "out");
+  const dashboardBuilt = existsSync28(join25(dashboardOutDir, "index.html"));
   let clientIdCounter = 0;
   if (!dashboardBuilt) {
     console.warn("[mink] dashboard not built. Run: cd dashboard && bun run build");
@@ -10229,9 +10622,9 @@ async function startDashboardServer(cwd, options = {}) {
         } else {
           let filePath;
           if (pathname === "/") {
-            filePath = join27(dashboardOutDir, "index.html");
+            filePath = join25(dashboardOutDir, "index.html");
           } else {
-            filePath = join27(dashboardOutDir, pathname);
+            filePath = join25(dashboardOutDir, pathname);
           }
           if (!filePath.startsWith(dashboardOutDir)) {
             return jsonResponse({ error: "Forbidden" }, 403);
@@ -10244,7 +10637,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(join25(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
           if (indexServed)
             return indexServed;
         }
@@ -10335,6 +10728,8 @@ retry: 3000
               return jsonResponse(loadOverview(resolvedCwd));
             case "/api/token-ledger":
               return jsonResponse(loadTokenLedgerPanel(resolvedCwd));
+            case "/api/compression":
+              return jsonResponse(loadCompressionPanel(resolvedCwd));
             case "/api/file-index":
               return jsonResponse(loadFileIndexPanel(resolvedCwd));
             case "/api/scheduler":
@@ -10353,7 +10748,7 @@ retry: 3000
             if (!filename || filename.includes("..") || filename.includes("/")) {
               return jsonResponse({ error: "Invalid filename" }, 400);
             }
-            const imgPath = join27(designCapturesDir(resolvedCwd), filename);
+            const imgPath = join25(designCapturesDir(resolvedCwd), filename);
             const served = await serveFile(imgPath, "image/jpeg");
             if (served) {
               served.headers.set("Cache-Control", "public, max-age=60");
@@ -10588,9 +10983,9 @@ __export(exports_dashboard, {
   resolveStartupCwd: () => resolveStartupCwd,
   dashboard: () => dashboard
 });
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 function resolveStartupCwd(cwd, registered = listRegisteredProjects()) {
-  if (existsSync31(projectDir(cwd))) {
+  if (existsSync29(projectDir(cwd))) {
     return { kind: "active", cwd };
   }
   if (registered.length === 0) {
@@ -10627,10 +11022,10 @@ var init_dashboard = __esm(() => {
 });
 
 // src/core/daemon-service.ts
-import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync15, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname13, join as join28 } from "path";
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync30, mkdirSync as mkdirSync14, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname12, join as join26 } from "path";
 function detectPlatform() {
   if (process.platform === "linux")
     return "systemd";
@@ -10640,11 +11035,11 @@ function detectPlatform() {
 }
 function resolveServiceInvocation() {
   const entry = process.argv[1];
-  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync32(entry)) {
+  if (entry && !/\.(js|ts|mjs|cjs)$/.test(entry) && existsSync30(entry)) {
     return {
       executable: entry,
       args: ["daemon", "start"],
-      pathDir: dirname13(entry)
+      pathDir: dirname12(entry)
     };
   }
   const cliPath = resolveCliPath();
@@ -10652,17 +11047,17 @@ function resolveServiceInvocation() {
   return {
     executable: interpreter,
     args: [cliPath, "daemon", "start"],
-    pathDir: dirname13(interpreter)
+    pathDir: dirname12(interpreter)
   };
 }
 function servicePaths(platform2) {
-  const home = homedir4();
+  const home = homedir3();
   if (platform2 === "systemd") {
-    const unitDir2 = join28(home, ".config", "systemd", "user");
-    return { unitDir: unitDir2, unitFile: join28(unitDir2, "mink-daemon.service") };
+    const unitDir2 = join26(home, ".config", "systemd", "user");
+    return { unitDir: unitDir2, unitFile: join26(unitDir2, "mink-daemon.service") };
   }
-  const unitDir = join28(home, "Library", "LaunchAgents");
-  return { unitDir, unitFile: join28(unitDir, "com.mink.daemon.plist") };
+  const unitDir = join26(home, "Library", "LaunchAgents");
+  return { unitDir, unitFile: join26(unitDir, "com.mink.daemon.plist") };
 }
 function renderSystemdUnit(inv) {
   const execStart = [inv.executable, ...inv.args].join(" ");
@@ -10736,17 +11131,17 @@ function installService(options = {}) {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (existsSync32(paths.unitFile) && !options.force) {
+  if (existsSync30(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 });
+  mkdirSync14(paths.unitDir, { recursive: true });
   if (platform2 === "systemd") {
     writeFileSync10(paths.unitFile, renderSystemdUnit(inv));
     try {
-      execSync8("systemctl --user daemon-reload", { stdio: "ignore" });
+      execSync7("systemctl --user daemon-reload", { stdio: "ignore" });
     } catch {}
     console.log(`[mink] wrote ${paths.unitFile}`);
     console.log("[mink] next steps:");
@@ -10769,24 +11164,24 @@ function uninstallService() {
     process.exit(1);
   }
   const paths = servicePaths(platform2);
-  if (!existsSync32(paths.unitFile)) {
+  if (!existsSync30(paths.unitFile)) {
     console.log(`[mink] no unit file at ${paths.unitFile} \u2014 nothing to uninstall`);
     return;
   }
   if (platform2 === "systemd") {
     try {
-      execSync8("systemctl --user disable --now mink-daemon.service", {
+      execSync7("systemctl --user disable --now mink-daemon.service", {
         stdio: "ignore"
       });
     } catch {}
     unlinkSync5(paths.unitFile);
     try {
-      execSync8("systemctl --user daemon-reload", { stdio: "ignore" });
+      execSync7("systemctl --user daemon-reload", { stdio: "ignore" });
     } catch {}
     console.log(`[mink] removed ${paths.unitFile}`);
   } else {
     try {
-      execSync8(`launchctl unload -w ${paths.unitFile}`, { stdio: "ignore" });
+      execSync7(`launchctl unload -w ${paths.unitFile}`, { stdio: "ignore" });
     } catch {}
     unlinkSync5(paths.unitFile);
     console.log(`[mink] removed ${paths.unitFile}`);
@@ -10801,7 +11196,7 @@ var exports_daemon = {};
 __export(exports_daemon, {
   daemon: () => daemon
 });
-import { readFileSync as readFileSync24, existsSync as existsSync33 } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync31 } from "fs";
 async function daemon(cwd, args) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -10817,7 +11212,7 @@ async function daemon(cwd, args) {
       break;
     case "logs": {
       const logPath = schedulerLogPath();
-      if (!existsSync33(logPath)) {
+      if (!existsSync31(logPath)) {
         console.log("[mink] no log file found");
         return;
       }
@@ -11089,13 +11484,13 @@ function printValidKeys() {
   }
 }
 function readLineFromStdin() {
-  return new Promise((resolve8) => {
+  return new Promise((resolve7) => {
     const chunks = [];
     process.stdin.resume();
     process.stdin.setEncoding("utf-8");
     process.stdin.once("data", (data) => {
       process.stdin.pause();
-      resolve8(String(data).trim());
+      resolve7(String(data).trim());
     });
   });
 }
@@ -11170,7 +11565,7 @@ var exports_update = {};
 __export(exports_update, {
   update: () => update
 });
-import { resolve as resolve8 } from "path";
+import { resolve as resolve7 } from "path";
 function parseArgs(args) {
   let dryRun = false;
   let project = null;
@@ -11228,7 +11623,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 = resolve7(target.cwd, ".claude", "settings.json");
     mergeHooksIntoSettings(settingsPath, newHooks);
     console.log("  hooks: updated");
     const metaPath = projectMetaPath(target.cwd);
@@ -11404,7 +11799,7 @@ var init_restore = __esm(() => {
 
 // src/core/design-eval/server-detect.ts
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join29 } from "path";
+import { join as join27 } from "path";
 async function probePort(port) {
   try {
     const controller = new AbortController;
@@ -11426,7 +11821,7 @@ async function findRunningServer(ports = DEFAULT_PROBE_PORTS) {
 }
 function detectDevCommand(cwd) {
   try {
-    const raw = readFileSync25(join29(cwd, "package.json"), "utf-8");
+    const raw = readFileSync25(join27(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts;
     if (!scripts || typeof scripts !== "object")
@@ -11446,10 +11841,10 @@ var init_server_detect = __esm(() => {
 });
 
 // src/core/design-eval/route-detect.ts
-import { existsSync as existsSync34, readdirSync as readdirSync10, statSync as statSync11 } from "fs";
-import { join as join30, relative as relative7, sep as sep2 } from "path";
+import { existsSync as existsSync32, readdirSync as readdirSync10, statSync as statSync11 } from "fs";
+import { join as join28, relative as relative7, sep as sep2 } from "path";
 function detectFramework(cwd) {
-  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync34(join30(cwd, `${name}.${ext}`))) || existsSync34(join30(cwd, name));
+  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync32(join28(cwd, `${name}.${ext}`))) || existsSync32(join28(cwd, name));
   if (has("next.config"))
     return "nextjs";
   if (has("svelte.config"))
@@ -11474,8 +11869,8 @@ function detectRoutes(cwd) {
 }
 function detectNextRoutes(cwd) {
   const routes = [];
-  const appDir = join30(cwd, "app");
-  if (existsSync34(appDir)) {
+  const appDir = join28(cwd, "app");
+  if (existsSync32(appDir)) {
     const pageFiles = findFiles(appDir, /^page\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative7(appDir, file);
@@ -11486,8 +11881,8 @@ function detectNextRoutes(cwd) {
       routes.push(route);
     }
   }
-  const pagesDir = join30(cwd, "pages");
-  if (existsSync34(pagesDir)) {
+  const pagesDir = join28(cwd, "pages");
+  if (existsSync32(pagesDir)) {
     const pageFiles = findFiles(pagesDir, /\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative7(pagesDir, file);
@@ -11506,8 +11901,8 @@ function detectNextRoutes(cwd) {
   return unique.length > 0 ? unique.sort() : ["/"];
 }
 function detectSvelteKitRoutes(cwd) {
-  const routesDir = join30(cwd, "src", "routes");
-  if (!existsSync34(routesDir))
+  const routesDir = join28(cwd, "src", "routes");
+  if (!existsSync32(routesDir))
     return ["/"];
   const routes = [];
   const pageFiles = findFiles(routesDir, /^\+page\.svelte$/);
@@ -11522,8 +11917,8 @@ function detectSvelteKitRoutes(cwd) {
   return routes.length > 0 ? routes.sort() : ["/"];
 }
 function detectNuxtRoutes(cwd) {
-  const pagesDir = join30(cwd, "pages");
-  if (!existsSync34(pagesDir))
+  const pagesDir = join28(cwd, "pages");
+  if (!existsSync32(pagesDir))
     return ["/"];
   const routes = [];
   const vueFiles = findFiles(pagesDir, /\.vue$/);
@@ -11549,7 +11944,7 @@ function findFiles(dir, pattern) {
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
-      const full = join30(current, entry);
+      const full = join28(current, entry);
       try {
         const stat2 = statSync11(full);
         if (stat2.isDirectory()) {
@@ -11577,11 +11972,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(resolve8) {
+      resolve8(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve9, reject) {
+  return new (P || (P = Promise))(function(resolve8, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -11597,7 +11992,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -11780,14 +12175,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(resolve8, reject) {
+        v = o[n](v), settle(resolve8, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve9, reject, d, v) {
+  function settle(resolve8, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve9({ value: v2, done: d });
+      resolve8({ value: v2, done: d });
     }, reject);
   }
 }
@@ -12318,7 +12713,7 @@ function of() {
 }
 function lastValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve9, reject) {
+  return new Promise(function(resolve8, reject) {
     var _hasValue = false;
     var _value;
     source.subscribe({
@@ -12329,9 +12724,9 @@ function lastValueFrom(source, config22) {
       error: reject,
       complete: function() {
         if (_hasValue) {
-          resolve9(_value);
+          resolve8(_value);
         } else if (hasConfig) {
-          resolve9(config22.defaultValue);
+          resolve8(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -12341,16 +12736,16 @@ function lastValueFrom(source, config22) {
 }
 function firstValueFrom(source, config22) {
   var hasConfig = typeof config22 === "object";
-  return new Promise(function(resolve9, reject) {
+  return new Promise(function(resolve8, reject) {
     var subscriber = new SafeSubscriber({
       next: function(value) {
-        resolve9(value);
+        resolve8(value);
         subscriber.unsubscribe();
       },
       error: reject,
       complete: function() {
         if (hasConfig) {
-          resolve9(config22.defaultValue);
+          resolve8(config22.defaultValue);
         } else {
           reject(new EmptyError);
         }
@@ -13402,7 +13797,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(resolve8, reject) {
         var subscriber = new SafeSubscriber({
           next: function(value) {
             try {
@@ -13413,7 +13808,7 @@ var init_rxjs = __esm(() => {
             }
           },
           error: reject,
-          complete: resolve9
+          complete: resolve8
         });
         _this.subscribe(subscriber);
       });
@@ -13435,14 +13830,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(resolve8, reject) {
         var value;
         _this.subscribe(function(x) {
           return value = x;
         }, function(err) {
           return reject(err);
         }, function() {
-          return resolve9(value);
+          return resolve8(value);
         });
       });
     };
@@ -15368,8 +15763,8 @@ class Deferred {
   #isRejected = false;
   #value;
   #resolve;
-  #taskPromise = new Promise((resolve9) => {
-    this.#resolve = resolve9;
+  #taskPromise = new Promise((resolve8) => {
+    this.#resolve = resolve8;
   });
   #timeoutId;
   #timeoutError;
@@ -15458,12 +15853,12 @@ var init_Mutex = __esm(() => {
       return new Mutex.Guard(this, onRelease);
     }
     release() {
-      const resolve9 = this.#acquirers.shift();
-      if (!resolve9) {
+      const resolve8 = this.#acquirers.shift();
+      if (!resolve8) {
         this.#locked = false;
         return;
       }
-      resolve9();
+      resolve8();
     }
   };
 });
@@ -17207,12 +17602,12 @@ var init_locators = __esm(() => {
       }
       return defer(() => {
         return from(handle.evaluate((element) => {
-          return new Promise((resolve9) => {
+          return new Promise((resolve8) => {
             window.requestAnimationFrame(() => {
               const rect1 = element.getBoundingClientRect();
               window.requestAnimationFrame(() => {
                 const rect2 = element.getBoundingClientRect();
-                resolve9([
+                resolve8([
                   {
                     x: rect1.x,
                     y: rect1.y,
@@ -18503,9 +18898,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((resolve8) => {
               const observer = new IntersectionObserver((entries) => {
-                resolve9(entries[0].intersectionRatio);
+                resolve8(entries[0].intersectionRatio);
                 observer.disconnect();
               });
               observer.observe(element);
@@ -18899,7 +19294,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((resolve8, reject) => {
             const script = document.createElement("script");
             script.type = type2;
             script.text = content2;
@@ -18912,12 +19307,12 @@ var init_Frame = __esm(() => {
             if (url) {
               script.src = url;
               script.addEventListener("load", () => {
-                resolve9(script);
+                resolve8(script);
               }, { once: true });
               document.head.appendChild(script);
             } else {
               document.head.appendChild(script);
-              resolve9(script);
+              resolve8(script);
             }
           });
         }, { ...options, type, content }));
@@ -18934,7 +19329,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((resolve8, reject) => {
             let element;
             if (!url) {
               element = document.createElement("style");
@@ -18946,7 +19341,7 @@ var init_Frame = __esm(() => {
               element = link;
             }
             element.addEventListener("load", () => {
-              resolve9(element);
+              resolve8(element);
             }, { once: true });
             element.addEventListener("error", (event) => {
               reject(new Error(event.message ?? "Could not load style"));
@@ -19800,9 +20195,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((resolve8) => {
               return this.mainFrame().client.once("Page.screencastFrame", () => {
-                return resolve9();
+                return resolve8();
               });
             });
           });
@@ -22460,11 +22855,11 @@ function addPageBinding(type, name, prefix) {
           return value instanceof Node;
         })
       }));
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve8, reject) => {
         callPuppeteer.callbacks.set(seq, {
           resolve(value) {
             callPuppeteer.args.delete(seq);
-            resolve9(value);
+            resolve8(value);
           },
           reject(value) {
             callPuppeteer.args.delete(seq);
@@ -25927,8 +26322,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((resolve8) => {
+          setTimeout(resolve8, delay);
         });
       }
       actions.push(this.up({ ...options, clickCount }));
@@ -25948,9 +26343,9 @@ var init_Input2 = __esm(() => {
       });
     }
     async drag(start, target) {
-      const promise = new Promise((resolve9) => {
+      const promise = new Promise((resolve8) => {
         this.#client.once("Input.dragIntercepted", (event) => {
-          return resolve9(event.data);
+          return resolve8(event.data);
         });
       });
       await this.move(start.x, start.y);
@@ -25991,8 +26386,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((resolve8) => {
+          return setTimeout(resolve8, delay);
         });
       }
       await this.drop(target, data);
@@ -26804,9 +27199,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((resolve8, reject) => {
         stream.on("error", reject);
-        stream.on("finish", resolve9);
+        stream.on("finish", resolve8);
       });
       const client = this.#primaryTargetClient;
       await client.send("HeapProfiler.enable");
@@ -28319,10 +28714,10 @@ __export(exports_BrowserWebSocketTransport, {
 
 class BrowserWebSocketTransport {
   static create(url) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       const ws = new WebSocket(url);
       ws.addEventListener("open", () => {
-        return resolve9(new BrowserWebSocketTransport(ws));
+        return resolve8(new BrowserWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -31156,11 +31551,11 @@ var require_BrowsingContextProcessor = __commonJS((exports) => {
       }
       const parentCdpClient = context2.cdpTarget.parentCdpClient;
       try {
-        const detachedFromTargetPromise = new Promise((resolve9) => {
+        const detachedFromTargetPromise = new Promise((resolve8) => {
           const onContextDestroyed = (event) => {
             if (event.targetId === params.context) {
               parentCdpClient.off("Target.detachedFromTarget", onContextDestroyed);
-              resolve9();
+              resolve8();
             }
           };
           parentCdpClient.on("Target.detachedFromTarget", onContextDestroyed);
@@ -32480,7 +32875,7 @@ var require_ActionDispatcher = __commonJS((exports) => {
         }
       }
       const promises = [
-        new Promise((resolve9) => setTimeout(resolve9, this.#tickDuration))
+        new Promise((resolve8) => setTimeout(resolve8, this.#tickDuration))
       ];
       for (const option of options) {
         promises.push(this.#dispatchAction(option));
@@ -33079,8 +33474,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((resolve8) => {
+          this.#acquirers.push(() => resolve8(this.#release.bind(this, state)));
         });
       }
       this.#locked = true;
@@ -33091,12 +33486,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 resolve8 = this.#acquirers.shift();
+      if (!resolve8) {
         this.#locked = false;
         return;
       }
-      resolve9();
+      resolve8();
     }
     async run(action) {
       const release = await this.acquire();
@@ -34223,8 +34618,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((resolve8) => {
+              queueNonEmptyResolver = resolve8;
             });
             await onMessage;
             return queue.shift();
@@ -34310,7 +34705,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((resolve8) => w[id] = resolve8);
           }
           const channelProxy = w[id];
           delete w[id];
@@ -35661,8 +36056,8 @@ var require_Deferred = __commonJS((exports) => {
       return this.#result;
     }
     constructor() {
-      this.#promise = new Promise((resolve9, reject) => {
-        this.#resolve = resolve9;
+      this.#promise = new Promise((resolve8, reject) => {
+        this.#resolve = resolve8;
         this.#reject = reject;
       });
       this.#promise.catch((_error) => {});
@@ -39987,11 +40382,11 @@ var require_BrowsingContextStorage = __commonJS((exports) => {
       if (this.#contexts.has(browsingContextId)) {
         return Promise.resolve(this.getContext(browsingContextId));
       }
-      return new Promise((resolve9) => {
+      return new Promise((resolve8) => {
         const listener = (event) => {
           if (event.browsingContext.id === browsingContextId) {
             this.#eventEmitter.off("added", listener);
-            resolve9(event.browsingContext);
+            resolve8(event.browsingContext);
           }
         };
         this.#eventEmitter.on("added", listener);
@@ -43487,8 +43882,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((resolve8, reject) => {
+              callback([resolve8, reject, args]);
             });
           }
         });
@@ -43576,8 +43971,8 @@ var init_ExposedFunction = __esm(() => {
           return;
         }
         try {
-          await dataHandle.evaluate(([resolve9], result2) => {
-            resolve9(result2);
+          await dataHandle.evaluate(([resolve8], result2) => {
+            resolve8(result2);
           }, result);
         } catch (error) {
           debugError(error);
@@ -48004,7 +48399,7 @@ import NodeWebSocket from "ws";
 
 class NodeWebSocketTransport {
   static create(url, headers) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       const ws = new NodeWebSocket(url, [], {
         followRedirects: true,
         perMessageDeflate: false,
@@ -48016,7 +48411,7 @@ class NodeWebSocketTransport {
         }
       });
       ws.addEventListener("open", () => {
-        return resolve9(new NodeWebSocketTransport(ws));
+        return resolve8(new NodeWebSocketTransport(ws));
       });
       ws.addEventListener("error", reject);
     });
@@ -50906,8 +51301,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((resolve8, reject) => {
+      req2.once("response", resolve8).once("error", reject).end();
     });
     req2.then = promise.then.bind(promise);
     return req2;
@@ -51278,7 +51673,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((resolve8, reject) => {
       let buffersLength = 0;
       const buffers = [];
       function read() {
@@ -51347,7 +51742,7 @@ var require_parse_proxy_response = __commonJS((exports) => {
         }
         debug2("got proxy server response: %o %o", firstLine, headers);
         cleanup();
-        resolve9({
+        resolve8({
           connect: {
             statusCode,
             statusText,
@@ -53451,11 +53846,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(resolve8) {
+        resolve8(value);
       });
     }
-    return new (P || (P = Promise))(function(resolve9, reject) {
+    return new (P || (P = Promise))(function(resolve8, reject) {
       function fulfilled(value) {
         try {
           step(generator.next(value));
@@ -53471,7 +53866,7 @@ var require_socksclient = __commonJS((exports) => {
         }
       }
       function step(result) {
-        result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+        result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
@@ -53498,13 +53893,13 @@ var require_socksclient = __commonJS((exports) => {
       this.setState(constants_1.SocksClientState.Created);
     }
     static createConnection(options, callback) {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve8, reject) => {
         try {
           (0, helpers_1.validateSocksClientOptions)(options, ["connect"]);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve9(err);
+            return resolve8(err);
           } else {
             return reject(err);
           }
@@ -53515,16 +53910,16 @@ var require_socksclient = __commonJS((exports) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(null, info);
-            resolve9(info);
+            resolve8(info);
           } else {
-            resolve9(info);
+            resolve8(info);
           }
         });
         client.once("error", (err) => {
           client.removeAllListeners();
           if (typeof callback === "function") {
             callback(err);
-            resolve9(err);
+            resolve8(err);
           } else {
             reject(err);
           }
@@ -53532,13 +53927,13 @@ var require_socksclient = __commonJS((exports) => {
       });
     }
     static createConnectionChain(options, callback) {
-      return new Promise((resolve9, reject) => __awaiter2(this, undefined, undefined, function* () {
+      return new Promise((resolve8, reject) => __awaiter2(this, undefined, undefined, function* () {
         try {
           (0, helpers_1.validateSocksClientChainOptions)(options);
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            return resolve9(err);
+            return resolve8(err);
           } else {
             return reject(err);
           }
@@ -53564,14 +53959,14 @@ var require_socksclient = __commonJS((exports) => {
           }
           if (typeof callback === "function") {
             callback(null, { socket: sock });
-            resolve9({ socket: sock });
+            resolve8({ socket: sock });
           } else {
-            resolve9({ socket: sock });
+            resolve8({ socket: sock });
           }
         } catch (err) {
           if (typeof callback === "function") {
             callback(err);
-            resolve9(err);
+            resolve8(err);
           } else {
             reject(err);
           }
@@ -54171,12 +54566,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((resolve8, reject) => {
           lookupFn(host, {}, (err, res) => {
             if (err) {
               reject(err);
             } else {
-              resolve9(res);
+              resolve8(res);
             }
           });
         });
@@ -55183,7 +55578,7 @@ var require_netUtils = __commonJS((exports) => {
     return `${socket.remoteAddress}:${socket.remotePort}`;
   }
   function upgradeSocket(socket, options) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       const tlsOptions = Object.assign({}, options, {
         socket
       });
@@ -55193,7 +55588,7 @@ var require_netUtils = __commonJS((exports) => {
           reject(tlsSocket.authorizationError);
         } else {
           tlsSocket.removeAllListeners("error");
-          resolve9(tlsSocket);
+          resolve8(tlsSocket);
         }
       }).once("error", (error) => {
         reject(error);
@@ -55285,7 +55680,7 @@ var require_transfer = __commonJS((exports) => {
     };
   }
   function connectForPassiveTransfer(host, port, ftp) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       let socket = ftp._newSocket();
       const handleConnErr = function(err) {
         err.message = "Can't open data connection in passive mode: " + err.message;
@@ -55308,7 +55703,7 @@ var require_transfer = __commonJS((exports) => {
         socket.removeListener("error", handleConnErr);
         socket.removeListener("timeout", handleTimeout);
         ftp.dataSocket = socket;
-        resolve9();
+        resolve8();
       });
     });
   }
@@ -57386,7 +57781,7 @@ var require_util2 = __commonJS((exports) => {
     return path;
   }
   exports.normalize = normalize2;
-  function join31(aRoot, aPath) {
+  function join29(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -57418,7 +57813,7 @@ var require_util2 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join31;
+  exports.join = join29;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -57591,7 +57986,7 @@ var require_util2 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join31(urlGenerate(parsed), sourceURL);
+      sourceURL = join29(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -59323,7 +59718,7 @@ var require_escodegen = __commonJS((exports) => {
     function noEmptySpace() {
       return space ? space : " ";
     }
-    function join31(left, right) {
+    function join29(left, right) {
       var leftSource, rightSource, leftCharCode, rightCharCode;
       leftSource = toSourceNodeWhenNeeded(left).toString();
       if (leftSource.length === 0) {
@@ -59664,8 +60059,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
         }
-        result = join31(result, operator);
-        result = [join31(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
+        result = join29(result, operator);
+        result = [join29(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
       });
       result.push(this.maybeBlock(stmt.body, flags));
       return result;
@@ -59803,11 +60198,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (stmt.id) {
-          result = join31(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+          result = join29(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
         }
         if (stmt.superClass) {
-          fragment = join31("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-          result = join31(result, fragment);
+          fragment = join29("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+          result = join29(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -59820,9 +60215,9 @@ var require_escodegen = __commonJS((exports) => {
         return escapeDirective(stmt.directive) + this.semicolon(flags);
       },
       DoWhileStatement: function(stmt, flags) {
-        var result = join31("do", this.maybeBlock(stmt.body, S_TFFF));
+        var result = join29("do", this.maybeBlock(stmt.body, S_TFFF));
         result = this.maybeBlockSuffix(stmt.body, result);
-        return join31(result, [
+        return join29(result, [
           "while" + space + "(",
           this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
           ")" + this.semicolon(flags)
@@ -59858,11 +60253,11 @@ var require_escodegen = __commonJS((exports) => {
       ExportDefaultDeclaration: function(stmt, flags) {
         var result = ["export"], bodyFlags;
         bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-        result = join31(result, "default");
+        result = join29(result, "default");
         if (isStatement(stmt.declaration)) {
-          result = join31(result, this.generateStatement(stmt.declaration, bodyFlags));
+          result = join29(result, this.generateStatement(stmt.declaration, bodyFlags));
         } else {
-          result = join31(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+          result = join29(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
         }
         return result;
       },
@@ -59870,15 +60265,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 join31(result, this.generateStatement(stmt.declaration, bodyFlags));
+          return join29(result, this.generateStatement(stmt.declaration, bodyFlags));
         }
         if (stmt.specifiers) {
           if (stmt.specifiers.length === 0) {
-            result = join31(result, "{" + space + "}");
+            result = join29(result, "{" + space + "}");
           } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-            result = join31(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+            result = join29(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
           } else {
-            result = join31(result, "{");
+            result = join29(result, "{");
             withIndent(function(indent2) {
               var i, iz;
               result.push(newline);
@@ -59896,7 +60291,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(base + "}");
           }
           if (stmt.source) {
-            result = join31(result, [
+            result = join29(result, [
               "from" + space,
               this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
               this.semicolon(flags)
@@ -59980,7 +60375,7 @@ var require_escodegen = __commonJS((exports) => {
         ];
         cursor = 0;
         if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-          result = join31(result, [
+          result = join29(result, [
             this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
           ]);
           ++cursor;
@@ -59990,7 +60385,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(",");
           }
           if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-            result = join31(result, [
+            result = join29(result, [
               space,
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
@@ -60019,7 +60414,7 @@ var require_escodegen = __commonJS((exports) => {
             }
           }
         }
-        result = join31(result, [
+        result = join29(result, [
           "from" + space,
           this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
           this.semicolon(flags)
@@ -60073,7 +60468,7 @@ var require_escodegen = __commonJS((exports) => {
         return result;
       },
       ThrowStatement: function(stmt, flags) {
-        return [join31("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+        return [join29("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
       },
       TryStatement: function(stmt, flags) {
         var result, i, iz, guardedHandlers;
@@ -60081,7 +60476,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 = join31(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+            result = join29(result, this.generateStatement(stmt.handlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
             }
@@ -60089,7 +60484,7 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           guardedHandlers = stmt.guardedHandlers || [];
           for (i = 0, iz = guardedHandlers.length;i < iz; ++i) {
-            result = join31(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+            result = join29(result, this.generateStatement(guardedHandlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
             }
@@ -60097,13 +60492,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 = join31(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                result = join29(result, this.generateStatement(stmt.handler[i], S_TFFF));
                 if (stmt.finalizer || i + 1 !== iz) {
                   result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                 }
               }
             } else {
-              result = join31(result, this.generateStatement(stmt.handler, S_TFFF));
+              result = join29(result, this.generateStatement(stmt.handler, S_TFFF));
               if (stmt.finalizer) {
                 result = this.maybeBlockSuffix(stmt.handler.body, result);
               }
@@ -60111,7 +60506,7 @@ var require_escodegen = __commonJS((exports) => {
           }
         }
         if (stmt.finalizer) {
-          result = join31(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+          result = join29(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
         }
         return result;
       },
@@ -60145,7 +60540,7 @@ var require_escodegen = __commonJS((exports) => {
         withIndent(function() {
           if (stmt.test) {
             result = [
-              join31("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+              join29("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
               ":"
             ];
           } else {
@@ -60193,9 +60588,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 = join31(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+            result = join29(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
           } else {
-            result = join31(result, join31("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+            result = join29(result, join29("else", this.maybeBlock(stmt.alternate, bodyFlags)));
           }
         } else {
           result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -60297,7 +60692,7 @@ var require_escodegen = __commonJS((exports) => {
       },
       ReturnStatement: function(stmt, flags) {
         if (stmt.argument) {
-          return [join31("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+          return [join29("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
         }
         return ["return" + this.semicolon(flags)];
       },
@@ -60379,14 +60774,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 = join31(fragment, expr.operator);
+          result = join29(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 = join31(result, fragment);
+          result = join29(result, fragment);
         }
         if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
           return ["(", result, ")"];
@@ -60426,7 +60821,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 = join31("new", this.generateExpression(expr.callee, Precedence.New, itemFlags));
+        result = join29("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) {
@@ -60473,11 +60868,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment, rightCharCode, leftSource, leftCharCode;
         fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
         if (space === "") {
-          result = join31(expr.operator, fragment);
+          result = join29(expr.operator, fragment);
         } else {
           result = [expr.operator];
           if (expr.operator.length > 2) {
-            result = join31(result, fragment);
+            result = join29(result, fragment);
           } else {
             leftSource = toSourceNodeWhenNeeded(result).toString();
             leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -60500,12 +60895,12 @@ var require_escodegen = __commonJS((exports) => {
           result = "yield";
         }
         if (expr.argument) {
-          result = join31(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
+          result = join29(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
         }
         return parenthesize(result, Precedence.Yield, precedence);
       },
       AwaitExpression: function(expr, precedence, flags) {
-        var result = join31(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
+        var result = join29(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
         return parenthesize(result, Precedence.Await, precedence);
       },
       UpdateExpression: function(expr, precedence, flags) {
@@ -60577,11 +60972,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (expr.id) {
-          result = join31(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+          result = join29(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
         }
         if (expr.superClass) {
-          fragment = join31("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-          result = join31(result, fragment);
+          fragment = join29("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+          result = join29(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(expr.body, S_TFFT));
@@ -60596,7 +60991,7 @@ var require_escodegen = __commonJS((exports) => {
         }
         if (expr.kind === "get" || expr.kind === "set") {
           fragment = [
-            join31(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+            join29(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
             this.generateFunctionBody(expr.value)
           ];
         } else {
@@ -60606,7 +61001,7 @@ var require_escodegen = __commonJS((exports) => {
             this.generateFunctionBody(expr.value)
           ];
         }
-        return join31(result, fragment);
+        return join29(result, fragment);
       },
       Property: function(expr, precedence, flags) {
         if (expr.kind === "get" || expr.kind === "set") {
@@ -60800,7 +61195,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 = join31(result, fragment);
+                result = join29(result, fragment);
               } else {
                 result.push(fragment);
               }
@@ -60808,13 +61203,13 @@ var require_escodegen = __commonJS((exports) => {
           });
         }
         if (expr.filter) {
-          result = join31(result, "if" + space);
+          result = join29(result, "if" + space);
           fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-          result = join31(result, ["(", fragment, ")"]);
+          result = join29(result, ["(", fragment, ")"]);
         }
         if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
           fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-          result = join31(result, fragment);
+          result = join29(result, fragment);
         }
         result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
         return result;
@@ -60830,8 +61225,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
         }
-        fragment = join31(fragment, expr.of ? "of" : "in");
-        fragment = join31(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+        fragment = join29(fragment, expr.of ? "of" : "in");
+        fragment = join29(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
         return ["for" + space + "(", fragment, ")"];
       },
       SpreadElement: function(expr, precedence, flags) {
@@ -67319,11 +67714,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(resolve8) {
+          resolve8(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve9, reject) {
+      return new (P || (P = Promise))(function(resolve8, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -67339,7 +67734,7 @@ var require_tslib = __commonJS((exports, module) => {
           }
         }
         function step(result) {
-          result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -67568,14 +67963,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(resolve8, reject) {
+            v = o[n](v), settle(resolve8, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve9, reject, d, v) {
+      function settle(resolve8, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve9({ value: v2, done: d });
+          resolve8({ value: v2, done: d });
         }, reject);
       }
     };
@@ -70814,12 +71209,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((resolve8, reject) => {
       (0, dns_1.lookup)(host, opts, (err, res) => {
         if (err) {
           reject(err);
         } else {
-          resolve9(res);
+          resolve8(res);
         }
       });
     });
@@ -71393,10 +71788,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((resolve8, reject) => {
       const socket = net_1.default.connect({ host: "8.8.8.8", port: 53 });
       const onError = () => {
-        resolve9(ip_1.ip.address());
+        resolve8(ip_1.ip.address());
       };
       socket.once("error", onError);
       socket.once("connect", () => {
@@ -71404,9 +71799,9 @@ var require_myIpAddress = __commonJS((exports) => {
         const addr = socket.address();
         socket.destroy();
         if (typeof addr === "string") {
-          resolve9(addr);
+          resolve8(addr);
         } else if (addr.address) {
-          resolve9(addr.address);
+          resolve8(addr.address);
         } else {
           reject(new Error("Expected a `string`"));
         }
@@ -71920,8 +72315,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((resolve8) => {
+        this.onSettled = resolve8;
       });
       this.resolveHandle = args.resolveHandle;
       this.rejectHandle = args.rejectHandle;
@@ -72313,13 +72708,13 @@ var require_context = __commonJS((exports) => {
       if (vmResolveResult.error) {
         return Promise.resolve(vmResolveResult);
       }
-      return new Promise((resolve9) => {
+      return new Promise((resolve8) => {
         lifetime_1.Scope.withScope((scope) => {
           const resolveHandle = scope.manage(this.newFunction("resolve", (value) => {
-            resolve9({ value: value && value.dup() });
+            resolve8({ value: value && value.dup() });
           }));
           const rejectHandle = scope.manage(this.newFunction("reject", (error) => {
-            resolve9({ error: error && error.dup() });
+            resolve8({ error: error && error.dup() });
           }));
           const promiseHandle = scope.manage(vmResolveResult.value);
           const promiseThenHandle = scope.manage(this.getProp(promiseHandle, "then"));
@@ -74151,7 +74546,7 @@ var require_dist10 = __commonJS((exports) => {
   exports.PacProxyAgent = undefined;
   var net = __importStar(__require("net"));
   var tls = __importStar(__require("tls"));
-  var crypto = __importStar(__require("crypto"));
+  var crypto2 = __importStar(__require("crypto"));
   var events_1 = __require("events");
   var debug_1 = __importDefault(require_src());
   var url_1 = __require("url");
@@ -74201,7 +74596,7 @@ var require_dist10 = __commonJS((exports) => {
           (0, quickjs_emscripten_1.getQuickJS)(),
           this.loadPacFile()
         ]);
-        const hash = crypto.createHash("sha1").update(code).digest("hex");
+        const hash = crypto2.createHash("sha1").update(code).digest("hex");
         if (this.resolver && this.resolverHash === hash) {
           debug2("Same sha1 hash for code - contents have not changed, reusing previous proxy resolver");
           return this.resolver;
@@ -74433,13 +74828,13 @@ import * as http from "http";
 import * as https from "https";
 import { URL as URL2, urlToHttpOptions } from "url";
 function headHttpRequest(url) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve8) => {
     const request3 = httpRequest(url, "HEAD", (response) => {
       response.resume();
-      resolve9(response.statusCode === 200);
+      resolve8(response.statusCode === 200);
     }, false);
     request3.on("error", () => {
-      resolve9(false);
+      resolve8(false);
     });
   });
 }
@@ -74467,7 +74862,7 @@ function httpRequest(url, method, response, keepAlive = true) {
   return request3;
 }
 function downloadFile(url, destinationPath, progressCallback) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve8, reject) => {
     let downloadedBytes = 0;
     let totalBytes = 0;
     function onData(chunk) {
@@ -74483,7 +74878,7 @@ function downloadFile(url, destinationPath, progressCallback) {
       }
       const file = createWriteStream(destinationPath);
       file.on("close", () => {
-        return resolve9();
+        return resolve8();
       });
       file.on("error", (error) => {
         return reject(error);
@@ -74508,7 +74903,7 @@ async function getJSON(url) {
   }
 }
 function getText(url) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve8, reject) => {
     const request3 = httpRequest(url, "GET", (response) => {
       let data = "";
       if (response.statusCode && response.statusCode >= 400) {
@@ -74519,7 +74914,7 @@ function getText(url) {
       });
       response.on("end", () => {
         try {
-          return resolve9(String(data));
+          return resolve8(String(data));
         } catch {
           return reject(new Error(`Failed to read text response from ${url}`));
         }
@@ -74536,7 +74931,7 @@ var init_httpUtil = __esm(() => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import os from "os";
 import path from "path";
 function folder(platform2) {
@@ -74626,7 +75021,7 @@ function getChromeWindowsLocation(channel2, locationsPrefixes) {
 }
 function getWslVariable(variable) {
   try {
-    const result = execSync9(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
+    const result = execSync8(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf-8"
     }).trim();
@@ -74637,7 +75032,7 @@ function getWslVariable(variable) {
   return;
 }
 function getWslLocation(channel2) {
-  const wslVersion = execSync9("wslinfo --version", {
+  const wslVersion = execSync8("wslinfo --version", {
     stdio: ["ignore", "pipe", "ignore"],
     encoding: "utf-8"
   }).trim();
@@ -74653,7 +75048,7 @@ function getWslLocation(channel2) {
   }
   const windowsPath = getChromeWindowsLocation(channel2, wslPrefixes);
   return windowsPath.map((path2) => {
-    return execSync9(`wslpath "${path2}"`).toString().trim();
+    return execSync8(`wslpath "${path2}"`).toString().trim();
   });
 }
 function getChromeLinuxOrWslLocation(channel2) {
@@ -75740,7 +76135,7 @@ class Process {
     if (opts.onExit) {
       this.#onExitHook = opts.onExit;
     }
-    this.#browserProcessExiting = new Promise((resolve9, reject) => {
+    this.#browserProcessExiting = new Promise((resolve8, reject) => {
       this.#browserProcess.once("exit", async () => {
         debugLaunch(`Browser process ${this.#browserProcess.pid} onExit`);
         this.#clearListeners();
@@ -75751,7 +76146,7 @@ class Process {
           reject(err);
           return;
         }
-        resolve9();
+        resolve8();
       });
     });
   }
@@ -75861,7 +76256,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
     return [...this.#logs];
   }
   waitForLineOutput(regex, timeout2 = 0) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       const onClose = (errorOrCode) => {
         cleanup();
         reject(new Error([
@@ -75899,7 +76294,7 @@ Error cause: ${isErrorLike2(error) ? error.stack : error}`);
           return;
         }
         cleanup();
-        resolve9(match[1]);
+        resolve8(match[1]);
       }
     });
   }
@@ -76429,7 +76824,7 @@ var require_get_stream = __commonJS((exports, module) => {
     };
     const { maxBuffer } = options;
     let stream;
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve8, reject) => {
       const rejectPromise = (error) => {
         if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
           error.bufferedData = stream.getBufferedValue();
@@ -76441,7 +76836,7 @@ var require_get_stream = __commonJS((exports, module) => {
           rejectPromise(error);
           return;
         }
-        resolve9();
+        resolve8();
       });
       stream.on("data", () => {
         if (stream.getBufferedLength() > maxBuffer) {
@@ -77802,7 +78197,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((resolve8, reject) => {
         this.zipfile.on("error", (err) => {
           this.canceled = true;
           reject(err);
@@ -77811,7 +78206,7 @@ var require_extract_zip = __commonJS((exports, module) => {
         this.zipfile.on("close", () => {
           if (!this.canceled) {
             debug4("zip extraction complete");
-            resolve9();
+            resolve8();
           }
         });
         this.zipfile.on("entry", async (entry) => {
@@ -79153,8 +79548,8 @@ var require_streamx = __commonJS((exports, module) => {
           return this;
         },
         next() {
-          return new Promise(function(resolve9, reject) {
-            promiseResolve = resolve9;
+          return new Promise(function(resolve8, reject) {
+            promiseResolve = resolve8;
             promiseReject = reject;
             const data = stream.read();
             if (data !== null)
@@ -79191,14 +79586,14 @@ var require_streamx = __commonJS((exports, module) => {
       }
       function destroy(err) {
         stream.destroy(err);
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve8, reject) => {
           if (stream._duplexState & DESTROYED)
-            return resolve9({ value: undefined, done: true });
+            return resolve8({ value: undefined, done: true });
           stream.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve9({ value: undefined, done: true });
+              resolve8({ value: undefined, done: true });
           });
         });
       }
@@ -79250,8 +79645,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((resolve8) => {
+        state.drains.push({ writes, resolve: resolve8 });
       });
     }
     write(data) {
@@ -79365,11 +79760,11 @@ var require_streamx = __commonJS((exports, module) => {
     cb(null);
   }
   function pipelinePromise(...streams) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve8, reject) => {
       return pipeline(...streams, (err) => {
         if (err)
           return reject(err);
-        resolve9();
+        resolve8();
       });
     });
   }
@@ -80083,16 +80478,16 @@ var require_extract = __commonJS((exports, module) => {
         entryCallback = null;
         cb(err);
       }
-      function onnext(resolve9, reject) {
+      function onnext(resolve8, reject) {
         if (error) {
           return reject(error);
         }
         if (entryStream) {
-          resolve9({ value: entryStream, done: false });
+          resolve8({ value: entryStream, done: false });
           entryStream = null;
           return;
         }
-        promiseResolve = resolve9;
+        promiseResolve = resolve8;
         promiseReject = reject;
         consumeCallback(null);
         if (extract._finished && promiseResolve) {
@@ -80123,14 +80518,14 @@ var require_extract = __commonJS((exports, module) => {
       function destroy(err) {
         extract.destroy(err);
         consumeCallback(err);
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve8, reject) => {
           if (extract.destroyed)
-            return resolve9({ value: undefined, done: true });
+            return resolve8({ value: undefined, done: true });
           extract.once("close", function() {
             if (err)
               reject(err);
             else
-              resolve9({ value: undefined, done: true });
+              resolve8({ value: undefined, done: true });
           });
         });
       }
@@ -80928,7 +81323,7 @@ var init_fileUtil = __esm(() => {
 // node_modules/@puppeteer/browsers/lib/esm/install.js
 import assert2 from "assert";
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync35, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync26 } from "fs";
 import { mkdir as mkdir2, unlink } from "fs/promises";
 import os5 from "os";
 import path8 from "path";
@@ -80981,7 +81376,7 @@ async function installWithProviders(options) {
         continue;
       }
       debugInstall(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync35(browserRoot)) {
+      if (!existsSync33(browserRoot)) {
         await mkdir2(browserRoot, { recursive: true });
       }
       return await installUrl(url, options, provider);
@@ -81014,7 +81409,7 @@ async function installDeps(installedBrowser) {
     return;
   }
   const depsPath = path8.join(path8.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync35(depsPath)) {
+  if (!existsSync33(depsPath)) {
     debugInstall(`deb.deps file was not found at ${depsPath}`);
     return;
   }
@@ -81056,11 +81451,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 (!existsSync35(browserRoot)) {
+  if (!existsSync33(browserRoot)) {
     await mkdir2(browserRoot, { recursive: true });
   }
   if (!options.unpack) {
-    if (existsSync35(archivePath)) {
+    if (existsSync33(archivePath)) {
       return archivePath;
     }
     debugInstall(`Downloading binary from ${url}`);
@@ -81081,8 +81476,8 @@ async function installUrl(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
   }
   try {
-    if (existsSync35(outputPath)) {
-      if (!existsSync35(installedBrowser.executablePath)) {
+    if (existsSync33(outputPath)) {
+      if (!existsSync33(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup(installedBrowser);
@@ -81091,7 +81486,7 @@ async function installUrl(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync35(archivePath)) {
+    if (!existsSync33(archivePath)) {
       debugInstall(`Downloading binary from ${url}`);
       try {
         debugTime("download");
@@ -81120,7 +81515,7 @@ async function installUrl(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync35(archivePath)) {
+    if (existsSync33(archivePath)) {
       await unlink(archivePath);
     }
   }
@@ -81131,7 +81526,7 @@ async function runSetup(installedBrowser) {
       debugTime("permissions");
       const browserDir = path8.dirname(installedBrowser.executablePath);
       const setupExePath = path8.join(browserDir, "setup.exe");
-      if (!existsSync35(setupExePath)) {
+      if (!existsSync33(setupExePath)) {
         return;
       }
       spawnSync4(path8.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
@@ -81472,12 +81867,12 @@ var init_lib = __esm(() => {
 });
 
 // node_modules/cliui/build/lib/string-utils.js
-function stripAnsi(str) {
+function stripAnsi2(str) {
   return str.replace(ansi, "");
 }
 function wrap(str, width) {
   const [start, end] = str.match(ansi) || ["", ""];
-  str = stripAnsi(str);
+  str = stripAnsi2(str);
   let wrapped = "";
   for (let i = 0;i < str.length; i++) {
     if (i !== 0 && i % width === 0) {
@@ -81502,7 +81897,7 @@ function ui(opts) {
     stringWidth: (str) => {
       return [...str].length;
     },
-    stripAnsi,
+    stripAnsi: stripAnsi2,
     wrap
   });
 }
@@ -81512,19 +81907,19 @@ var init_cliui = __esm(() => {
 });
 
 // node_modules/escalade/sync/index.mjs
-import { dirname as dirname14, resolve as resolve10 } from "path";
+import { dirname as dirname13, resolve as resolve9 } from "path";
 import { readdirSync as readdirSync11, statSync as statSync12 } from "fs";
 function sync_default(start, callback) {
-  let dir = resolve10(".", start);
+  let dir = resolve9(".", start);
   let tmp, stats = statSync12(dir);
   if (!stats.isDirectory()) {
-    dir = dirname14(dir);
+    dir = dirname13(dir);
   }
   while (true) {
     tmp = callback(dir, readdirSync11(dir));
     if (tmp)
-      return resolve10(dir, tmp);
-    dir = dirname14(tmp = dir);
+      return resolve9(dir, tmp);
+    dir = dirname13(tmp = dir);
     if (tmp === dir)
       break;
   }
@@ -82470,7 +82865,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 resolve10 } 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;
@@ -82493,7 +82888,7 @@ var init_lib2 = __esm(() => {
     },
     format,
     normalize: normalize2,
-    resolve: resolve11,
+    resolve: resolve10,
     require: (path9) => {
       if (true) {
         return __require(path9);
@@ -82545,7 +82940,7 @@ var init_yerror = __esm(() => {
 // node_modules/y18n/build/lib/platform-shims/node.js
 import { readFileSync as readFileSync27, statSync as statSync13, writeFile } from "fs";
 import { format as format2 } from "util";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve11 } from "path";
 var node_default;
 var init_node = __esm(() => {
   node_default = {
@@ -82554,7 +82949,7 @@ var init_node = __esm(() => {
       writeFile
     },
     format: format2,
-    resolve: resolve12,
+    resolve: resolve11,
     exists: (file) => {
       try {
         return statSync13(file).isFile();
@@ -82737,7 +83132,7 @@ import { notStrictEqual, strictEqual } from "assert";
 import { inspect } from "util";
 import { readFileSync as readFileSync28 } from "fs";
 import { fileURLToPath } from "url";
-import { basename as basename8, dirname as dirname15, extname as extname3, relative as relative8, resolve as resolve13 } from "path";
+import { basename as basename8, dirname as dirname14, extname as extname3, relative as relative8, resolve as resolve12 } 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();
@@ -82770,10 +83165,10 @@ var init_esm = __esm(() => {
     Parser: lib_default,
     path: {
       basename: basename8,
-      dirname: dirname15,
+      dirname: dirname14,
       extname: extname3,
       relative: relative8,
-      resolve: resolve13
+      resolve: resolve12
     },
     process: {
       argv: () => process.argv,
@@ -82795,7 +83190,7 @@ var init_esm = __esm(() => {
       return [...str].length;
     },
     y18n: y18n_default({
-      directory: resolve13(__dirname2, "../../../locales"),
+      directory: resolve12(__dirname2, "../../../locales"),
       updateFiles: false
     })
   };
@@ -85043,12 +85438,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((resolve13, reject) => {
           __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
             if (err)
               reject(err);
             else
-              resolve14(completions);
+              resolve13(completions);
           });
         });
       } else {
@@ -86483,9 +86878,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: join32 } = await import("path");
+    const { join: join30 } = await import("path");
     const userDataDir = resolveDefaultUserDataDir3(Browser7.CHROME, platform2, convertPuppeteerChannelToBrowsersChannel2(options.channel));
-    const portPath = join32(userDataDir, "DevToolsActivePort");
+    const portPath = join30(userDataDir, "DevToolsActivePort");
     try {
       const fileContent = await environment.value.fs.promises.readFile(portPath, "ascii");
       const [rawPort, rawPath] = fileContent.split(`
@@ -86709,9 +87104,9 @@ var init_PipeTransport = __esm(() => {
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { tmpdir } from "os";
-import { join as join32 } from "path";
+import { join as join30 } from "path";
 
 class BrowserLauncher {
   #browser;
@@ -86736,7 +87131,7 @@ class BrowserLauncher {
       ...options,
       protocol
     });
-    if (!existsSync36(launchArgs.executablePath)) {
+    if (!existsSync34(launchArgs.executablePath)) {
       throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
     }
     const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
@@ -86811,7 +87206,7 @@ class BrowserLauncher {
       browserCloseCallback();
       const logs = browserProcess.getRecentLogs().join(`
 `);
-      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync36(join32(launchArgs.userDataDir, "lockfile"))) {
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync34(join30(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) {
@@ -86901,12 +87296,12 @@ class BrowserLauncher {
     });
   }
   getProfilePath() {
-    return join32(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+    return join30(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
   }
   resolveExecutablePath(headless, validatePath = true) {
     let executablePath = this.puppeteer.configuration.executablePath;
     if (executablePath) {
-      if (validatePath && !existsSync36(executablePath)) {
+      if (validatePath && !existsSync34(executablePath)) {
         throw new Error(`Tried to find the browser at the configured path (${executablePath}), but no executable was found.`);
       }
       return executablePath;
@@ -86929,7 +87324,7 @@ class BrowserLauncher {
       browser: browserType,
       buildId: this.puppeteer.browserVersion
     });
-    if (validatePath && !existsSync36(executablePath)) {
+    if (validatePath && !existsSync34(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.`);
@@ -87467,7 +87862,7 @@ var init_PuppeteerNode = __esm(() => {
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
 import fs5 from "fs";
 import os8 from "os";
-import { dirname as dirname16 } from "path";
+import { dirname as dirname15 } from "path";
 import { PassThrough } from "stream";
 var import_debug6, __runInitializers22 = function(thisArg, initializers, value) {
   var useValue = arguments.length > 2;
@@ -87541,8 +87936,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((resolve13) => {
+            this.#process.stdin.write(buffer, resolve13);
           });
           if (error) {
             console.log(`ffmpeg failed to write: ${error.message}.`);
@@ -87591,7 +87986,7 @@ var init_ScreenRecorder = __esm(() => {
           filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
         }
         if (path11) {
-          fs5.mkdirSync(dirname16(path11), { recursive: overwrite });
+          fs5.mkdirSync(dirname15(path11), { recursive: overwrite });
         }
         this.#process = spawn2(ffmpegPath, [
           ["-loglevel", "error"],
@@ -87697,8 +88092,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((resolve13) => {
+          this.#process.once("close", resolve13);
         });
       }
       async[(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
@@ -87744,17 +88139,17 @@ var init_puppeteer_core = __esm(() => {
 });
 
 // src/core/design-eval/capture.ts
-import { mkdirSync as mkdirSync16, statSync as statSync14, existsSync as existsSync37 } from "fs";
-import { join as join33 } from "path";
+import { mkdirSync as mkdirSync15, statSync as statSync14, existsSync as existsSync35 } from "fs";
+import { join as join31 } from "path";
 function findBrowser() {
   const platform2 = process.platform;
   const paths = CHROME_PATHS[platform2] ?? [];
   for (const p of paths) {
-    if (existsSync37(p))
+    if (existsSync35(p))
       return p;
   }
-  const minkBrowsers = join33(minkRoot(), "browsers");
-  if (existsSync37(minkBrowsers)) {
+  const minkBrowsers = join31(minkRoot(), "browsers");
+  if (existsSync35(minkBrowsers)) {
     const found = findChromeInDir(minkBrowsers);
     if (found)
       return found;
@@ -87775,7 +88170,7 @@ function findChromeInDir(dir) {
   try {
     const entries = readdirSync12(dir);
     for (const entry of entries) {
-      const full = join33(dir, entry);
+      const full = join31(dir, entry);
       try {
         const stat2 = statSync15(full);
         if (stat2.isDirectory()) {
@@ -87823,7 +88218,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 = join33(options.outputDir, fileName);
+    const filePath = join31(options.outputDir, fileName);
     await page.screenshot({
       path: filePath,
       type: "jpeg",
@@ -87855,7 +88250,7 @@ async function captureRoute(page, route, baseUrl, viewport, options) {
   return results;
 }
 async function captureAllRoutes(routes, baseUrl, viewports, options, outputDir) {
-  mkdirSync16(outputDir, { recursive: true });
+  mkdirSync15(outputDir, { recursive: true });
   const executablePath = findBrowser();
   const browser = await puppeteer_core_default.launch({
     executablePath,
@@ -89292,9 +89687,9 @@ var exports_wiki = {};
 __export(exports_wiki, {
   wiki: () => wiki
 });
-import { existsSync as existsSync38, statSync as statSync15 } from "fs";
-import { resolve as resolve14 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync36, statSync as statSync15 } from "fs";
+import { resolve as resolve13 } from "path";
+import { homedir as homedir4 } from "os";
 async function wiki(_cwd, args) {
   const sub = args[0];
   switch (sub) {
@@ -89350,7 +89745,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 = existsSync38(targetPath) && statSync15(targetPath).isDirectory();
+  const isExisting = existsSync36(targetPath) && statSync15(targetPath).isDirectory();
   setConfigValue("wiki.path", targetPath);
   ensureVaultStructure();
   seedTemplates(vaultTemplates());
@@ -89560,9 +89955,9 @@ function wikiLinks() {
 }
 function expandPath(raw) {
   if (raw.startsWith("~/")) {
-    return resolve14(homedir5(), raw.slice(2));
+    return resolve13(homedir4(), raw.slice(2));
   }
-  return resolve14(raw);
+  return resolve13(raw);
 }
 var init_wiki = __esm(() => {
   init_vault();
@@ -89578,8 +89973,8 @@ var exports_note = {};
 __export(exports_note, {
   note: () => note
 });
-import { resolve as resolve15 } from "path";
-import { existsSync as existsSync39, readFileSync as readFileSync29 } from "fs";
+import { resolve as resolve14 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync29 } from "fs";
 async function note(cwd, args) {
   if (!isWikiEnabled()) {
     console.error("[mink] wiki feature is disabled");
@@ -89609,8 +90004,8 @@ async function note(cwd, args) {
     return;
   }
   if (parsed.file) {
-    const sourcePath = resolve15(cwd, parsed.file);
-    if (!existsSync39(sourcePath)) {
+    const sourcePath = resolve14(cwd, parsed.file);
+    if (!existsSync37(sourcePath)) {
       console.error(`[mink] file not found: ${sourcePath}`);
       process.exit(1);
     }
@@ -89771,39 +90166,39 @@ var exports_skill = {};
 __export(exports_skill, {
   skill: () => skill
 });
-import { join as join34, resolve as resolve16, dirname as dirname17 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join32, resolve as resolve15, dirname as dirname16 } from "path";
+import { homedir as homedir5 } from "os";
 import {
-  existsSync as existsSync40,
-  mkdirSync as mkdirSync17,
-  copyFileSync as copyFileSync2,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync16,
+  copyFileSync,
   unlinkSync as unlinkSync6,
   readdirSync as readdirSync12,
-  rmSync as rmSync3,
+  rmSync as rmSync2,
   symlinkSync as symlinkSync2,
   lstatSync as lstatSync2
 } from "fs";
 function getSkillsSourceDir() {
-  let dir = dirname17(new URL(import.meta.url).pathname);
+  let dir = dirname16(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync40(join34(dir, "package.json")) && existsSync40(join34(dir, "skills"))) {
-      return join34(dir, "skills");
+    if (existsSync38(join32(dir, "package.json")) && existsSync38(join32(dir, "skills"))) {
+      return join32(dir, "skills");
     }
-    const parent = dirname17(dir);
+    const parent = dirname16(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve16(dirname17(new URL(import.meta.url).pathname), "../../skills");
+  return resolve15(dirname16(new URL(import.meta.url).pathname), "../../skills");
 }
 function getAvailableSkills() {
   const dir = getSkillsSourceDir();
-  if (!existsSync40(dir))
+  if (!existsSync38(dir))
     return [];
-  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync40(join34(dir, d.name, "SKILL.md"))).map((d) => d.name);
+  return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync38(join32(dir, d.name, "SKILL.md"))).map((d) => d.name);
 }
 function isInstalled(skillName) {
-  return existsSync40(join34(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
+  return existsSync38(join32(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
 }
 async function skill(args) {
   const sub = args[0];
@@ -89837,28 +90232,28 @@ function skillInstall(name) {
     console.error("  Expected skills at: " + sourceDir);
     return;
   }
-  mkdirSync17(AGENTS_SKILLS_DIR, { recursive: true });
+  mkdirSync16(AGENTS_SKILLS_DIR, { recursive: true });
   for (const skillName of skills) {
-    const srcDir = join34(sourceDir, skillName);
-    const srcFile = join34(srcDir, "SKILL.md");
-    const destDir = join34(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync40(srcFile)) {
+    const srcDir = join32(sourceDir, skillName);
+    const srcFile = join32(srcDir, "SKILL.md");
+    const destDir = join32(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync38(srcFile)) {
       console.error(`[mink] skill not found: ${skillName}`);
       continue;
     }
-    mkdirSync17(destDir, { recursive: true });
+    mkdirSync16(destDir, { recursive: true });
     copyDirRecursive2(srcDir, destDir);
-    mkdirSync17(CLAUDE_SKILLS_DIR, { recursive: true });
-    const symlink = join34(CLAUDE_SKILLS_DIR, skillName);
+    mkdirSync16(CLAUDE_SKILLS_DIR, { recursive: true });
+    const symlink = join32(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync40(symlink)) {
+      if (existsSync38(symlink)) {
         if (lstatSync2(symlink).isSymbolicLink() || lstatSync2(symlink).isFile()) {
           unlinkSync6(symlink);
         } else {
-          rmSync3(symlink, { recursive: true, force: true });
+          rmSync2(symlink, { recursive: true, force: true });
         }
       }
-      const relativeTarget = join34("..", "..", ".agents", "skills", skillName);
+      const relativeTarget = join32("..", "..", ".agents", "skills", skillName);
       symlinkSync2(relativeTarget, symlink);
     } catch {}
     console.log(`[mink] installed: ${skillName} -> ${destDir}`);
@@ -89869,15 +90264,15 @@ function skillInstall(name) {
 function skillUninstall(name) {
   const skills = name ? [name] : getAvailableSkills();
   for (const skillName of skills) {
-    const destDir = join34(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync40(destDir)) {
+    const destDir = join32(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync38(destDir)) {
       console.log(`[mink] not installed: ${skillName}`);
       continue;
     }
-    rmSync3(destDir, { recursive: true, force: true });
-    const symlink = join34(CLAUDE_SKILLS_DIR, skillName);
+    rmSync2(destDir, { recursive: true, force: true });
+    const symlink = join32(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync40(symlink))
+      if (existsSync38(symlink))
         unlinkSync6(symlink);
     } catch {}
     console.log(`[mink] uninstalled: ${skillName}`);
@@ -89892,7 +90287,7 @@ function skillList() {
   if (installed.length > 0) {
     console.log("  Installed:");
     for (const s of installed) {
-      console.log(`    ${s}  (${join34(AGENTS_SKILLS_DIR, s)})`);
+      console.log(`    ${s}  (${join32(AGENTS_SKILLS_DIR, s)})`);
     }
   }
   if (notInstalled.length > 0) {
@@ -89911,20 +90306,20 @@ function skillList() {
 function copyDirRecursive2(src, dest) {
   const entries = readdirSync12(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join34(src, entry.name);
-    const destPath = join34(dest, entry.name);
+    const srcPath = join32(src, entry.name);
+    const destPath = join32(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync17(destPath, { recursive: true });
+      mkdirSync16(destPath, { recursive: true });
       copyDirRecursive2(srcPath, destPath);
     } else {
-      copyFileSync2(srcPath, destPath);
+      copyFileSync(srcPath, destPath);
     }
   }
 }
 var AGENTS_SKILLS_DIR, CLAUDE_SKILLS_DIR;
 var init_skill = __esm(() => {
-  AGENTS_SKILLS_DIR = join34(homedir6(), ".agents", "skills");
-  CLAUDE_SKILLS_DIR = join34(homedir6(), ".claude", "skills");
+  AGENTS_SKILLS_DIR = join32(homedir5(), ".agents", "skills");
+  CLAUDE_SKILLS_DIR = join32(homedir5(), ".claude", "skills");
 });
 
 // src/commands/agent.ts
@@ -89932,41 +90327,41 @@ var exports_agent = {};
 __export(exports_agent, {
   agent: () => agent
 });
-import { join as join35, resolve as resolve17, dirname as dirname18 } from "path";
-import { homedir as homedir7 } from "os";
+import { join as join33, resolve as resolve16, dirname as dirname17 } from "path";
+import { homedir as homedir6 } from "os";
 import {
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync39,
+  mkdirSync as mkdirSync17,
   readFileSync as readFileSync30,
   writeFileSync as writeFileSync11
 } from "fs";
 import { createHash as createHash4 } from "crypto";
 import { spawnSync as spawnSync6 } from "child_process";
 function getAgentTemplatePath() {
-  let dir = dirname18(new URL(import.meta.url).pathname);
+  let dir = dirname17(new URL(import.meta.url).pathname);
   while (true) {
-    if (existsSync41(join35(dir, "package.json")) && existsSync41(join35(dir, "agents", TEMPLATE_FILE))) {
-      return join35(dir, "agents", TEMPLATE_FILE);
+    if (existsSync39(join33(dir, "package.json")) && existsSync39(join33(dir, "agents", TEMPLATE_FILE))) {
+      return join33(dir, "agents", TEMPLATE_FILE);
     }
-    const parent = dirname18(dir);
+    const parent = dirname17(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  return resolve17(dirname18(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
+  return resolve16(dirname17(new URL(import.meta.url).pathname), "../../agents", TEMPLATE_FILE);
 }
 function getMinkVersion() {
-  let dir = dirname18(new URL(import.meta.url).pathname);
+  let dir = dirname17(new URL(import.meta.url).pathname);
   while (true) {
-    const pkgPath = join35(dir, "package.json");
-    if (existsSync41(pkgPath)) {
+    const pkgPath = join33(dir, "package.json");
+    if (existsSync39(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync30(pkgPath, "utf-8"));
         if (pkg.name && pkg.version)
           return pkg.version;
       } catch {}
     }
-    const parent = dirname18(dir);
+    const parent = dirname17(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -89984,19 +90379,19 @@ function sha2562(text) {
   return createHash4("sha256").update(text).digest("hex");
 }
 function claudeAgentsDir() {
-  return join35(homedir7(), ".claude", "agents");
+  return join33(homedir6(), ".claude", "agents");
 }
 function installedAgentPath() {
-  return join35(claudeAgentsDir(), INSTALLED_FILE);
+  return join33(claudeAgentsDir(), INSTALLED_FILE);
 }
 function installAgentDefinition(opts) {
   const templatePath = getAgentTemplatePath();
-  if (!existsSync41(templatePath)) {
+  if (!existsSync39(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 && existsSync41(installed)) {
+  if (opts.skip && existsSync39(installed)) {
     return { action: "skipped", path: installed };
   }
   const template = readFileSync30(templatePath, "utf-8");
@@ -90005,14 +90400,14 @@ function installAgentDefinition(opts) {
     VAULT_PATH: resolveVaultPath(),
     MINK_VERSION: getMinkVersion()
   });
-  const exists = existsSync41(installed);
+  const exists = existsSync39(installed);
   if (!opts.force && exists) {
     const current = readFileSync30(installed, "utf-8");
     if (sha2562(current) === sha2562(rendered)) {
       return { action: "unchanged", path: installed };
     }
   }
-  mkdirSync18(claudeAgentsDir(), { recursive: true });
+  mkdirSync17(claudeAgentsDir(), { recursive: true });
   writeFileSync11(installed, rendered);
   return {
     action: exists ? "updated" : "installed",
@@ -90083,8 +90478,8 @@ async function agent(_cwd, rawArgs) {
   }
   const skipUpdate = args.noUpdate || process.env.MINK_AGENT_NO_UPDATE === "1";
   const root = minkRoot();
-  if (!existsSync41(root)) {
-    mkdirSync18(root, { recursive: true });
+  if (!existsSync39(root)) {
+    mkdirSync17(root, { recursive: true });
   }
   let result;
   try {
@@ -90135,13 +90530,13 @@ var init_agent = __esm(() => {
 });
 
 // src/core/sync-merge-drivers.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync3, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
-import { join as join36 } from "path";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync12, appendFileSync as appendFileSync2, copyFileSync as copyFileSync2, renameSync as renameSync4, unlinkSync as unlinkSync7 } from "fs";
+import { join as join34 } from "path";
 function logWarning(driver, args, err) {
   try {
     const line = `[${new Date().toISOString()}] ${driver} fallback for ${args.filePath}: ${err instanceof Error ? err.message : String(err)}
 `;
-    appendFileSync2(join36(minkRoot(), "sync-warnings.log"), line);
+    appendFileSync2(join34(minkRoot(), "sync-warnings.log"), line);
   } catch {}
 }
 function readJsonOrNull(path12) {
@@ -90376,7 +90771,7 @@ function mergeDbDriver(args) {
   const tmp = `${args.oursPath}.merge-${process.pid}-${Date.now()}.tmp`;
   let ours = null;
   try {
-    copyFileSync3(args.oursPath, tmp);
+    copyFileSync2(args.oursPath, tmp);
     ours = openDriver(tmp);
     ours.exec("PRAGMA journal_mode = WAL");
     ours.exec("PRAGMA foreign_keys = ON");
@@ -90892,22 +91287,8 @@ switch (command2) {
     sessionStop(sessionPath(cwd));
     break;
   case "init": {
-    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 });
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
+    await init2(cwd);
     break;
   }
   case "status": {
@@ -90937,6 +91318,11 @@ switch (command2) {
     await postRead2(cwd);
     break;
   }
+  case "post-tool": {
+    const { postTool: postTool2 } = await Promise.resolve().then(() => (init_post_tool(), exports_post_tool));
+    await postTool2(cwd);
+    break;
+  }
   case "pre-write": {
     const { preWrite: preWrite2 } = await Promise.resolve().then(() => (init_pre_write(), exports_pre_write));
     await preWrite2(cwd);
@@ -90952,6 +91338,11 @@ switch (command2) {
     detectWaste2(cwd);
     break;
   }
+  case "retrieve": {
+    const { retrieve: retrieve2 } = await Promise.resolve().then(() => (init_retrieve(), exports_retrieve));
+    retrieve2(cwd, process.argv.slice(3));
+    break;
+  }
   case "cron": {
     const { cron: cron2 } = await Promise.resolve().then(() => (init_cron(), exports_cron));
     await cron2(cwd, process.argv.slice(3));
@@ -91051,12 +91442,12 @@ switch (command2) {
   case "version":
   case "--version":
   case "-v": {
-    const { resolve: resolve18, dirname: dirname19, basename: basename9 } = await import("path");
+    const { resolve: resolve17, dirname: dirname18, basename: basename9 } = await import("path");
     const bundlePath = new URL(import.meta.url).pathname;
-    const cliPath = resolve18(dirname19(bundlePath));
+    const cliPath = resolve17(dirname18(bundlePath));
     const { readFileSync: readFileSync32 } = await import("fs");
     try {
-      const pkg = JSON.parse(readFileSync32(resolve18(cliPath, "../package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync32(resolve17(cliPath, "../package.json"), "utf-8"));
       console.log(`mink ${pkg.version}`);
     } catch {
       console.log("mink (unknown version)");
@@ -91079,8 +91470,7 @@ switch (command2) {
     console.log("Usage: mink <command> [options]");
     console.log();
     console.log("Commands:");
-    console.log("  init [--agent X] [--yes] Initialize Mink in the current project");
-    console.log("                          --agent claude|pi|all (default: detect & prompt)");
+    console.log("  init                    Initialize Mink in the current project");
     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");
@@ -91122,6 +91512,7 @@ switch (command2) {
     console.log("  restore [backup]        Restore state from a backup");
     console.log("  bug search <term>       Search the bug log");
     console.log("  detect-waste            Detect and flag wasteful patterns");
+    console.log("  retrieve <token>        Return a compressed tool output's original (spec 21)");
     console.log("  reflect                 Generate learning memory reflections");
     console.log("  designqc [target]       Capture design screenshots (spec 13)");
     console.log("  framework-advisor       Generate framework advisor knowledge file (spec 14)");
@@ -91131,6 +91522,7 @@ switch (command2) {
     console.log("  session-stop            Finalize session and log data");
     console.log("  pre-read / post-read    File read hooks");
     console.log("  pre-write / post-write  File write hooks");
+    console.log("  post-tool               Tool-output compression hook (Bash/Grep/MCP, spec 21)");
     break;
   default:
     console.error(`[mink] unknown command: ${command2 ?? "(none)"}`);