@drewpayment/mink 0.3.0 → 0.5.0

package/dist/cli.js

@@ -189,14 +189,19 @@ __export(exports_paths, {
   projectMetaPath: () => projectMetaPath,
   projectDir: () => projectDir,
   minkRoot: () => minkRoot,
+  localConfigPath: () => localConfigPath,
   learningMemoryPath: () => learningMemoryPath,
   globalConfigPath: () => globalConfigPath,
   frameworkAdvisorPath: () => frameworkAdvisorPath,
   frameworkAdvisorJsonPath: () => frameworkAdvisorJsonPath,
   fileIndexPath: () => fileIndexPath,
+  deviceRegistryPath: () => deviceRegistryPath,
+  deviceIdPath: () => deviceIdPath,
   designReportPath: () => designReportPath,
   designCapturesDir: () => designCapturesDir,
   configPath: () => configPath,
+  channelPidPath: () => channelPidPath,
+  channelLogPath: () => channelLogPath,
   bugMemoryPath: () => bugMemoryPath,
   backupDirPath: () => backupDirPath,
   actionLogPath: () => actionLogPath
@@ -243,9 +248,24 @@ function schedulerLogPath() {
 function schedulerManifestPath(cwd) {
   return join(projectDir(cwd), "scheduler-manifest.json");
 }
+function channelPidPath() {
+  return join(MINK_ROOT, "channel.pid");
+}
+function channelLogPath() {
+  return join(MINK_ROOT, "channel.log");
+}
 function globalConfigPath() {
   return join(MINK_ROOT, "config");
 }
+function localConfigPath() {
+  return join(MINK_ROOT, "config.local");
+}
+function deviceIdPath() {
+  return join(MINK_ROOT, "device-id");
+}
+function deviceRegistryPath() {
+  return join(MINK_ROOT, "devices.json");
+}
 function projectMetaPath(cwd) {
   return join(projectDir(cwd), "project-meta.json");
 }
@@ -560,96 +580,167 @@ var init_config = __esm(() => {
       key: "wiki.path",
       default: "~/.mink/wiki/",
       envVar: "MINK_WIKI_PATH",
-      description: "Wiki vault location"
+      description: "Wiki vault location",
+      scope: "local"
     },
     {
       key: "wiki.enabled",
       default: "true",
       envVar: "MINK_WIKI_ENABLED",
-      description: "Enable/disable the wiki feature"
+      description: "Enable/disable the wiki feature",
+      scope: "shared"
     },
     {
       key: "wiki.sync-mode",
       default: "immediate",
       envVar: "MINK_WIKI_SYNC_MODE",
-      description: "Sync mode: immediate or batched"
+      description: "Sync mode: immediate or batched",
+      scope: "shared"
     },
     {
       key: "wiki.git-backup",
       default: "false",
       envVar: "MINK_WIKI_GIT_BACKUP",
-      description: "Deprecated: use sync.enabled instead"
+      description: "Deprecated: use sync.enabled instead",
+      scope: "shared"
     },
     {
       key: "wiki.git-remote",
       default: "origin",
       envVar: "MINK_WIKI_GIT_REMOTE",
-      description: "Deprecated: use sync.remote-url instead"
+      description: "Deprecated: use sync.remote-url instead",
+      scope: "shared"
     },
     {
       key: "notes.default-category",
       default: "inbox",
       envVar: "MINK_NOTES_DEFAULT_CATEGORY",
-      description: "Default category for notes captured via CLI"
+      description: "Default category for notes captured via CLI",
+      scope: "shared"
     },
     {
       key: "sync.enabled",
       default: "false",
       envVar: "MINK_SYNC_ENABLED",
-      description: "Enable/disable automatic git sync of ~/.mink"
+      description: "Enable/disable automatic git sync of ~/.mink",
+      scope: "shared"
     },
     {
       key: "sync.remote-url",
       default: "",
       envVar: "MINK_SYNC_REMOTE_URL",
-      description: "Git remote URL for ~/.mink sync"
+      description: "Git remote URL for ~/.mink sync",
+      scope: "shared"
     },
     {
       key: "sync.last-push",
       default: "",
       envVar: "MINK_SYNC_LAST_PUSH",
-      description: "ISO timestamp of last successful sync push"
+      description: "ISO timestamp of last successful sync push",
+      scope: "local"
     },
     {
       key: "sync.last-pull",
       default: "",
       envVar: "MINK_SYNC_LAST_PULL",
-      description: "ISO timestamp of last successful sync pull"
+      description: "ISO timestamp of last successful sync pull",
+      scope: "local"
+    },
+    {
+      key: "channel.discord.bot-token",
+      default: "",
+      envVar: "MINK_CHANNEL_DISCORD_BOT_TOKEN",
+      description: "Discord bot token for Claude Code Channels",
+      scope: "local"
+    },
+    {
+      key: "channel.discord.enabled",
+      default: "false",
+      envVar: "MINK_CHANNEL_DISCORD_ENABLED",
+      description: "Auto-start Discord channel when daemon starts",
+      scope: "local"
+    },
+    {
+      key: "channel.default-platform",
+      default: "discord",
+      envVar: "MINK_CHANNEL_DEFAULT_PLATFORM",
+      description: "Default platform for mink channel start",
+      scope: "shared"
+    },
+    {
+      key: "channel.skip-permissions",
+      default: "true",
+      envVar: "MINK_CHANNEL_SKIP_PERMISSIONS",
+      description: "Pass --dangerously-skip-permissions so the channel can run without terminal prompts",
+      scope: "shared"
     }
   ];
   VALID_KEYS = new Set(CONFIG_KEYS.map((k) => k.key));
 });
 
 // src/core/global-config.ts
-function loadGlobalConfig() {
-  const raw = safeReadJson(globalConfigPath());
+var exports_global_config = {};
+__export(exports_global_config, {
+  setConfigValue: () => setConfigValue,
+  saveLocalConfig: () => saveLocalConfig,
+  saveGlobalConfig: () => saveGlobalConfig,
+  resolveConfigValue: () => resolveConfigValue,
+  resolveAllConfig: () => resolveAllConfig,
+  resetConfigKey: () => resetConfigKey,
+  resetAllConfig: () => resetAllConfig,
+  migrateConfigIfNeeded: () => migrateConfigIfNeeded,
+  loadLocalConfig: () => loadLocalConfig,
+  loadGlobalConfig: () => loadGlobalConfig
+});
+function loadConfigFile(path) {
+  const raw = safeReadJson(path);
   if (raw === null)
     return {};
   if (typeof raw !== "object" || Array.isArray(raw)) {
-    console.warn("[mink] warning: corrupt config file at " + globalConfigPath());
+    console.warn("[mink] warning: corrupt config file at " + path);
     return {};
   }
   return raw;
 }
+function loadGlobalConfig() {
+  return loadConfigFile(globalConfigPath());
+}
 function saveGlobalConfig(config) {
   atomicWriteJson(globalConfigPath(), config);
 }
+function loadLocalConfig() {
+  return loadConfigFile(localConfigPath());
+}
+function saveLocalConfig(config) {
+  atomicWriteJson(localConfigPath(), config);
+}
+function loadConfigForScope(scope) {
+  return scope === "local" ? loadLocalConfig() : loadGlobalConfig();
+}
+function saveConfigForScope(scope, config) {
+  if (scope === "local") {
+    saveLocalConfig(config);
+  } else {
+    saveGlobalConfig(config);
+  }
+}
 function resolveConfigValue(key) {
   const meta = getConfigKeyMeta(key);
-  const config = loadGlobalConfig();
+  const config = loadConfigForScope(meta.scope);
   const envValue = process.env[meta.envVar];
   const fileValue = config[key];
   if (envValue !== undefined && envValue !== "") {
     return {
       value: envValue,
       source: "environment variable",
+      scope: meta.scope,
       configFileValue: fileValue
     };
   }
   if (fileValue !== undefined) {
-    return { value: fileValue, source: "config file" };
+    return { value: fileValue, source: "config file", scope: meta.scope };
   }
-  return { value: meta.default, source: "default" };
+  return { value: meta.default, source: "default", scope: meta.scope };
 }
 function resolveAllConfig() {
   return CONFIG_KEYS.map((meta) => ({
@@ -658,18 +749,46 @@ function resolveAllConfig() {
   }));
 }
 function setConfigValue(key, value) {
-  const config = loadGlobalConfig();
+  const meta = getConfigKeyMeta(key);
+  const config = loadConfigForScope(meta.scope);
   config[key] = value;
-  saveGlobalConfig(config);
+  saveConfigForScope(meta.scope, config);
 }
 function resetConfigKey(key) {
-  const config = loadGlobalConfig();
+  const meta = getConfigKeyMeta(key);
+  const config = loadConfigForScope(meta.scope);
   delete config[key];
-  saveGlobalConfig(config);
+  saveConfigForScope(meta.scope, config);
 }
 function resetAllConfig() {
   saveGlobalConfig({});
+  saveLocalConfig({});
 }
+function migrateConfigIfNeeded() {
+  if (migrationRan)
+    return;
+  migrationRan = true;
+  const { existsSync } = __require("fs");
+  if (existsSync(localConfigPath()))
+    return;
+  const shared = loadGlobalConfig();
+  const localKeys = CONFIG_KEYS.filter((k) => k.scope === "local");
+  const localConfig = {};
+  let hasLocal = false;
+  for (const meta of localKeys) {
+    const val = shared[meta.key];
+    if (val !== undefined) {
+      localConfig[meta.key] = val;
+      delete shared[meta.key];
+      hasLocal = true;
+    }
+  }
+  if (hasLocal) {
+    saveLocalConfig(localConfig);
+    saveGlobalConfig(shared);
+  }
+}
+var migrationRan = false;
 var init_global_config = __esm(() => {
   init_paths();
   init_fs_utils();
@@ -1010,6 +1129,81 @@ var init_note_index = __esm(() => {
   ]);
 });
 
+// src/core/device.ts
+var exports_device = {};
+__export(exports_device, {
+  updateDeviceHeartbeat: () => updateDeviceHeartbeat,
+  setDeviceName: () => setDeviceName,
+  saveDeviceRegistry: () => saveDeviceRegistry,
+  loadDeviceRegistry: () => loadDeviceRegistry,
+  listDevices: () => listDevices,
+  getOrCreateDeviceId: () => getOrCreateDeviceId
+});
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+import { hostname, platform } from "os";
+import { randomUUID } from "crypto";
+function getOrCreateDeviceId() {
+  const idPath = deviceIdPath();
+  if (existsSync3(idPath)) {
+    return readFileSync4(idPath, "utf-8").trim();
+  }
+  const id = randomUUID();
+  mkdirSync3(dirname2(idPath), { recursive: true });
+  writeFileSync2(idPath, id + `
+`);
+  return id;
+}
+function loadDeviceRegistry() {
+  const raw = safeReadJson(deviceRegistryPath());
+  if (raw !== null && typeof raw === "object" && !Array.isArray(raw) && "devices" in raw) {
+    return raw;
+  }
+  return { devices: {} };
+}
+function saveDeviceRegistry(registry) {
+  atomicWriteJson(deviceRegistryPath(), registry);
+}
+function updateDeviceHeartbeat() {
+  const id = getOrCreateDeviceId();
+  const registry = loadDeviceRegistry();
+  const now = new Date().toISOString();
+  const existing = registry.devices[id];
+  registry.devices[id] = {
+    name: existing?.name ?? hostname(),
+    hostname: hostname(),
+    platform: platform(),
+    firstSeen: existing?.firstSeen ?? now,
+    lastSeen: now
+  };
+  saveDeviceRegistry(registry);
+}
+function listDevices() {
+  const registry = loadDeviceRegistry();
+  return Object.entries(registry.devices).map(([id, info]) => ({
+    id,
+    ...info
+  }));
+}
+function setDeviceName(name) {
+  const id = getOrCreateDeviceId();
+  const registry = loadDeviceRegistry();
+  const now = new Date().toISOString();
+  const existing = registry.devices[id];
+  registry.devices[id] = {
+    name,
+    hostname: hostname(),
+    platform: platform(),
+    firstSeen: existing?.firstSeen ?? now,
+    lastSeen: now
+  };
+  saveDeviceRegistry(registry);
+}
+var init_device = __esm(() => {
+  init_paths();
+  init_fs_utils();
+});
+
 // src/core/sync.ts
 var exports_sync = {};
 __export(exports_sync, {
@@ -1021,7 +1215,7 @@ __export(exports_sync, {
   ensureGitignore: () => ensureGitignore,
   disconnectSync: () => disconnectSync
 });
-import { existsSync as existsSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
 import { execSync } from "child_process";
 function git(args, timeoutMs = GIT_TIMEOUT) {
@@ -1042,15 +1236,15 @@ function isSyncInitialized() {
   const enabled = resolveConfigValue("sync.enabled").value;
   if (enabled !== "true")
     return false;
-  return existsSync3(join4(minkRoot(), ".git"));
+  return existsSync4(join4(minkRoot(), ".git"));
 }
 function ensureGitignore() {
   const gitignorePath = join4(minkRoot(), ".gitignore");
-  writeFileSync2(gitignorePath, GITIGNORE_CONTENTS);
+  writeFileSync3(gitignorePath, GITIGNORE_CONTENTS);
 }
 function getSyncStatus() {
   const enabled = resolveConfigValue("sync.enabled").value === "true";
-  const gitInitialized = existsSync3(join4(minkRoot(), ".git"));
+  const gitInitialized = existsSync4(join4(minkRoot(), ".git"));
   const remoteUrl = resolveConfigValue("sync.remote-url").value;
   const lastPush = resolveConfigValue("sync.last-push").value;
   const lastPull = resolveConfigValue("sync.last-pull").value;
@@ -1077,7 +1271,7 @@ function getSyncStatus() {
 function initSync(remoteUrl) {
   const root = minkRoot();
   const gitDir = join4(root, ".git");
-  if (existsSync3(gitDir)) {
+  if (existsSync4(gitDir)) {
     console.log("[mink] sync is already initialized in " + root);
     console.log("[mink] run 'mink sync disconnect' first to reinitialize");
     return;
@@ -1129,6 +1323,7 @@ function initSync(remoteUrl) {
 function syncPull(onMessage = (msg) => console.error(msg)) {
   if (!isSyncInitialized())
     return;
+  ensureGitignore();
   const root = minkRoot();
   try {
     const status = gitSafe("status --porcelain");
@@ -1140,7 +1335,7 @@ function syncPull(onMessage = (msg) => console.error(msg)) {
     try {
       git(`pull --rebase origin ${branch}`, FETCH_TIMEOUT);
     } catch (err) {
-      if (existsSync3(join4(root, ".git", "rebase-merge")) || existsSync3(join4(root, ".git", "rebase-apply"))) {
+      if (existsSync4(join4(root, ".git", "rebase-merge")) || existsSync4(join4(root, ".git", "rebase-apply"))) {
         gitSafe("rebase --abort");
         onMessage("[mink] sync pull: rebase conflict detected — aborted rebase, local state preserved");
         onMessage("[mink] resolve manually with 'mink sync pull' or 'cd ~/.mink && git pull --rebase origin main'");
@@ -1156,6 +1351,9 @@ function syncPull(onMessage = (msg) => console.error(msg)) {
       }
     }
     setConfigValue("sync.last-pull", new Date().toISOString());
+    try {
+      updateDeviceHeartbeat();
+    } catch {}
   } catch (err) {
     onMessage(`[mink] sync pull error: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1163,6 +1361,10 @@ function syncPull(onMessage = (msg) => console.error(msg)) {
 function syncPush(onMessage = (msg) => console.error(msg)) {
   if (!isSyncInitialized())
     return;
+  ensureGitignore();
+  try {
+    updateDeviceHeartbeat();
+  } catch {}
   const root = minkRoot();
   try {
     const status = gitSafe("status --porcelain");
@@ -1182,7 +1384,7 @@ function syncPush(onMessage = (msg) => console.error(msg)) {
     try {
       git(`pull --rebase origin ${branch}`, FETCH_TIMEOUT);
     } catch {
-      if (existsSync3(join4(root, ".git", "rebase-merge")) || existsSync3(join4(root, ".git", "rebase-apply"))) {
+      if (existsSync4(join4(root, ".git", "rebase-merge")) || existsSync4(join4(root, ".git", "rebase-apply"))) {
         gitSafe("rebase --abort");
         onMessage("[mink] sync: rebase conflict during push — local commit preserved, skipping push");
         onMessage("[mink] resolve manually with 'mink sync pull' then 'mink sync push'");
@@ -1202,7 +1404,7 @@ function syncPush(onMessage = (msg) => console.error(msg)) {
 function disconnectSync() {
   const root = minkRoot();
   const gitDir = join4(root, ".git");
-  if (!existsSync3(gitDir)) {
+  if (!existsSync4(gitDir)) {
     console.log("[mink] sync is not initialized — nothing to disconnect");
     return;
   }
@@ -1228,12 +1430,17 @@ var GIT_TIMEOUT = 5000, PUSH_TIMEOUT = 1e4, FETCH_TIMEOUT = 15000, GITIGNORE_CON
 scheduler.pid
 scheduler.log
 
+# Device identity and local config — machine-specific
+device-id
+config.local
+
 # Local backups — machine-specific snapshots
 projects/*/backups/
 `;
 var init_sync = __esm(() => {
   init_paths();
   init_global_config();
+  init_device();
 });
 
 // src/core/learning-memory.ts
@@ -1611,13 +1818,13 @@ var exports_reflect = {};
 __export(exports_reflect, {
   reflect: () => reflect
 });
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 function reflect(projectDir2, memoryPath, configPath2) {
-  if (!existsSync4(memoryPath)) {
+  if (!existsSync5(memoryPath)) {
     console.log("[mink] no learning memory found");
     return null;
   }
-  const markdown = readFileSync5(memoryPath, "utf-8");
+  const markdown = readFileSync6(memoryPath, "utf-8");
   const mem = parseLearningMemory(markdown);
   const config = safeReadJson(configPath2);
   const tokenBudget = config?.learningMemoryTokenBudget ?? DEFAULT_TOKEN_BUDGET;
@@ -1913,14 +2120,19 @@ __export(exports_paths2, {
   projectMetaPath: () => projectMetaPath2,
   projectDir: () => projectDir2,
   minkRoot: () => minkRoot2,
+  localConfigPath: () => localConfigPath2,
   learningMemoryPath: () => learningMemoryPath2,
   globalConfigPath: () => globalConfigPath2,
   frameworkAdvisorPath: () => frameworkAdvisorPath2,
   frameworkAdvisorJsonPath: () => frameworkAdvisorJsonPath2,
   fileIndexPath: () => fileIndexPath2,
+  deviceRegistryPath: () => deviceRegistryPath2,
+  deviceIdPath: () => deviceIdPath2,
   designReportPath: () => designReportPath2,
   designCapturesDir: () => designCapturesDir2,
   configPath: () => configPath2,
+  channelPidPath: () => channelPidPath2,
+  channelLogPath: () => channelLogPath2,
   bugMemoryPath: () => bugMemoryPath2,
   backupDirPath: () => backupDirPath2,
   actionLogPath: () => actionLogPath2
@@ -1967,9 +2179,24 @@ function schedulerLogPath2() {
 function schedulerManifestPath2(cwd) {
   return join7(projectDir2(cwd), "scheduler-manifest.json");
 }
+function channelPidPath2() {
+  return join7(MINK_ROOT2, "channel.pid");
+}
+function channelLogPath2() {
+  return join7(MINK_ROOT2, "channel.log");
+}
 function globalConfigPath2() {
   return join7(MINK_ROOT2, "config");
 }
+function localConfigPath2() {
+  return join7(MINK_ROOT2, "config.local");
+}
+function deviceIdPath2() {
+  return join7(MINK_ROOT2, "device-id");
+}
+function deviceRegistryPath2() {
+  return join7(MINK_ROOT2, "devices.json");
+}
 function projectMetaPath2(cwd) {
   return join7(projectDir2(cwd), "project-meta.json");
 }
@@ -2002,11 +2229,11 @@ __export(exports_backup, {
   createBackup: () => createBackup
 });
 import {
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync3,
-  existsSync as existsSync6,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync4,
+  existsSync as existsSync7,
   statSync as statSync3
 } from "fs";
 import { join as join8 } from "path";
@@ -2021,7 +2248,7 @@ function formatTimestamp(date) {
   return `${y}${mo}${d}-${h}${mi}${s}${ms}`;
 }
 function copyDirectoryFiles(srcDir, destDir, excludeDirs) {
-  mkdirSync4(destDir, { recursive: true });
+  mkdirSync5(destDir, { recursive: true });
   const entries = readdirSync2(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
@@ -2029,7 +2256,7 @@ function copyDirectoryFiles(srcDir, destDir, excludeDirs) {
         continue;
       copyDirectoryFiles(join8(srcDir, entry.name), join8(destDir, entry.name), excludeDirs);
     } else if (entry.isFile()) {
-      writeFileSync3(join8(destDir, entry.name), readFileSync7(join8(srcDir, entry.name)));
+      writeFileSync4(join8(destDir, entry.name), readFileSync8(join8(srcDir, entry.name)));
     }
   }
 }
@@ -2038,7 +2265,7 @@ function createBackup(cwd) {
   const dir = backupDirPath(cwd);
   let name = base;
   let suffix = 1;
-  while (existsSync6(join8(dir, name))) {
+  while (existsSync7(join8(dir, name))) {
     name = `${base}-${suffix}`;
     suffix++;
   }
@@ -2049,7 +2276,7 @@ function createBackup(cwd) {
 }
 function listBackups(cwd) {
   const dir = backupDirPath(cwd);
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
   const entries = readdirSync2(dir, { withFileTypes: true });
   const backups = [];
@@ -2080,7 +2307,7 @@ function listBackups(cwd) {
 }
 function restoreBackup(cwd, backupName) {
   const backupPath = join8(backupDirPath(cwd), backupName);
-  if (!existsSync6(backupPath)) {
+  if (!existsSync7(backupPath)) {
     throw new Error(`backup not found: ${backupName}`);
   }
   createBackup(cwd);
@@ -2450,7 +2677,7 @@ var exports_scan = {};
 __export(exports_scan, {
   scan: () => scan
 });
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { join as join10 } from "path";
 function loadExistingIndex(indexPath) {
   const raw = safeReadJson(indexPath);
@@ -2504,7 +2731,7 @@ function scan(cwd, options) {
     const fullPath = join10(cwd, file.relativePath);
     let content;
     try {
-      content = readFileSync8(fullPath, "utf-8");
+      content = readFileSync9(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -2540,12 +2767,12 @@ __export(exports_seed, {
   parseCargoToml: () => parseCargoToml
 });
 import { basename as basename4, join as join11 } from "path";
-import { readFileSync as readFileSync9, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync8 } from "fs";
 function readFile(filePath) {
-  if (!existsSync7(filePath))
+  if (!existsSync8(filePath))
     return null;
   try {
-    return readFileSync9(filePath, "utf-8");
+    return readFileSync10(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -2722,8 +2949,8 @@ __export(exports_init, {
   buildHooksConfig: () => buildHooksConfig
 });
 import { execSync as execSync2 } from "child_process";
-import { mkdirSync as mkdirSync5, existsSync as existsSync8 } from "fs";
-import { resolve as resolve2, dirname as dirname3, basename as basename5, join as join12 } from "path";
+import { mkdirSync as mkdirSync6, existsSync as existsSync9 } from "fs";
+import { resolve as resolve2, dirname as dirname4, basename as basename5, join as join12 } from "path";
 function detectRuntime() {
   try {
     execSync2("bun --version", { stdio: "ignore" });
@@ -2734,13 +2961,13 @@ function detectRuntime() {
 }
 function resolveCliPath() {
   const selfPath = new URL(import.meta.url).pathname;
-  const selfDir = dirname3(selfPath);
+  const selfDir = dirname4(selfPath);
   if (selfPath.endsWith("dist/cli.js")) {
     return selfPath;
   }
   const projectRoot = resolve2(selfDir, "../..");
   const distPath = join12(projectRoot, "dist", "cli.js");
-  if (existsSync8(distPath))
+  if (existsSync9(distPath))
     return distPath;
   return resolve2(selfDir, "../cli.ts");
 }
@@ -2776,7 +3003,7 @@ function isMinkHook(entry) {
   return false;
 }
 function mergeHooksIntoSettings(settingsPath, newHooks) {
-  mkdirSync5(dirname3(settingsPath), { recursive: true });
+  mkdirSync6(dirname4(settingsPath), { recursive: true });
   const existing = safeReadJson(settingsPath) ?? {};
   const existingHooks = existing.hooks ?? {};
   for (const [event, entries] of Object.entries(newHooks)) {
@@ -2789,9 +3016,9 @@ function mergeHooksIntoSettings(settingsPath, newHooks) {
 }
 function isExistingInstallation(cwd) {
   const dir = projectDir(cwd);
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     return false;
-  return existsSync8(join12(dir, "file-index.json"));
+  return existsSync9(join12(dir, "file-index.json"));
 }
 async function init(cwd) {
   const runtime = detectRuntime();
@@ -2807,7 +3034,7 @@ async function init(cwd) {
     console.log(`  backup: ${backupName}`);
   }
   mergeHooksIntoSettings(settingsPath, hooks);
-  mkdirSync5(dir, { recursive: true });
+  mkdirSync6(dir, { recursive: true });
   const projectId = generateProjectId(cwd);
   const isNotesProject = isWikiEnabled() && isVaultInitialized() && isInsideVault(cwd);
   const metaPath = projectMetaPath(cwd);
@@ -2835,7 +3062,7 @@ async function init(cwd) {
   scan2(cwd, { check: false });
   const { learningMemoryPath: learningMemoryPath3 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
   const memPath = learningMemoryPath3(cwd);
-  if (!existsSync8(memPath)) {
+  if (!existsSync9(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);
@@ -2845,7 +3072,7 @@ async function init(cwd) {
     try {
       const projectSlug = basename5(cwd);
       const overviewPath = join12(vaultProjects(projectSlug), "overview.md");
-      if (!existsSync8(overviewPath)) {
+      if (!existsSync9(overviewPath)) {
         const now = new Date().toISOString();
         const overview = [
           `---`,
@@ -2881,13 +3108,362 @@ var init_init = __esm(() => {
   init_vault();
 });
 
+// src/core/channel-templates.ts
+import { join as join13 } from "path";
+import { existsSync as existsSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync7 } from "fs";
+function writeCompanionClaudeMd(vaultPath, overwrite = false) {
+  mkdirSync7(vaultPath, { recursive: true });
+  const claudeMdPath = join13(vaultPath, "CLAUDE.md");
+  if (existsSync10(claudeMdPath) && !overwrite) {
+    return false;
+  }
+  writeFileSync5(claudeMdPath, COMPANION_CLAUDE_MD);
+  return true;
+}
+var COMPANION_CLAUDE_MD = `# Mink Knowledge Companion
+
+You are **Mink**, a personal knowledge companion. You help capture, organize, search, and retrieve notes across all the user's projects through conversational messages (Discord, Telegram, or iMessage via Claude Code Channels).
+
+Your home is this wiki vault — the directory you're running in. Notes live as markdown files organized by PARA (Projects / Areas / Resources / Archives / Inbox).
+
+## Your Role
+
+You are the **smart orchestrator**. The \`mink\` CLI is the dumb writer — it takes explicit flags and writes files. Your job:
+
+1. Understand what the user wants (capture, search, organize, summarize)
+2. Gather vault context when useful
+3. Call the right \`mink\` command with good flags
+4. Reply briefly — the user is likely on mobile
+
+## Conversational Style
+
+- **Brief.** One or two sentences. The user is in a chat app, not a terminal.
+- **Confirm what happened.** "Saved to \`projects/auth/blocker.md\` with tags \`compliance, blocker\`." — short, specific.
+- **Suggest, don't interrogate.** If you're unsure about a tag, pick a reasonable default and mention it. Don't ask 3 questions before saving a note.
+- **Surface related work.** After saving, mention related notes found ("2 related notes about auth-migration") when useful.
+
+## Capturing Notes
+
+When the user's message sounds like a note ("save this...", "log that...", or just describes something factual), **capture it**. Don't ask permission.
+
+### Flow
+
+1. **Read the message.** Extract: what's this about? Is it project-specific?
+2. **Gather context briefly.** Run these when needed (not every time):
+   - \`mink note list --recent 10\` — recent notes for continuity
+   - \`mink wiki status\` — vault overview
+   - Check \`.mink-index.json\` for existing tag vocabulary
+3. **Decide metadata:**
+   - **Title** — clear, descriptive (becomes the filename). Not the raw text.
+   - **Category** — one of:
+     - \`projects\` — has a deadline, milestone, or deliverable. Use \`--project <slug>\` if it maps to a known Mink project.
+     - \`areas\` — ongoing responsibility or recurring concern
+     - \`resources\` — reference material, how-to, guide
+     - \`archives\` — completed or historical
+     - \`inbox\` — genuinely unclear (user will sort later)
+   - **Tags** — 2–3 is usually right. **Prefer existing tags** from the vocabulary over inventing new ones. Lowercase, hyphenated.
+   - **Wikilinks** — wrap people, projects, and concepts in \`[[double-brackets]]\` inside the body when they match existing notes.
+4. **Call \`mink note\`** with the flags:
+   \`\`\`bash
+   mink note --title "Title" --body "Body with [[wikilinks]]" --category <cat> --tags "a,b,c"
+   # Add --project <slug> if project-linked
+   \`\`\`
+5. **Reply.** One line: where it landed, category, tags. Optionally: related notes.
+
+### Daily Notes
+
+If the user says "add to my daily" or "daily" or "today":
+\`\`\`bash
+mink note --daily "Content to append"
+\`\`\`
+
+### Meeting Notes
+
+If the user describes a meeting (attendees, topic, discussion):
+\`\`\`bash
+mink note --template meeting --title "Meeting: Topic" --body "..." --category areas --tags "meeting,..."
+\`\`\`
+
+## Searching and Retrieving
+
+When the user asks about past work — "what did I write about X?", "show me notes from last week", "find my notes on auth" — use:
+
+- \`mink note search <term>\` — full-text search (title, description, tags, path)
+- \`mink note list --recent N\` — recent notes
+- \`mink note list --category projects\` — filter by category
+- \`mink note list --tag auth\` — filter by tag
+
+**Return results briefly.** Top 3–5 matches with one-line summaries. If there are more, say so.
+
+Example reply:
+> Found 3 notes about auth-migration:
+> • \`projects/auth/compliance-blocker.md\` (today) — blocked on session token storage
+> • \`projects/auth/architecture.md\` (Apr 10) — middleware rewrite plan
+> • \`areas/daily/2026-04-12.md\` — standup update
+
+## Organization
+
+If the user says "move this to projects", "tag this with X", or "categorize my inbox":
+
+- For a single note: read it, rewrite it in the new category with \`mink note --file\` (ingestion). The CLI doesn't have a move command — you move by rewriting.
+- For inbox triage: list with \`mink note list --category inbox\`, propose categorization, execute on confirmation.
+
+## Daily Summaries
+
+If the user asks "what did I work on today?" or "give me a summary":
+
+1. Read today's daily note: \`mink note list --tag daily --recent 1\` → read the file
+2. Check recent notes: \`mink note list --recent 20\`
+3. Synthesize a short summary (3–5 bullets)
+
+## Cross-Project Awareness
+
+Notes may be linked to projects via \`source_project\` in frontmatter. To find notes for a specific project:
+\`\`\`bash
+mink note list --category projects
+mink note search <project-slug>
+\`\`\`
+
+Use wikilinks generously: \`[[project-name]]\`, \`[[person-name]]\`, \`[[concept]]\`. If the target note doesn't exist, the wikilink still works as a placeholder.
+
+## Session Kickoff
+
+At the start of a fresh conversation (first user message), it's fine to silently run:
+\`\`\`bash
+mink wiki status
+mink note list --recent 5
+\`\`\`
+
+Don't announce this. Just have the context.
+
+## What NOT to Do
+
+- Don't ask "what category should this be?" — pick one, move on.
+- Don't paste long output. Summarize.
+- Don't invent tags that exist with slight variations. Check vocabulary first.
+- Don't open files or directories unrelated to the vault. Stay focused on notes and wiki operations.
+- Don't edit source code in this vault — this is a knowledge repo, not a codebase.
+
+## CLI Reference (Cheat Sheet)
+
+\`\`\`bash
+# Capture
+mink note "quick thought"                                # inbox capture
+mink note --title T --body B --category areas --tags a,b
+mink note --daily "content"                              # daily note
+mink note --template meeting --title "..." --body "..."
+mink note --file ./external.md --category resources
+
+# Search / list
+mink note search <term>
+mink note list [--category X] [--tag Y] [--recent N]
+
+# Vault
+mink wiki status
+mink wiki rebuild-index
+\`\`\`
+`;
+var init_channel_templates = () => {};
+
+// src/core/channel-process.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8, existsSync as existsSync11 } from "fs";
+import { dirname as dirname5, join as join14 } from "path";
+import { spawnSync } from "child_process";
+function readChannelPidFile() {
+  try {
+    const raw = readFileSync11(channelPidPath(), "utf-8");
+    const data = JSON.parse(raw);
+    if (data && typeof data.session === "string" && typeof data.platform === "string" && typeof data.startedAt === "string" && typeof data.vaultPath === "string") {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeChannelPidFile(data) {
+  const pidPath = channelPidPath();
+  mkdirSync8(dirname5(pidPath), { recursive: true });
+  writeFileSync6(pidPath, JSON.stringify(data, null, 2));
+}
+function removeChannelPidFile() {
+  try {
+    unlinkSync2(channelPidPath());
+  } catch {}
+}
+function sessionName(platform2) {
+  return `${SESSION_PREFIX}${platform2}`;
+}
+function isScreenInstalled() {
+  const result = spawnSync("screen", ["-ls"], { stdio: "ignore" });
+  return !result.error;
+}
+function screenSessionExists(session) {
+  const result = spawnSync("screen", ["-ls", session], {
+    stdio: ["ignore", "pipe", "ignore"],
+    encoding: "utf-8"
+  });
+  const output = typeof result.stdout === "string" ? result.stdout : "";
+  return new RegExp(`\\d+\\.${session}\\b`).test(output);
+}
+function shellEscape(s) {
+  if (/^[a-zA-Z0-9_@%+=:,./\-]+$/.test(s))
+    return s;
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+async function startChannelProcess(opts) {
+  if (!isScreenInstalled()) {
+    throw new Error(`GNU screen is required but was not found on PATH.
+` + `macOS: screen is pre-installed — check your shell environment.
+` + "Linux: install with `sudo apt install screen` (or your package manager).");
+  }
+  const session = sessionName(opts.platform);
+  if (screenSessionExists(session)) {
+    writeChannelPidFile({
+      session,
+      platform: opts.platform,
+      startedAt: new Date().toISOString(),
+      vaultPath: opts.vaultPath
+    });
+    return { session, alreadyRunning: true };
+  }
+  const claudeCmd = opts.claudeCommand ?? "claude";
+  const pluginSpec = PLUGIN_SPECS[opts.platform];
+  const tokenEnvVar = TOKEN_ENV_VARS[opts.platform];
+  const claudeFlags = ["--channels", shellEscape(pluginSpec)];
+  if (opts.skipPermissions) {
+    claudeFlags.push("--dangerously-skip-permissions");
+  }
+  const parts = [];
+  parts.push(`cd ${shellEscape(opts.vaultPath)}`);
+  if (opts.token) {
+    parts.push(`export ${tokenEnvVar}=${shellEscape(opts.token)}`);
+  }
+  parts.push(`exec ${shellEscape(claudeCmd)} ${claudeFlags.join(" ")}`);
+  const innerCmd = parts.join("; ");
+  const result = spawnSync("screen", ["-T", "screen-256color", "-dmS", session, "bash", "-c", innerCmd], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+  if (result.status !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr : "";
+    throw new Error(`screen failed to create session (exit ${result.status}): ${stderr || "(no output)"}`);
+  }
+  await new Promise((r) => setTimeout(r, 700));
+  if (!screenSessionExists(session)) {
+    throw new Error("channel session died immediately after starting. " + "This usually means `claude` failed to launch. Check:\n" + "  • Is `claude` on your PATH? Run `which claude`.\n" + "  • Have you installed the plugin? Run `claude` then `/plugin install discord@claude-plugins-official`.\n" + `  • Try running the command manually to see the error:
+` + `    cd ${opts.vaultPath} && claude --channels ${pluginSpec}`);
+  }
+  writeChannelPidFile({
+    session,
+    platform: opts.platform,
+    startedAt: new Date().toISOString(),
+    vaultPath: opts.vaultPath
+  });
+  return { session, alreadyRunning: false };
+}
+async function stopChannelProcess() {
+  const pidData = readChannelPidFile();
+  if (!pidData) {
+    return "not-running";
+  }
+  if (!screenSessionExists(pidData.session)) {
+    removeChannelPidFile();
+    return "not-running";
+  }
+  spawnSync("screen", ["-S", pidData.session, "-X", "quit"], { stdio: "ignore" });
+  for (let i = 0;i < 30; i++) {
+    if (!screenSessionExists(pidData.session)) {
+      removeChannelPidFile();
+      return "stopped";
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  removeChannelPidFile();
+  return "stopped";
+}
+function isChannelRunning() {
+  const pidData = readChannelPidFile();
+  if (!pidData)
+    return false;
+  if (!screenSessionExists(pidData.session)) {
+    removeChannelPidFile();
+    return false;
+  }
+  return true;
+}
+function getChannelStatus() {
+  const pidData = readChannelPidFile();
+  if (!pidData)
+    return null;
+  if (!screenSessionExists(pidData.session)) {
+    removeChannelPidFile();
+    return null;
+  }
+  const startedMs = Date.parse(pidData.startedAt);
+  const uptimeSec = Number.isFinite(startedMs) ? Math.max(0, Math.floor((Date.now() - startedMs) / 1000)) : 0;
+  return {
+    session: pidData.session,
+    platform: pidData.platform,
+    startedAt: pidData.startedAt,
+    vaultPath: pidData.vaultPath,
+    uptime: uptimeSec
+  };
+}
+function getChannelLogs() {
+  const pidData = readChannelPidFile();
+  if (!pidData)
+    return null;
+  if (!screenSessionExists(pidData.session))
+    return null;
+  const tmpPath = join14(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 (existsSync11(tmpPath))
+      break;
+    const delayUntil = Date.now() + 50;
+    while (Date.now() < delayUntil) {}
+  }
+  try {
+    const content = readFileSync11(tmpPath, "utf-8");
+    try {
+      unlinkSync2(tmpPath);
+    } catch {}
+    return content;
+  } catch {
+    return null;
+  }
+}
+function attachChannel() {
+  const pidData = readChannelPidFile();
+  if (!pidData)
+    return "not-running";
+  if (!screenSessionExists(pidData.session)) {
+    removeChannelPidFile();
+    return "not-running";
+  }
+  spawnSync("screen", ["-r", pidData.session], { stdio: "inherit" });
+  return "attached";
+}
+var SESSION_PREFIX = "mink-channel-", PLUGIN_SPECS, TOKEN_ENV_VARS;
+var init_channel_process = __esm(() => {
+  init_paths();
+  PLUGIN_SPECS = {
+    discord: "plugin:discord@claude-plugins-official",
+    telegram: "plugin:telegram@claude-plugins-official"
+  };
+  TOKEN_ENV_VARS = {
+    discord: "DISCORD_BOT_TOKEN",
+    telegram: "TELEGRAM_BOT_TOKEN"
+  };
+});
+
 // src/core/daemon.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, openSync } from "fs";
-import { mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, openSync } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
+import { dirname as dirname6, resolve as resolve3 } from "path";
 function readPidFile() {
   try {
-    const raw = readFileSync10(schedulerPidPath(), "utf-8");
+    const raw = readFileSync12(schedulerPidPath(), "utf-8");
     const data = JSON.parse(raw);
     if (data && typeof data.pid === "number" && typeof data.startedAt === "string" && typeof data.projectCwd === "string") {
       return data;
@@ -2899,12 +3475,12 @@ function readPidFile() {
 }
 function writePidFile(data) {
   const pidPath = schedulerPidPath();
-  mkdirSync6(dirname4(pidPath), { recursive: true });
-  writeFileSync4(pidPath, JSON.stringify(data, null, 2));
+  mkdirSync9(dirname6(pidPath), { recursive: true });
+  writeFileSync7(pidPath, JSON.stringify(data, null, 2));
 }
 function removePidFile() {
   try {
-    unlinkSync2(schedulerPidPath());
+    unlinkSync3(schedulerPidPath());
   } catch {}
 }
 function isProcessAlive(pid) {
@@ -2924,10 +3500,10 @@ function startDaemon(cwd) {
   if (existing) {
     removePidFile();
   }
-  const __dir = dirname4(new URL(import.meta.url).pathname);
+  const __dir = dirname6(new URL(import.meta.url).pathname);
   const cliPath = resolve3(__dir, "../cli.ts");
   const logPath = schedulerLogPath();
-  mkdirSync6(dirname4(logPath), { recursive: true });
+  mkdirSync9(dirname6(logPath), { recursive: true });
   const logFd = openSync(logPath, "a");
   const proc = Bun.spawn(["bun", "run", cliPath, "cron", "__daemon"], {
     cwd,
@@ -2944,8 +3520,37 @@ function startDaemon(cwd) {
   });
   console.log(`[mink] scheduler started (PID: ${proc.pid})`);
   console.log(`[mink] log: ${logPath}`);
+  maybeStartChannel().catch((err) => {
+    console.error(`[mink] failed to start channel: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+async function maybeStartChannel() {
+  const enabled = resolveConfigValue("channel.discord.enabled").value === "true";
+  if (!enabled)
+    return;
+  if (!isVaultInitialized()) {
+    console.log("[mink] channel enabled but vault not initialized — skipping channel start");
+    return;
+  }
+  const token = resolveConfigValue("channel.discord.bot-token").value;
+  if (!token) {
+    console.log("[mink] channel enabled but no Discord bot token configured — skipping channel start");
+    return;
+  }
+  if (isChannelRunning()) {
+    return;
+  }
+  const platform2 = resolveConfigValue("channel.default-platform").value || "discord";
+  const skipPermissions = resolveConfigValue("channel.skip-permissions").value === "true";
+  const vaultPath = resolveVaultPath();
+  writeCompanionClaudeMd(vaultPath, false);
+  const result = await startChannelProcess({ vaultPath, platform: platform2, token, skipPermissions });
+  if (!result.alreadyRunning) {
+    console.log(`[mink] channel started (session: ${result.session}, platform: ${platform2})`);
+  }
 }
 async function stopDaemon() {
+  await stopChannelIfRunning();
   const pidData = readPidFile();
   if (!pidData) {
     console.log("[mink] scheduler is not running (no PID file)");
@@ -2972,24 +3577,38 @@ async function stopDaemon() {
   removePidFile();
   console.log("[mink] scheduler force-stopped (SIGKILL)");
 }
+async function stopChannelIfRunning() {
+  if (!isChannelRunning())
+    return;
+  const result = await stopChannelProcess();
+  if (result === "stopped") {
+    console.log("[mink] channel stopped");
+  }
+}
 function getDaemonStatus(cwd) {
+  const channel = getChannelStatus();
   const pidData = readPidFile();
   if (!pidData) {
-    return { running: false };
+    return { running: false, channel };
   }
   if (!isProcessAlive(pidData.pid)) {
     removePidFile();
-    return { running: false };
+    return { running: false, channel };
   }
   return {
     running: true,
     pid: pidData.pid,
     startedAt: pidData.startedAt,
-    projectCwd: pidData.projectCwd
+    projectCwd: pidData.projectCwd,
+    channel
   };
 }
 var init_daemon = __esm(() => {
   init_paths();
+  init_global_config();
+  init_vault();
+  init_channel_templates();
+  init_channel_process();
 });
 
 // src/commands/status.ts
@@ -2997,9 +3616,9 @@ var exports_status = {};
 __export(exports_status, {
   status: () => status
 });
-import { existsSync as existsSync10, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13, statSync as statSync5 } from "fs";
 function checkJsonFile(name, filePath, validator) {
-  if (!existsSync10(filePath))
+  if (!existsSync13(filePath))
     return { name, path: filePath, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -3009,10 +3628,10 @@ function checkJsonFile(name, filePath, validator) {
   return { name, path: filePath, status: "ok" };
 }
 function checkTextFile(name, filePath) {
-  if (!existsSync10(filePath))
+  if (!existsSync13(filePath))
     return { name, path: filePath, status: "missing" };
   try {
-    readFileSync11(filePath, "utf-8");
+    readFileSync13(filePath, "utf-8");
     return { name, path: filePath, status: "ok" };
   } catch {
     return { name, path: filePath, status: "corrupt" };
@@ -3072,8 +3691,8 @@ function status(cwd) {
   console.log();
   try {
     const memPath = learningMemoryPath(cwd);
-    if (existsSync10(memPath)) {
-      const content = readFileSync11(memPath, "utf-8");
+    if (existsSync13(memPath)) {
+      const content = readFileSync13(memPath, "utf-8");
       const mem = parseLearningMemory(content);
       const total = totalEntryCount(mem);
       const mtime = statSync5(memPath).mtime;
@@ -3127,8 +3746,8 @@ var exports_scan2 = {};
 __export(exports_scan2, {
   scan: () => scan2
 });
-import { readFileSync as readFileSync12 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import { join as join15 } from "path";
 function loadExistingIndex2(indexPath) {
   const raw = safeReadJson(indexPath);
   if (isFileIndex(raw))
@@ -3178,10 +3797,10 @@ function scan2(cwd, options) {
   newIndex.header.lifetimeHits = index.header.lifetimeHits;
   newIndex.header.lifetimeMisses = index.header.lifetimeMisses;
   for (const file of scanned) {
-    const fullPath = join13(cwd, file.relativePath);
+    const fullPath = join15(cwd, file.relativePath);
     let content;
     try {
-      content = readFileSync12(fullPath, "utf-8");
+      content = readFileSync14(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -3212,13 +3831,13 @@ var exports_reflect2 = {};
 __export(exports_reflect2, {
   reflect: () => reflect2
 });
-import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync15 } from "fs";
 function reflect2(projectDir3, memoryPath, configPath3) {
-  if (!existsSync11(memoryPath)) {
+  if (!existsSync14(memoryPath)) {
     console.log("[mink] no learning memory found");
     return null;
   }
-  const markdown = readFileSync13(memoryPath, "utf-8");
+  const markdown = readFileSync15(memoryPath, "utf-8");
   const mem = parseLearningMemory(markdown);
   const config = safeReadJson(configPath3);
   const tokenBudget = config?.learningMemoryTokenBudget ?? DEFAULT_TOKEN_BUDGET2;
@@ -3499,7 +4118,7 @@ __export(exports_pre_write, {
   analyzePreWrite: () => analyzePreWrite
 });
 import { relative as relative4 } from "path";
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 function analyzePreWrite(filePath, writeContent, doNotRepeatEntries, bugMemory) {
   const warnings = [];
   const allMatches = [];
@@ -3553,7 +4172,7 @@ async function preWrite(cwd) {
     const writeContent = extractWriteContent(input);
     let doNotRepeatEntries = [];
     try {
-      const markdown = readFileSync14(learningMemoryPath(cwd), "utf-8");
+      const markdown = readFileSync16(learningMemoryPath(cwd), "utf-8");
       const mem = parseLearningMemory(markdown);
       doNotRepeatEntries = getEntries(mem, "Do-Not-Repeat");
     } catch {}
@@ -3610,7 +4229,7 @@ __export(exports_post_write, {
   analyzePostWrite: () => analyzePostWrite
 });
 import { relative as relative5 } from "path";
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 function analyzePostWrite(filePath, fileContent, index) {
   if (isWriteExcluded(filePath)) {
     return {
@@ -3674,7 +4293,7 @@ async function postWrite(cwd) {
     const filePath = relative5(cwd, absolutePath);
     let fileContent = null;
     try {
-      fileContent = readFileSync15(absolutePath, "utf-8");
+      fileContent = readFileSync17(absolutePath, "utf-8");
     } catch {}
     const rawState = safeReadJson(sessionPath(cwd));
     const state = isSessionState(rawState) ? rawState : createSessionState();
@@ -4094,10 +4713,10 @@ async function executeTask(taskId, projectCwd) {
       if (task.actionType === "ai-cli") {
         try {
           const { learningMemoryPath: learningMemoryPath4 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
-          const { readFileSync: readFileSync16 } = await import("fs");
+          const { readFileSync: readFileSync18 } = await import("fs");
           let memoryContent;
           try {
-            memoryContent = readFileSync16(learningMemoryPath4(projectCwd), "utf-8");
+            memoryContent = readFileSync18(learningMemoryPath4(projectCwd), "utf-8");
           } catch {
             console.log("[mink] no learning memory found, skipping reflection");
             return;
@@ -4655,9 +5274,9 @@ var init_design_eval = __esm(() => {
 });
 
 // src/core/dashboard-api.ts
-import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync18 } from "fs";
 function checkJsonFile2(name, filePath, validator) {
-  if (!existsSync12(filePath))
+  if (!existsSync15(filePath))
     return { name, status: "missing" };
   const data = safeReadJson(filePath);
   if (data === null)
@@ -4667,10 +5286,10 @@ function checkJsonFile2(name, filePath, validator) {
   return { name, status: "ok" };
 }
 function checkTextFile2(name, filePath) {
-  if (!existsSync12(filePath))
+  if (!existsSync15(filePath))
     return { name, status: "missing" };
   try {
-    readFileSync16(filePath, "utf-8");
+    readFileSync18(filePath, "utf-8");
     return { name, status: "ok" };
   } catch {
     return { name, status: "corrupt" };
@@ -4753,7 +5372,7 @@ function loadSchedulerPanel(cwd) {
 }
 function loadLearningMemoryPanel(cwd) {
   const memPath = learningMemoryPath(cwd);
-  if (!existsSync12(memPath)) {
+  if (!existsSync15(memPath)) {
     return {
       projectName: "unknown",
       sections: {
@@ -4765,7 +5384,7 @@ function loadLearningMemoryPanel(cwd) {
     };
   }
   try {
-    const content = readFileSync16(memPath, "utf-8");
+    const content = readFileSync18(memPath, "utf-8");
     return parseLearningMemory(content);
   } catch {
     return {
@@ -4867,10 +5486,10 @@ var init_dashboard_api = __esm(() => {
 });
 
 // src/core/project-registry.ts
-import { readdirSync as readdirSync4, existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
+import { readdirSync as readdirSync4, existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
 function getProjectMeta(projDir) {
-  const metaPath = join14(projDir, "project-meta.json");
+  const metaPath = join16(projDir, "project-meta.json");
   const raw = safeReadJson(metaPath);
   if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
     return null;
@@ -4887,15 +5506,15 @@ function getProjectMeta(projDir) {
   };
 }
 function listRegisteredProjects() {
-  const projectsDir = join14(minkRoot(), "projects");
-  if (!existsSync13(projectsDir))
+  const projectsDir = join16(minkRoot(), "projects");
+  if (!existsSync16(projectsDir))
     return [];
   const entries = readdirSync4(projectsDir, { withFileTypes: true });
   const projects = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const projDir = join14(projectsDir, entry.name);
+    const projDir = join16(projectsDir, entry.name);
     const meta = getProjectMeta(projDir);
     if (meta) {
       projects.push({
@@ -5059,8 +5678,8 @@ __export(exports_dashboard_server, {
   startDashboardServer: () => startDashboardServer
 });
 import { watch } from "fs";
-import { existsSync as existsSync14 } from "fs";
-import { basename as basename7, dirname as dirname5, join as join15, extname as extname2 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { basename as basename7, dirname as dirname7, join as join17, extname as extname2 } from "path";
 
 class SSEManager {
   clients = new Map;
@@ -5213,7 +5832,7 @@ function extractPathParam(pathname, prefix) {
 }
 async function startDashboardServer(cwd, options = {}) {
   const port = options.port ?? 4040;
-  const hostname = options.hostname ?? "127.0.0.1";
+  const hostname2 = options.hostname ?? "127.0.0.1";
   const sseManager = new SSEManager;
   sseManager.start();
   let activeCwd = cwd;
@@ -5233,15 +5852,15 @@ async function startDashboardServer(cwd, options = {}) {
       timestamp: new Date().toISOString()
     });
   });
-  const __dir = dirname5(new URL(import.meta.url).pathname);
+  const __dir = dirname7(new URL(import.meta.url).pathname);
   let pkgRoot = __dir;
-  while (pkgRoot !== dirname5(pkgRoot)) {
-    if (existsSync14(join15(pkgRoot, "package.json")))
+  while (pkgRoot !== dirname7(pkgRoot)) {
+    if (existsSync17(join17(pkgRoot, "package.json")))
       break;
-    pkgRoot = dirname5(pkgRoot);
+    pkgRoot = dirname7(pkgRoot);
   }
-  const dashboardOutDir = join15(pkgRoot, "dashboard", "out");
-  const dashboardBuilt = existsSync14(join15(dashboardOutDir, "index.html"));
+  const dashboardOutDir = join17(pkgRoot, "dashboard", "out");
+  const dashboardBuilt = existsSync17(join17(dashboardOutDir, "index.html"));
   let clientIdCounter = 0;
   if (!dashboardBuilt) {
     console.warn("[mink] dashboard not built. Run: cd dashboard && bun run build");
@@ -5257,7 +5876,7 @@ async function startDashboardServer(cwd, options = {}) {
   }
   const server = await runtimeServe({
     port,
-    hostname,
+    hostname: hostname2,
     idleTimeout: 0,
     async fetch(req) {
       const url = new URL(req.url);
@@ -5271,9 +5890,9 @@ async function startDashboardServer(cwd, options = {}) {
         } else {
           let filePath;
           if (pathname === "/") {
-            filePath = join15(dashboardOutDir, "index.html");
+            filePath = join17(dashboardOutDir, "index.html");
           } else {
-            filePath = join15(dashboardOutDir, pathname);
+            filePath = join17(dashboardOutDir, pathname);
           }
           if (!filePath.startsWith(dashboardOutDir)) {
             return jsonResponse({ error: "Forbidden" }, 403);
@@ -5286,7 +5905,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(join15(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
+          const indexServed = await serveFile(join17(dashboardOutDir, "index.html"), "text/html; charset=utf-8");
           if (indexServed)
             return indexServed;
         }
@@ -5346,7 +5965,7 @@ retry: 3000
             if (!filename || filename.includes("..") || filename.includes("/")) {
               return jsonResponse({ error: "Invalid filename" }, 400);
             }
-            const imgPath = join15(designCapturesDir(resolvedCwd), filename);
+            const imgPath = join17(designCapturesDir(resolvedCwd), filename);
             const served = await serveFile(imgPath, "image/jpeg");
             if (served) {
               served.headers.set("Cache-Control", "public, max-age=60");
@@ -5420,11 +6039,11 @@ retry: 3000
       return jsonResponse({ error: "Not found" }, 404);
     }
   });
-  const serverUrl = `http://${hostname}:${server.port}`;
+  const serverUrl = `http://${hostname2}:${server.port}`;
   if (options.open !== false) {
     try {
-      const platform = process.platform;
-      const cmd = platform === "darwin" ? ["open", serverUrl] : platform === "win32" ? ["cmd", "/c", "start", serverUrl] : ["xdg-open", serverUrl];
+      const platform2 = process.platform;
+      const cmd = platform2 === "darwin" ? ["open", serverUrl] : platform2 === "win32" ? ["cmd", "/c", "start", serverUrl] : ["xdg-open", serverUrl];
       runtimeSpawn(cmd).unref();
     } catch {}
   }
@@ -5478,9 +6097,9 @@ var exports_dashboard = {};
 __export(exports_dashboard, {
   dashboard: () => dashboard
 });
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 async function dashboard(cwd, args) {
-  if (!existsSync15(projectDir(cwd))) {
+  if (!existsSync18(projectDir(cwd))) {
     console.error("[mink] project not initialized. Run: mink init");
     process.exit(1);
   }
@@ -5502,7 +6121,7 @@ var exports_daemon = {};
 __export(exports_daemon, {
   daemon: () => daemon
 });
-import { readFileSync as readFileSync17, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync19, existsSync as existsSync19 } from "fs";
 async function daemon(cwd, args) {
   const subcommand = args[0];
   switch (subcommand) {
@@ -5518,12 +6137,12 @@ async function daemon(cwd, args) {
       break;
     case "logs": {
       const logPath = schedulerLogPath();
-      if (!existsSync16(logPath)) {
+      if (!existsSync19(logPath)) {
         console.log("[mink] no log file found");
         return;
       }
       try {
-        const content = readFileSync17(logPath, "utf-8");
+        const content = readFileSync19(logPath, "utf-8");
         const lines = content.split(`
 `);
         const tail = lines.slice(-50).join(`
@@ -5545,6 +6164,232 @@ var init_daemon2 = __esm(() => {
   init_paths();
 });
 
+// src/commands/channel.ts
+var exports_channel = {};
+__export(exports_channel, {
+  channel: () => channel
+});
+function parsePlatform(value) {
+  if (!value)
+    return null;
+  if (SUPPORTED_PLATFORMS.includes(value)) {
+    return value;
+  }
+  return null;
+}
+function extractFlag(args, flag) {
+  const idx = args.findIndex((a) => a === flag || a.startsWith(flag + "="));
+  if (idx === -1)
+    return;
+  const arg = args[idx];
+  if (arg.includes("=")) {
+    return arg.slice(arg.indexOf("=") + 1);
+  }
+  return args[idx + 1];
+}
+async function channel(args) {
+  const subcommand = args[0];
+  const rest = args.slice(1);
+  switch (subcommand) {
+    case "setup":
+      setupChannel(rest);
+      break;
+    case "start":
+      await startChannel(rest);
+      break;
+    case "stop":
+      await stopChannel();
+      break;
+    case "status":
+      showStatus();
+      break;
+    case "logs":
+      showLogs();
+      break;
+    case "attach":
+      doAttach();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function setupChannel(args) {
+  const platform2 = parsePlatform(args[0]);
+  if (!platform2) {
+    console.error("[mink] missing or invalid platform");
+    console.error("Usage: mink channel setup <discord|telegram> --token <token>");
+    process.exit(1);
+  }
+  if (platform2 === "telegram") {
+    console.error("[mink] telegram setup is not yet supported");
+    process.exit(1);
+  }
+  const token = extractFlag(args, "--token");
+  if (!token) {
+    console.log("[mink] Discord Channel Setup");
+    console.log("");
+    console.log("In the Discord Developer Portal (https://discord.com/developers/applications):");
+    console.log("");
+    console.log("  1. New Application > give it a name");
+    console.log("  2. Bot > Reset Token > copy the token");
+    console.log("  3. Bot > scroll to Privileged Gateway Intents:");
+    console.log("     - Enable MESSAGE CONTENT INTENT (required)");
+    console.log("  4. OAuth2 > URL Generator:");
+    console.log("     - Integration Type: Guild Install (NOT User Install)");
+    console.log("     - Scopes: bot");
+    console.log("     - Bot Permissions: View Channels, Send Messages,");
+    console.log("       Send Messages in Threads, Read Message History,");
+    console.log("       Attach Files, Add Reactions");
+    console.log("  5. Open the generated URL to invite the bot to a server");
+    console.log("     (create a personal server if you just want to DM the bot)");
+    console.log("");
+    console.log("Then install the channel plugin once inside Claude Code:");
+    console.log("  claude");
+    console.log("  /plugin install discord@claude-plugins-official");
+    console.log("  (exit Claude Code)");
+    console.log("");
+    console.log("Finally, save your token:");
+    console.log("  mink channel setup discord --token <your-token>");
+    console.log("");
+    console.log("Your token is stored locally in ~/.mink/config.local");
+    console.log("and is NOT synced across machines.");
+    return;
+  }
+  if (!/^[\w.-]{30,}$/.test(token)) {
+    console.error("[mink] token format looks invalid — expected a long token string");
+    process.exit(1);
+  }
+  setConfigValue("channel.discord.bot-token", token);
+  setConfigValue("channel.discord.enabled", "true");
+  setConfigValue("channel.default-platform", "discord");
+  console.log("[mink] Discord bot token saved to config.local");
+  console.log("[mink] channel.discord.enabled = true");
+  console.log("[mink] channel.default-platform = discord");
+  console.log("");
+  console.log("Next: mink channel start");
+}
+async function startChannel(args) {
+  if (!isVaultInitialized()) {
+    console.error("[mink] wiki vault is not initialized");
+    console.error("Run: mink wiki init");
+    process.exit(1);
+  }
+  const requested = parsePlatform(args[0]);
+  const platform2 = requested ?? parsePlatform(resolveConfigValue("channel.default-platform").value) ?? "discord";
+  if (platform2 === "telegram") {
+    console.error("[mink] telegram is not yet supported");
+    process.exit(1);
+  }
+  const token = resolveConfigValue("channel.discord.bot-token").value;
+  if (!token) {
+    console.error("[mink] no Discord bot token configured");
+    console.error("Run: mink channel setup discord --token <your-token>");
+    process.exit(1);
+  }
+  const vaultPath = resolveVaultPath();
+  const wrote = writeCompanionClaudeMd(vaultPath, false);
+  if (wrote) {
+    console.log(`[mink] created companion CLAUDE.md at ${vaultPath}`);
+  }
+  const skipPermissions = resolveConfigValue("channel.skip-permissions").value === "true";
+  let result;
+  try {
+    result = await startChannelProcess({ vaultPath, platform: platform2, token, skipPermissions });
+  } catch (err) {
+    console.error("[mink] failed to start channel:");
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (result.alreadyRunning) {
+    console.log(`[mink] channel is already running (screen session: ${result.session})`);
+    return;
+  }
+  console.log(`[mink] channel started`);
+  console.log(`[mink] platform:  ${platform2}`);
+  console.log(`[mink] vault:     ${vaultPath}`);
+  console.log(`[mink] session:   ${result.session} (GNU screen)`);
+  console.log("");
+  console.log("Next:");
+  console.log("  1. DM your bot on Discord — it replies with a pairing code");
+  console.log("  2. Attach to the Claude Code session: mink channel attach");
+  console.log("  3. Inside the session, run: /discord:access pair <code>");
+  console.log("  4. Then lock down access:   /discord:access policy allowlist");
+  console.log("  5. Detach with Ctrl-a d");
+  console.log("");
+  console.log("See activity:  mink channel logs");
+}
+async function stopChannel() {
+  const result = await stopChannelProcess();
+  switch (result) {
+    case "not-running":
+      console.log("[mink] channel is not running");
+      break;
+    case "stopped":
+      console.log("[mink] channel stopped");
+      break;
+  }
+}
+function showStatus() {
+  const status2 = getChannelStatus();
+  if (!status2) {
+    console.log("[mink] channel is not running");
+    return;
+  }
+  console.log(`running:   yes`);
+  console.log(`session:   ${status2.session}`);
+  console.log(`platform:  ${status2.platform}`);
+  console.log(`vault:     ${status2.vaultPath}`);
+  console.log(`started:   ${status2.startedAt}`);
+  console.log(`uptime:    ${formatUptime(status2.uptime)}`);
+  console.log("");
+  console.log("Attach:    mink channel attach");
+}
+function formatUptime(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  const mins = Math.floor(seconds / 60);
+  if (mins < 60)
+    return `${mins}m ${seconds % 60}s`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs}h ${mins % 60}m`;
+}
+function showLogs() {
+  const content = getChannelLogs();
+  if (content == null) {
+    console.log("[mink] channel is not running (no logs to show)");
+    return;
+  }
+  console.log(content.replace(/\n+$/, ""));
+}
+function doAttach() {
+  const result = attachChannel();
+  if (result === "not-running") {
+    console.log("[mink] channel is not running");
+    console.log("Start it with: mink channel start");
+  }
+}
+function printUsage() {
+  console.error("Usage: mink channel <subcommand>");
+  console.error("");
+  console.error("Subcommands:");
+  console.error("  setup <platform> --token <token>   Configure a channel (discord|telegram)");
+  console.error("  start [platform]                   Launch channel session (in GNU screen)");
+  console.error("  stop                               Stop channel session");
+  console.error("  status                             Show channel status");
+  console.error("  logs                               Show recent channel output");
+  console.error("  attach                             Attach to the channel's Claude Code session");
+  console.error("                                     (detach with Ctrl-a then d)");
+}
+var SUPPORTED_PLATFORMS;
+var init_channel = __esm(() => {
+  init_global_config();
+  init_vault();
+  init_channel_templates();
+  init_channel_process();
+  SUPPORTED_PLATFORMS = ["discord", "telegram"];
+});
+
 // src/commands/config.ts
 var exports_config = {};
 __export(exports_config, {
@@ -5600,7 +6445,7 @@ async function config(args) {
     const all = resolveAllConfig();
     console.log("[mink] configuration:");
     for (const entry of all) {
-      let line2 = `  ${entry.key} = ${entry.value} (source: ${entry.source})`;
+      let line2 = `  ${entry.key} = ${entry.value} (${entry.scope}, source: ${entry.source})`;
       if (entry.source === "environment variable" && entry.configFileValue !== undefined) {
         line2 += ` [config file value: ${entry.configFileValue} — overridden]`;
       }
@@ -5635,8 +6480,8 @@ var init_config2 = __esm(() => {
 
 // src/commands/init.ts
 import { execSync as execSync3 } from "child_process";
-import { mkdirSync as mkdirSync7, existsSync as existsSync17 } from "fs";
-import { resolve as resolve4, dirname as dirname6, basename as basename8, join as join16 } from "path";
+import { mkdirSync as mkdirSync10, existsSync as existsSync20 } from "fs";
+import { resolve as resolve4, dirname as dirname8, basename as basename8, join as join18 } from "path";
 function detectRuntime2() {
   try {
     execSync3("bun --version", { stdio: "ignore" });
@@ -5677,7 +6522,7 @@ function isMinkHook2(entry) {
   return false;
 }
 function mergeHooksIntoSettings2(settingsPath, newHooks) {
-  mkdirSync7(dirname6(settingsPath), { recursive: true });
+  mkdirSync10(dirname8(settingsPath), { recursive: true });
   const existing = safeReadJson(settingsPath) ?? {};
   const existingHooks = existing.hooks ?? {};
   for (const [event, entries] of Object.entries(newHooks)) {
@@ -5700,7 +6545,7 @@ var exports_update = {};
 __export(exports_update, {
   update: () => update
 });
-import { resolve as resolve5, dirname as dirname7 } from "path";
+import { resolve as resolve5, dirname as dirname9 } from "path";
 function parseArgs(args) {
   let dryRun = false;
   let project = null;
@@ -5748,7 +6593,7 @@ async function update(cwd, args) {
     return;
   }
   const runtime = detectRuntime2();
-  const cliPath = resolve5(dirname7(new URL(import.meta.url).pathname), "../cli.ts");
+  const cliPath = resolve5(dirname9(new URL(import.meta.url).pathname), "../cli.ts");
   const newHooks = buildHooksConfig2(runtime, cliPath);
   for (const target of targets) {
     console.log(`[mink] updating: ${target.name} (${target.id})`);
@@ -5817,8 +6662,8 @@ var init_restore = __esm(() => {
 });
 
 // src/core/design-eval/server-detect.ts
-import { readFileSync as readFileSync18 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join19 } from "path";
 async function probePort(port) {
   try {
     const controller = new AbortController;
@@ -5840,7 +6685,7 @@ async function findRunningServer(ports = DEFAULT_PROBE_PORTS) {
 }
 function detectDevCommand(cwd) {
   try {
-    const raw = readFileSync18(join17(cwd, "package.json"), "utf-8");
+    const raw = readFileSync20(join19(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const scripts = pkg.scripts;
     if (!scripts || typeof scripts !== "object")
@@ -5860,10 +6705,10 @@ var init_server_detect = __esm(() => {
 });
 
 // src/core/design-eval/route-detect.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, statSync as statSync8 } from "fs";
-import { join as join18, relative as relative6, sep } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync5, statSync as statSync8 } from "fs";
+import { join as join20, relative as relative6, sep } from "path";
 function detectFramework(cwd) {
-  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync18(join18(cwd, `${name}.${ext}`))) || existsSync18(join18(cwd, name));
+  const has = (name) => ["js", "mjs", "ts", "cjs"].some((ext) => existsSync21(join20(cwd, `${name}.${ext}`))) || existsSync21(join20(cwd, name));
   if (has("next.config"))
     return "nextjs";
   if (has("svelte.config"))
@@ -5888,8 +6733,8 @@ function detectRoutes(cwd) {
 }
 function detectNextRoutes(cwd) {
   const routes = [];
-  const appDir = join18(cwd, "app");
-  if (existsSync18(appDir)) {
+  const appDir = join20(cwd, "app");
+  if (existsSync21(appDir)) {
     const pageFiles = findFiles(appDir, /^page\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative6(appDir, file);
@@ -5900,8 +6745,8 @@ function detectNextRoutes(cwd) {
       routes.push(route);
     }
   }
-  const pagesDir = join18(cwd, "pages");
-  if (existsSync18(pagesDir)) {
+  const pagesDir = join20(cwd, "pages");
+  if (existsSync21(pagesDir)) {
     const pageFiles = findFiles(pagesDir, /\.(tsx?|jsx?)$/);
     for (const file of pageFiles) {
       const rel = relative6(pagesDir, file);
@@ -5920,8 +6765,8 @@ function detectNextRoutes(cwd) {
   return unique.length > 0 ? unique.sort() : ["/"];
 }
 function detectSvelteKitRoutes(cwd) {
-  const routesDir = join18(cwd, "src", "routes");
-  if (!existsSync18(routesDir))
+  const routesDir = join20(cwd, "src", "routes");
+  if (!existsSync21(routesDir))
     return ["/"];
   const routes = [];
   const pageFiles = findFiles(routesDir, /^\+page\.svelte$/);
@@ -5936,8 +6781,8 @@ function detectSvelteKitRoutes(cwd) {
   return routes.length > 0 ? routes.sort() : ["/"];
 }
 function detectNuxtRoutes(cwd) {
-  const pagesDir = join18(cwd, "pages");
-  if (!existsSync18(pagesDir))
+  const pagesDir = join20(cwd, "pages");
+  if (!existsSync21(pagesDir))
     return ["/"];
   const routes = [];
   const vueFiles = findFiles(pagesDir, /\.vue$/);
@@ -5963,7 +6808,7 @@ function findFiles(dir, pattern) {
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
-      const full = join18(current, entry);
+      const full = join20(current, entry);
       try {
         const stat2 = statSync8(full);
         if (stat2.isDirectory()) {
@@ -18868,10 +19713,10 @@ var init_NetworkManager = __esm(() => {
         throw error;
       }
     }
-    async setUserAgent(userAgent, userAgentMetadata, platform) {
+    async setUserAgent(userAgent, userAgentMetadata, platform2) {
       this.#userAgent = userAgent;
       this.#userAgentMetadata = userAgentMetadata;
-      this.#platform = platform;
+      this.#platform = platform2;
       await this.#applyToAllClients(this.#applyUserAgent.bind(this));
     }
     async#applyUserAgent(client) {
@@ -28613,8 +29458,8 @@ var require_ChannelProxy = __commonJS((exports) => {
     #properties;
     #id = (0, uuid_js_1.uuidv4)();
     #logger;
-    constructor(channel, logger) {
-      this.#properties = channel;
+    constructor(channel2, logger) {
+      this.#properties = channel2;
       this.#logger = logger;
     }
     async init(realm, eventManager) {
@@ -31307,7 +32152,7 @@ var require_BrowsingContextImpl = __commonJS((exports) => {
         const realm = new WindowRealm_js_1.WindowRealm(this.id, this.#browsingContextStorage, this.#cdpTarget.cdpClient, this.#eventManager, id, this.#logger, origin, uniqueId, this.#realmStorage, sandbox);
         if (auxData.isDefault) {
           this.#defaultRealmDeferred.resolve(realm);
-          Promise.all(this.#cdpTarget.getChannels().map((channel) => channel.startListenerFromWindow(realm, this.#eventManager)));
+          Promise.all(this.#cdpTarget.getChannels().map((channel2) => channel2.startListenerFromWindow(realm, this.#eventManager)));
         }
       });
       this.#cdpTarget.cdpClient.on("Runtime.executionContextDestroyed", (params) => {
@@ -37889,7 +38734,7 @@ var init_ExposedFunction = __esm(() => {
     }
     async#initialize() {
       const connection = this.#connection;
-      const channel = {
+      const channel2 = {
         type: "channel",
         value: {
           channel: this.#channel,
@@ -37916,11 +38761,11 @@ var init_ExposedFunction = __esm(() => {
         try {
           const [script] = await Promise.all([
             frame.browsingContext.addPreloadScript(functionDeclaration, {
-              arguments: [channel],
+              arguments: [channel2],
               sandbox: realm.sandbox
             }),
             realm.realm.callFunction(functionDeclaration, false, {
-              arguments: [channel]
+              arguments: [channel2]
             })
           ]);
           this.#scripts.push([frame, script]);
@@ -40383,22 +41228,22 @@ var init_Page3 = __esm(() => {
       async setUserAgent(userAgentOrOptions, userAgentMetadata) {
         let userAgent;
         let clientHints;
-        let platform;
+        let platform2;
         if (typeof userAgentOrOptions === "string") {
           userAgent = userAgentOrOptions;
           clientHints = userAgentMetadata;
         } else {
           userAgent = userAgentOrOptions.userAgent ?? null;
           clientHints = userAgentOrOptions.userAgentMetadata;
-          platform = userAgentOrOptions.platform === "" ? undefined : userAgentOrOptions.platform;
+          platform2 = userAgentOrOptions.platform === "" ? undefined : userAgentOrOptions.platform;
         }
         if (userAgent === "") {
           userAgent = null;
         }
         await this.#frame.browsingContext.setUserAgent(userAgent);
-        if (platform && platform !== "") {
+        if (platform2 && platform2 !== "") {
           clientHints = clientHints ?? {};
-          clientHints.platform = platform;
+          clientHints.platform = platform2;
         }
         await this.#frame.browsingContext.setClientHintsOverride(clientHints ?? null);
       }
@@ -48364,15 +49209,15 @@ var require_proxy_from_env = __commonJS((exports) => {
   function getProxyForUrl(url) {
     var parsedUrl = typeof url === "string" ? parseUrl(url) : url || {};
     var proto = parsedUrl.protocol;
-    var hostname = parsedUrl.host;
+    var hostname2 = parsedUrl.host;
     var port = parsedUrl.port;
-    if (typeof hostname !== "string" || !hostname || typeof proto !== "string") {
+    if (typeof hostname2 !== "string" || !hostname2 || typeof proto !== "string") {
       return "";
     }
     proto = proto.split(":", 1)[0];
-    hostname = hostname.replace(/:\d*$/, "");
+    hostname2 = hostname2.replace(/:\d*$/, "");
     port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
-    if (!shouldProxy(hostname, port)) {
+    if (!shouldProxy(hostname2, port)) {
       return "";
     }
     var proxy = getEnv("npm_config_" + proto + "_proxy") || getEnv(proto + "_proxy") || getEnv("npm_config_proxy") || getEnv("all_proxy");
@@ -48381,7 +49226,7 @@ var require_proxy_from_env = __commonJS((exports) => {
     }
     return proxy;
   }
-  function shouldProxy(hostname, port) {
+  function shouldProxy(hostname2, port) {
     var NO_PROXY = (getEnv("npm_config_no_proxy") || getEnv("no_proxy")).toLowerCase();
     if (!NO_PROXY) {
       return true;
@@ -48400,12 +49245,12 @@ var require_proxy_from_env = __commonJS((exports) => {
         return true;
       }
       if (!/^[.*]/.test(parsedProxyHostname)) {
-        return hostname !== parsedProxyHostname;
+        return hostname2 !== parsedProxyHostname;
       }
       if (parsedProxyHostname.charAt(0) === "*") {
         parsedProxyHostname = parsedProxyHostname.slice(1);
       }
-      return !stringEndsWith.call(hostname, parsedProxyHostname);
+      return !stringEndsWith.call(hostname2, parsedProxyHostname);
     });
   }
   function getEnv(key) {
@@ -48483,8 +49328,8 @@ var require_dist2 = __commonJS((exports) => {
     setRequestProps(req, opts) {
       const { proxy } = this;
       const protocol = opts.secureEndpoint ? "https:" : "http:";
-      const hostname = req.getHeader("host") || "localhost";
-      const base = `${protocol}//${hostname}`;
+      const hostname2 = req.getHeader("host") || "localhost";
+      const base = `${protocol}//${hostname2}`;
       const url = new url_1.URL(req.path, base);
       if (opts.port !== 80) {
         url.port = String(opts.port);
@@ -54667,7 +55512,7 @@ var require_util2 = __commonJS((exports) => {
     return path;
   }
   exports.normalize = normalize;
-  function join19(aRoot, aPath) {
+  function join21(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -54699,7 +55544,7 @@ var require_util2 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join19;
+  exports.join = join21;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -54872,7 +55717,7 @@ var require_util2 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join19(urlGenerate(parsed), sourceURL);
+      sourceURL = join21(urlGenerate(parsed), sourceURL);
     }
     return normalize(sourceURL);
   }
@@ -56604,7 +57449,7 @@ var require_escodegen = __commonJS((exports) => {
     function noEmptySpace() {
       return space ? space : " ";
     }
-    function join19(left, right) {
+    function join21(left, right) {
       var leftSource, rightSource, leftCharCode, rightCharCode;
       leftSource = toSourceNodeWhenNeeded(left).toString();
       if (leftSource.length === 0) {
@@ -56945,8 +57790,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
         }
-        result = join19(result, operator);
-        result = [join19(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
+        result = join21(result, operator);
+        result = [join21(result, that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)), ")"];
       });
       result.push(this.maybeBlock(stmt.body, flags));
       return result;
@@ -57084,11 +57929,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (stmt.id) {
-          result = join19(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+          result = join21(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
         }
         if (stmt.superClass) {
-          fragment = join19("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-          result = join19(result, fragment);
+          fragment = join21("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+          result = join21(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -57101,9 +57946,9 @@ var require_escodegen = __commonJS((exports) => {
         return escapeDirective(stmt.directive) + this.semicolon(flags);
       },
       DoWhileStatement: function(stmt, flags) {
-        var result = join19("do", this.maybeBlock(stmt.body, S_TFFF));
+        var result = join21("do", this.maybeBlock(stmt.body, S_TFFF));
         result = this.maybeBlockSuffix(stmt.body, result);
-        return join19(result, [
+        return join21(result, [
           "while" + space + "(",
           this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
           ")" + this.semicolon(flags)
@@ -57139,11 +57984,11 @@ var require_escodegen = __commonJS((exports) => {
       ExportDefaultDeclaration: function(stmt, flags) {
         var result = ["export"], bodyFlags;
         bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-        result = join19(result, "default");
+        result = join21(result, "default");
         if (isStatement(stmt.declaration)) {
-          result = join19(result, this.generateStatement(stmt.declaration, bodyFlags));
+          result = join21(result, this.generateStatement(stmt.declaration, bodyFlags));
         } else {
-          result = join19(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+          result = join21(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
         }
         return result;
       },
@@ -57151,15 +57996,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 join19(result, this.generateStatement(stmt.declaration, bodyFlags));
+          return join21(result, this.generateStatement(stmt.declaration, bodyFlags));
         }
         if (stmt.specifiers) {
           if (stmt.specifiers.length === 0) {
-            result = join19(result, "{" + space + "}");
+            result = join21(result, "{" + space + "}");
           } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-            result = join19(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+            result = join21(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
           } else {
-            result = join19(result, "{");
+            result = join21(result, "{");
             withIndent(function(indent2) {
               var i, iz;
               result.push(newline);
@@ -57177,7 +58022,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(base + "}");
           }
           if (stmt.source) {
-            result = join19(result, [
+            result = join21(result, [
               "from" + space,
               this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
               this.semicolon(flags)
@@ -57261,7 +58106,7 @@ var require_escodegen = __commonJS((exports) => {
         ];
         cursor = 0;
         if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-          result = join19(result, [
+          result = join21(result, [
             this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
           ]);
           ++cursor;
@@ -57271,7 +58116,7 @@ var require_escodegen = __commonJS((exports) => {
             result.push(",");
           }
           if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-            result = join19(result, [
+            result = join21(result, [
               space,
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
@@ -57300,7 +58145,7 @@ var require_escodegen = __commonJS((exports) => {
             }
           }
         }
-        result = join19(result, [
+        result = join21(result, [
           "from" + space,
           this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
           this.semicolon(flags)
@@ -57354,7 +58199,7 @@ var require_escodegen = __commonJS((exports) => {
         return result;
       },
       ThrowStatement: function(stmt, flags) {
-        return [join19("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+        return [join21("throw", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
       },
       TryStatement: function(stmt, flags) {
         var result, i, iz, guardedHandlers;
@@ -57362,7 +58207,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 = join19(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+            result = join21(result, this.generateStatement(stmt.handlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
             }
@@ -57370,7 +58215,7 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           guardedHandlers = stmt.guardedHandlers || [];
           for (i = 0, iz = guardedHandlers.length;i < iz; ++i) {
-            result = join19(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+            result = join21(result, this.generateStatement(guardedHandlers[i], S_TFFF));
             if (stmt.finalizer || i + 1 !== iz) {
               result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
             }
@@ -57378,13 +58223,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 = join19(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                result = join21(result, this.generateStatement(stmt.handler[i], S_TFFF));
                 if (stmt.finalizer || i + 1 !== iz) {
                   result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                 }
               }
             } else {
-              result = join19(result, this.generateStatement(stmt.handler, S_TFFF));
+              result = join21(result, this.generateStatement(stmt.handler, S_TFFF));
               if (stmt.finalizer) {
                 result = this.maybeBlockSuffix(stmt.handler.body, result);
               }
@@ -57392,7 +58237,7 @@ var require_escodegen = __commonJS((exports) => {
           }
         }
         if (stmt.finalizer) {
-          result = join19(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+          result = join21(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
         }
         return result;
       },
@@ -57426,7 +58271,7 @@ var require_escodegen = __commonJS((exports) => {
         withIndent(function() {
           if (stmt.test) {
             result = [
-              join19("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+              join21("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
               ":"
             ];
           } else {
@@ -57474,9 +58319,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 = join19(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+            result = join21(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
           } else {
-            result = join19(result, join19("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+            result = join21(result, join21("else", this.maybeBlock(stmt.alternate, bodyFlags)));
           }
         } else {
           result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -57578,7 +58423,7 @@ var require_escodegen = __commonJS((exports) => {
       },
       ReturnStatement: function(stmt, flags) {
         if (stmt.argument) {
-          return [join19("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
+          return [join21("return", this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)), this.semicolon(flags)];
         }
         return ["return" + this.semicolon(flags)];
       },
@@ -57660,14 +58505,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 = join19(fragment, expr.operator);
+          result = join21(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 = join19(result, fragment);
+          result = join21(result, fragment);
         }
         if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
           return ["(", result, ")"];
@@ -57707,7 +58552,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 = join19("new", this.generateExpression(expr.callee, Precedence.New, itemFlags));
+        result = join21("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) {
@@ -57754,11 +58599,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment, rightCharCode, leftSource, leftCharCode;
         fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
         if (space === "") {
-          result = join19(expr.operator, fragment);
+          result = join21(expr.operator, fragment);
         } else {
           result = [expr.operator];
           if (expr.operator.length > 2) {
-            result = join19(result, fragment);
+            result = join21(result, fragment);
           } else {
             leftSource = toSourceNodeWhenNeeded(result).toString();
             leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -57781,12 +58626,12 @@ var require_escodegen = __commonJS((exports) => {
           result = "yield";
         }
         if (expr.argument) {
-          result = join19(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
+          result = join21(result, this.generateExpression(expr.argument, Precedence.Yield, E_TTT));
         }
         return parenthesize(result, Precedence.Yield, precedence);
       },
       AwaitExpression: function(expr, precedence, flags) {
-        var result = join19(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
+        var result = join21(expr.all ? "await*" : "await", this.generateExpression(expr.argument, Precedence.Await, E_TTT));
         return parenthesize(result, Precedence.Await, precedence);
       },
       UpdateExpression: function(expr, precedence, flags) {
@@ -57858,11 +58703,11 @@ var require_escodegen = __commonJS((exports) => {
         var result, fragment;
         result = ["class"];
         if (expr.id) {
-          result = join19(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+          result = join21(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
         }
         if (expr.superClass) {
-          fragment = join19("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-          result = join19(result, fragment);
+          fragment = join21("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+          result = join21(result, fragment);
         }
         result.push(space);
         result.push(this.generateStatement(expr.body, S_TFFT));
@@ -57877,7 +58722,7 @@ var require_escodegen = __commonJS((exports) => {
         }
         if (expr.kind === "get" || expr.kind === "set") {
           fragment = [
-            join19(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+            join21(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
             this.generateFunctionBody(expr.value)
           ];
         } else {
@@ -57887,7 +58732,7 @@ var require_escodegen = __commonJS((exports) => {
             this.generateFunctionBody(expr.value)
           ];
         }
-        return join19(result, fragment);
+        return join21(result, fragment);
       },
       Property: function(expr, precedence, flags) {
         if (expr.kind === "get" || expr.kind === "set") {
@@ -58081,7 +58926,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 = join19(result, fragment);
+                result = join21(result, fragment);
               } else {
                 result.push(fragment);
               }
@@ -58089,13 +58934,13 @@ var require_escodegen = __commonJS((exports) => {
           });
         }
         if (expr.filter) {
-          result = join19(result, "if" + space);
+          result = join21(result, "if" + space);
           fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-          result = join19(result, ["(", fragment, ")"]);
+          result = join21(result, ["(", fragment, ")"]);
         }
         if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
           fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-          result = join19(result, fragment);
+          result = join21(result, fragment);
         }
         result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
         return result;
@@ -58111,8 +58956,8 @@ var require_escodegen = __commonJS((exports) => {
         } else {
           fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
         }
-        fragment = join19(fragment, expr.of ? "of" : "in");
-        fragment = join19(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+        fragment = join21(fragment, expr.of ? "of" : "in");
+        fragment = join21(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
         return ["for" + space + "(", fragment, ")"];
       },
       SpreadElement: function(expr, precedence, flags) {
@@ -71820,8 +72665,8 @@ var init_httpUtil = __esm(() => {
 import { execSync as execSync4 } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
-function folder(platform) {
-  switch (platform) {
+function folder(platform2) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return "linux64";
@@ -71835,32 +72680,32 @@ function folder(platform) {
       return "win64";
   }
 }
-function resolveDownloadUrl(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
-  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join("/")}`;
+function resolveDownloadUrl(platform2, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+  return `${baseUrl}/${resolveDownloadPath(platform2, buildId).join("/")}`;
 }
-function resolveDownloadPath(platform, buildId) {
-  return [buildId, folder(platform), `chrome-${folder(platform)}.zip`];
+function resolveDownloadPath(platform2, buildId) {
+  return [buildId, folder(platform2), `chrome-${folder(platform2)}.zip`];
 }
-function relativeExecutablePath(platform, _buildId) {
-  switch (platform) {
+function relativeExecutablePath(platform2, _buildId) {
+  switch (platform2) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path.join("chrome-" + folder(platform), "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing");
+      return path.join("chrome-" + folder(platform2), "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return path.join("chrome-linux64", "chrome");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path.join("chrome-" + folder(platform), "chrome.exe");
+      return path.join("chrome-" + folder(platform2), "chrome.exe");
   }
 }
-async function getLastKnownGoodReleaseForChannel(channel) {
+async function getLastKnownGoodReleaseForChannel(channel2) {
   const data = await getJSON(new URL(`${baseVersionUrl}/last-known-good-versions.json`));
-  for (const channel2 of Object.keys(data.channels)) {
-    data.channels[channel2.toLowerCase()] = data.channels[channel2];
-    delete data.channels[channel2];
+  for (const channel3 of Object.keys(data.channels)) {
+    data.channels[channel3.toLowerCase()] = data.channels[channel3];
+    delete data.channels[channel3];
   }
-  return data.channels[channel];
+  return data.channels[channel2];
 }
 async function getLastKnownGoodReleaseForMilestone(milestone) {
   const data = await getJSON(new URL(`${baseVersionUrl}/latest-versions-per-milestone.json`));
@@ -71870,24 +72715,24 @@ async function getLastKnownGoodReleaseForBuild(buildPrefix) {
   const data = await getJSON(new URL(`${baseVersionUrl}/latest-patch-versions-per-build.json`));
   return data.builds[buildPrefix];
 }
-async function resolveBuildId(channel) {
-  if (Object.values(ChromeReleaseChannel).includes(channel)) {
-    return (await getLastKnownGoodReleaseForChannel(channel)).version;
+async function resolveBuildId(channel2) {
+  if (Object.values(ChromeReleaseChannel).includes(channel2)) {
+    return (await getLastKnownGoodReleaseForChannel(channel2)).version;
   }
-  if (channel.match(/^\d+$/)) {
-    return (await getLastKnownGoodReleaseForMilestone(channel))?.version;
+  if (channel2.match(/^\d+$/)) {
+    return (await getLastKnownGoodReleaseForMilestone(channel2))?.version;
   }
-  if (channel.match(/^\d+\.\d+\.\d+$/)) {
-    return (await getLastKnownGoodReleaseForBuild(channel))?.version;
+  if (channel2.match(/^\d+\.\d+\.\d+$/)) {
+    return (await getLastKnownGoodReleaseForBuild(channel2))?.version;
   }
   return;
 }
-function getChromeWindowsLocation(channel, locationsPrefixes) {
+function getChromeWindowsLocation(channel2, locationsPrefixes) {
   if (locationsPrefixes.size === 0) {
     throw new Error("Non of the common Windows Env variables were set");
   }
   let suffix;
-  switch (channel) {
+  switch (channel2) {
     case ChromeReleaseChannel.STABLE:
       suffix = "Google\\Chrome\\Application\\chrome.exe";
       break;
@@ -71917,7 +72762,7 @@ function getWslVariable(variable) {
   } catch {}
   return;
 }
-function getWslLocation(channel) {
+function getWslLocation(channel2) {
   const wslVersion = execSync4("wslinfo --version", {
     stdio: ["ignore", "pipe", "ignore"],
     encoding: "utf-8"
@@ -71932,14 +72777,14 @@ function getWslLocation(channel) {
       wslPrefixes.add(wslPrefix);
     }
   }
-  const windowsPath = getChromeWindowsLocation(channel, wslPrefixes);
+  const windowsPath = getChromeWindowsLocation(channel2, wslPrefixes);
   return windowsPath.map((path2) => {
     return execSync4(`wslpath "${path2}"`).toString().trim();
   });
 }
-function getChromeLinuxOrWslLocation(channel) {
+function getChromeLinuxOrWslLocation(channel2) {
   const locations = [];
-  switch (channel) {
+  switch (channel2) {
     case ChromeReleaseChannel.STABLE:
       locations.push("/opt/google/chrome/chrome");
       break;
@@ -71954,15 +72799,15 @@ function getChromeLinuxOrWslLocation(channel) {
       break;
   }
   try {
-    const wslPath = getWslLocation(channel);
+    const wslPath = getWslLocation(channel2);
     if (wslPath) {
       locations.push(...wslPath);
     }
   } catch {}
   return locations;
 }
-function resolveSystemExecutablePaths(platform, channel) {
-  switch (platform) {
+function resolveSystemExecutablePaths(platform2, channel2) {
+  switch (platform2) {
     case BrowserPlatform.WIN64:
     case BrowserPlatform.WIN32:
       const prefixLocation = new Set(WINDOWS_ENV_PARAM_NAMES.map((name) => {
@@ -71974,10 +72819,10 @@ function resolveSystemExecutablePaths(platform, channel) {
       prefixLocation.add("C:\\Program Files (x86)");
       prefixLocation.add("D:\\Program Files");
       prefixLocation.add("D:\\Program Files (x86)");
-      return getChromeWindowsLocation(channel, prefixLocation);
+      return getChromeWindowsLocation(channel2, prefixLocation);
     case BrowserPlatform.MAC_ARM:
     case BrowserPlatform.MAC:
-      switch (channel) {
+      switch (channel2) {
         case ChromeReleaseChannel.STABLE:
           return [
             "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
@@ -71997,14 +72842,14 @@ function resolveSystemExecutablePaths(platform, channel) {
       }
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      return getChromeLinuxOrWslLocation(channel);
+      return getChromeLinuxOrWslLocation(channel2);
   }
 }
-function resolveDefaultUserDataDir(platform, channel) {
-  switch (platform) {
+function resolveDefaultUserDataDir(platform2, channel2) {
+  switch (platform2) {
     case BrowserPlatform.WIN64:
     case BrowserPlatform.WIN32:
-      switch (channel) {
+      switch (channel2) {
         case ChromeReleaseChannel.STABLE:
           return path.join(getLocalAppDataWin(), "Google", "Chrome", "User Data");
         case ChromeReleaseChannel.BETA:
@@ -72016,7 +72861,7 @@ function resolveDefaultUserDataDir(platform, channel) {
       }
     case BrowserPlatform.MAC_ARM:
     case BrowserPlatform.MAC:
-      switch (channel) {
+      switch (channel2) {
         case ChromeReleaseChannel.STABLE:
           return path.join(getBaseUserDataDirPathMac(), "Chrome");
         case ChromeReleaseChannel.BETA:
@@ -72028,7 +72873,7 @@ function resolveDefaultUserDataDir(platform, channel) {
       }
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      switch (channel) {
+      switch (channel2) {
         case ChromeReleaseChannel.STABLE:
           return path.join(getConfigHomeLinux(), "google-chrome");
         case ChromeReleaseChannel.BETA:
@@ -72079,8 +72924,8 @@ var init_chrome = __esm(() => {
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome-headless-shell.js
 import path2 from "node:path";
-function folder2(platform) {
-  switch (platform) {
+function folder2(platform2) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return "linux64";
@@ -72094,27 +72939,27 @@ function folder2(platform) {
       return "win64";
   }
 }
-function resolveDownloadUrl2(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
-  return `${baseUrl}/${resolveDownloadPath2(platform, buildId).join("/")}`;
+function resolveDownloadUrl2(platform2, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+  return `${baseUrl}/${resolveDownloadPath2(platform2, buildId).join("/")}`;
 }
-function resolveDownloadPath2(platform, buildId) {
+function resolveDownloadPath2(platform2, buildId) {
   return [
     buildId,
-    folder2(platform),
-    `chrome-headless-shell-${folder2(platform)}.zip`
+    folder2(platform2),
+    `chrome-headless-shell-${folder2(platform2)}.zip`
   ];
 }
-function relativeExecutablePath2(platform, _buildId) {
-  switch (platform) {
+function relativeExecutablePath2(platform2, _buildId) {
+  switch (platform2) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path2.join("chrome-headless-shell-" + folder2(platform), "chrome-headless-shell");
+      return path2.join("chrome-headless-shell-" + folder2(platform2), "chrome-headless-shell");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return path2.join("chrome-headless-shell-linux64", "chrome-headless-shell");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path2.join("chrome-headless-shell-" + folder2(platform), "chrome-headless-shell.exe");
+      return path2.join("chrome-headless-shell-" + folder2(platform2), "chrome-headless-shell.exe");
   }
 }
 var init_chrome_headless_shell = __esm(() => {
@@ -72124,8 +72969,8 @@ var init_chrome_headless_shell = __esm(() => {
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chromedriver.js
 import path3 from "node:path";
-function folder3(platform) {
-  switch (platform) {
+function folder3(platform2) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return "linux64";
@@ -72139,23 +72984,23 @@ function folder3(platform) {
       return "win64";
   }
 }
-function resolveDownloadUrl3(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
-  return `${baseUrl}/${resolveDownloadPath3(platform, buildId).join("/")}`;
+function resolveDownloadUrl3(platform2, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+  return `${baseUrl}/${resolveDownloadPath3(platform2, buildId).join("/")}`;
 }
-function resolveDownloadPath3(platform, buildId) {
-  return [buildId, folder3(platform), `chromedriver-${folder3(platform)}.zip`];
+function resolveDownloadPath3(platform2, buildId) {
+  return [buildId, folder3(platform2), `chromedriver-${folder3(platform2)}.zip`];
 }
-function relativeExecutablePath3(platform, _buildId) {
-  switch (platform) {
+function relativeExecutablePath3(platform2, _buildId) {
+  switch (platform2) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path3.join("chromedriver-" + folder3(platform), "chromedriver");
+      return path3.join("chromedriver-" + folder3(platform2), "chromedriver");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return path3.join("chromedriver-linux64", "chromedriver");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path3.join("chromedriver-" + folder3(platform), "chromedriver.exe");
+      return path3.join("chromedriver-" + folder3(platform2), "chromedriver.exe");
   }
 }
 var init_chromedriver = __esm(() => {
@@ -72165,8 +73010,8 @@ var init_chromedriver = __esm(() => {
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chromium.js
 import path4 from "node:path";
-function archive(platform, buildId) {
-  switch (platform) {
+function archive(platform2, buildId) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return "chrome-linux";
@@ -72178,8 +73023,8 @@ function archive(platform, buildId) {
       return parseInt(buildId, 10) > 591479 ? "chrome-win" : "chrome-win32";
   }
 }
-function folder4(platform) {
-  switch (platform) {
+function folder4(platform2) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return "Linux_x64";
@@ -72193,14 +73038,14 @@ function folder4(platform) {
       return "Win_x64";
   }
 }
-function resolveDownloadUrl4(platform, buildId, baseUrl = "https://storage.googleapis.com/chromium-browser-snapshots") {
-  return `${baseUrl}/${resolveDownloadPath4(platform, buildId).join("/")}`;
+function resolveDownloadUrl4(platform2, buildId, baseUrl = "https://storage.googleapis.com/chromium-browser-snapshots") {
+  return `${baseUrl}/${resolveDownloadPath4(platform2, buildId).join("/")}`;
 }
-function resolveDownloadPath4(platform, buildId) {
-  return [folder4(platform), buildId, `${archive(platform, buildId)}.zip`];
+function resolveDownloadPath4(platform2, buildId) {
+  return [folder4(platform2), buildId, `${archive(platform2, buildId)}.zip`];
 }
-function relativeExecutablePath4(platform, _buildId) {
-  switch (platform) {
+function relativeExecutablePath4(platform2, _buildId) {
+  switch (platform2) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
       return path4.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
@@ -72212,8 +73057,8 @@ function relativeExecutablePath4(platform, _buildId) {
       return path4.join("chrome-win", "chrome.exe");
   }
 }
-async function resolveBuildId2(platform) {
-  return await getText(new URL(`https://storage.googleapis.com/chromium-browser-snapshots/${folder4(platform)}/LAST_CHANGE`));
+async function resolveBuildId2(platform2) {
+  return await getText(new URL(`https://storage.googleapis.com/chromium-browser-snapshots/${folder4(platform2)}/LAST_CHANGE`));
 }
 function compareVersions2(a, b) {
   return Number(a) - Number(b);
@@ -72230,8 +73075,8 @@ function getFormat(buildId) {
   const majorVersion = Number(buildId.split(".").shift());
   return majorVersion >= 135 ? "xz" : "bz2";
 }
-function archiveNightly(platform, buildId) {
-  switch (platform) {
+function archiveNightly(platform2, buildId) {
+  switch (platform2) {
     case BrowserPlatform.LINUX:
       return `firefox-${buildId}.en-US.linux-x86_64.tar.${getFormat(buildId)}`;
     case BrowserPlatform.LINUX_ARM:
@@ -72241,11 +73086,11 @@ function archiveNightly(platform, buildId) {
       return `firefox-${buildId}.en-US.mac.dmg`;
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return `firefox-${buildId}.en-US.${platform}.zip`;
+      return `firefox-${buildId}.en-US.${platform2}.zip`;
   }
 }
-function archive2(platform, buildId) {
-  switch (platform) {
+function archive2(platform2, buildId) {
+  switch (platform2) {
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
       return `firefox-${buildId}.tar.${getFormat(buildId)}`;
@@ -72257,8 +73102,8 @@ function archive2(platform, buildId) {
       return `Firefox Setup ${buildId}.exe`;
   }
 }
-function platformName(platform) {
-  switch (platform) {
+function platformName(platform2) {
+  switch (platform2) {
     case BrowserPlatform.LINUX:
       return `linux-x86_64`;
     case BrowserPlatform.LINUX_ARM:
@@ -72268,7 +73113,7 @@ function platformName(platform) {
       return `mac`;
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return platform;
+      return platform2;
   }
 }
 function parseBuildId(buildId) {
@@ -72280,9 +73125,9 @@ function parseBuildId(buildId) {
   }
   return [FirefoxChannel.NIGHTLY, buildId];
 }
-function resolveDownloadUrl5(platform, buildId, baseUrl) {
-  const [channel] = parseBuildId(buildId);
-  switch (channel) {
+function resolveDownloadUrl5(platform2, buildId, baseUrl) {
+  const [channel2] = parseBuildId(buildId);
+  switch (channel2) {
     case FirefoxChannel.NIGHTLY:
       baseUrl ??= "https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central";
       break;
@@ -72295,30 +73140,30 @@ function resolveDownloadUrl5(platform, buildId, baseUrl) {
       baseUrl ??= "https://archive.mozilla.org/pub/firefox/releases";
       break;
   }
-  return `${baseUrl}/${resolveDownloadPath5(platform, buildId).join("/")}`;
+  return `${baseUrl}/${resolveDownloadPath5(platform2, buildId).join("/")}`;
 }
-function resolveDownloadPath5(platform, buildId) {
-  const [channel, resolvedBuildId] = parseBuildId(buildId);
-  switch (channel) {
+function resolveDownloadPath5(platform2, buildId) {
+  const [channel2, resolvedBuildId] = parseBuildId(buildId);
+  switch (channel2) {
     case FirefoxChannel.NIGHTLY:
-      return [archiveNightly(platform, resolvedBuildId)];
+      return [archiveNightly(platform2, resolvedBuildId)];
     case FirefoxChannel.DEVEDITION:
     case FirefoxChannel.BETA:
     case FirefoxChannel.STABLE:
     case FirefoxChannel.ESR:
       return [
         resolvedBuildId,
-        platformName(platform),
+        platformName(platform2),
         "en-US",
-        archive2(platform, resolvedBuildId)
+        archive2(platform2, resolvedBuildId)
       ];
   }
 }
-function relativeExecutablePath5(platform, buildId) {
-  const [channel] = parseBuildId(buildId);
-  switch (channel) {
+function relativeExecutablePath5(platform2, buildId) {
+  const [channel2] = parseBuildId(buildId);
+  switch (channel2) {
     case FirefoxChannel.NIGHTLY:
-      switch (platform) {
+      switch (platform2) {
         case BrowserPlatform.MAC_ARM:
         case BrowserPlatform.MAC:
           return path5.join("Firefox Nightly.app", "Contents", "MacOS", "firefox");
@@ -72333,7 +73178,7 @@ function relativeExecutablePath5(platform, buildId) {
     case FirefoxChannel.DEVEDITION:
     case FirefoxChannel.ESR:
     case FirefoxChannel.STABLE:
-      switch (platform) {
+      switch (platform2) {
         case BrowserPlatform.MAC_ARM:
         case BrowserPlatform.MAC:
           return path5.join("Firefox.app", "Contents", "MacOS", "firefox");
@@ -72346,7 +73191,7 @@ function relativeExecutablePath5(platform, buildId) {
       }
   }
 }
-async function resolveBuildId3(channel = FirefoxChannel.NIGHTLY) {
+async function resolveBuildId3(channel2 = FirefoxChannel.NIGHTLY) {
   const channelToVersionKey = {
     [FirefoxChannel.ESR]: "FIREFOX_ESR",
     [FirefoxChannel.STABLE]: "LATEST_FIREFOX_VERSION",
@@ -72355,11 +73200,11 @@ async function resolveBuildId3(channel = FirefoxChannel.NIGHTLY) {
     [FirefoxChannel.NIGHTLY]: "FIREFOX_NIGHTLY"
   };
   const versions = await getJSON(new URL(`${baseVersionUrl2}/firefox_versions.json`));
-  const version = versions[channelToVersionKey[channel]];
+  const version = versions[channelToVersionKey[channel2]];
   if (!version) {
-    throw new Error(`Channel ${channel} is not found.`);
+    throw new Error(`Channel ${channel2} is not found.`);
   }
-  return channel + "_" + version;
+  return channel2 + "_" + version;
 }
 async function createProfile(options) {
   if (!fs.existsSync(options.path)) {
@@ -72498,7 +73343,7 @@ var init_firefox = __esm(() => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/browser-data.js
-async function resolveBuildIdForBrowserTag(browser, platform, tag) {
+async function resolveBuildIdForBrowserTag(browser, platform2, tag) {
   switch (browser) {
     case Browser6.FIREFOX:
       switch (tag) {
@@ -72573,7 +73418,7 @@ async function resolveBuildIdForBrowserTag(browser, platform, tag) {
     case Browser6.CHROMIUM:
       switch (tag) {
         case BrowserTag.LATEST:
-          return await resolveBuildId2(platform);
+          return await resolveBuildId2(platform2);
         case BrowserTag.NIGHTLY:
         case BrowserTag.CANARY:
         case BrowserTag.DEV:
@@ -72585,10 +73430,10 @@ async function resolveBuildIdForBrowserTag(browser, platform, tag) {
       }
   }
 }
-async function resolveBuildId4(browser, platform, tag) {
+async function resolveBuildId4(browser, platform2, tag) {
   const browserTag = tag;
   if (Object.values(BrowserTag).includes(browserTag)) {
-    return await resolveBuildIdForBrowserTag(browser, platform, browserTag);
+    return await resolveBuildIdForBrowserTag(browser, platform2, browserTag);
   }
   switch (browser) {
     case Browser6.FIREFOX:
@@ -72624,7 +73469,7 @@ async function createProfile2(browser, opts) {
       throw new Error(`Profile creation is not support for ${browser} yet`);
   }
 }
-function resolveDefaultUserDataDir2(browser, platform, channel) {
+function resolveDefaultUserDataDir2(browser, platform2, channel2) {
   switch (browser) {
     case Browser6.CHROMEDRIVER:
     case Browser6.CHROMEHEADLESSSHELL:
@@ -72632,10 +73477,10 @@ function resolveDefaultUserDataDir2(browser, platform, channel) {
     case Browser6.CHROMIUM:
       throw new Error(`Default user dir detection is not supported for ${browser} yet.`);
     case Browser6.CHROME:
-      return resolveDefaultUserDataDir(platform, channel);
+      return resolveDefaultUserDataDir(platform2, channel2);
   }
 }
-function resolveSystemExecutablePaths2(browser, platform, channel) {
+function resolveSystemExecutablePaths2(browser, platform2, channel2) {
   switch (browser) {
     case Browser6.CHROMEDRIVER:
     case Browser6.CHROMEHEADLESSSHELL:
@@ -72643,7 +73488,7 @@ function resolveSystemExecutablePaths2(browser, platform, channel) {
     case Browser6.CHROMIUM:
       throw new Error(`System browser detection is not supported for ${browser} yet.`);
     case Browser6.CHROME:
-      return resolveSystemExecutablePaths(platform, channel);
+      return resolveSystemExecutablePaths(platform2, channel2);
   }
 }
 function getVersionComparator(browser) {
@@ -72690,9 +73535,9 @@ var init_browser_data = __esm(() => {
 // node_modules/@puppeteer/browsers/lib/esm/detectPlatform.js
 import os2 from "node:os";
 function detectBrowserPlatform() {
-  const platform = os2.platform();
+  const platform2 = os2.platform();
   const arch = os2.arch();
-  switch (platform) {
+  switch (platform2) {
     case "darwin":
       return arch === "arm64" ? BrowserPlatform.MAC_ARM : BrowserPlatform.MAC;
     case "linux":
@@ -72728,15 +73573,15 @@ class InstalledBrowser {
   platform;
   executablePath;
   #cache;
-  constructor(cache, browser, buildId, platform) {
+  constructor(cache, browser, buildId, platform2) {
     this.#cache = cache;
     this.browser = browser;
     this.buildId = buildId;
-    this.platform = platform;
+    this.platform = platform2;
     this.executablePath = cache.computeExecutablePath({
       browser,
       buildId,
-      platform
+      platform: platform2
     });
   }
   get path() {
@@ -72780,17 +73625,17 @@ class Cache {
     fs2.mkdirSync(path6.dirname(metatadaPath), { recursive: true });
     fs2.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
   }
-  readExecutablePath(browser, platform, buildId) {
+  readExecutablePath(browser, platform2, buildId) {
     const metadata = this.readMetadata(browser);
-    const key = `${platform}-${buildId}`;
+    const key = `${platform2}-${buildId}`;
     return metadata.executablePaths?.[key] ?? null;
   }
-  writeExecutablePath(browser, platform, buildId, executablePath) {
+  writeExecutablePath(browser, platform2, buildId, executablePath) {
     const metadata = this.readMetadata(browser);
     if (!metadata.executablePaths) {
       metadata.executablePaths = {};
     }
-    const key = `${platform}-${buildId}`;
+    const key = `${platform2}-${buildId}`;
     metadata.executablePaths[key] = executablePath;
     this.writeMetadata(browser, metadata);
   }
@@ -72801,8 +73646,8 @@ class Cache {
     }
     return metadata.aliases[alias];
   }
-  installationDir(browser, platform, buildId) {
-    return path6.join(this.browserRoot(browser), `${platform}-${buildId}`);
+  installationDir(browser, platform2, buildId) {
+    return path6.join(this.browserRoot(browser), `${platform2}-${buildId}`);
   }
   clear() {
     fs2.rmSync(this.#rootDir, {
@@ -72812,19 +73657,19 @@ class Cache {
       retryDelay: 500
     });
   }
-  uninstall(browser, platform, buildId) {
+  uninstall(browser, platform2, buildId) {
     const metadata = this.readMetadata(browser);
     for (const alias of Object.keys(metadata.aliases)) {
       if (metadata.aliases[alias] === buildId) {
         delete metadata.aliases[alias];
       }
     }
-    const key = `${platform}-${buildId}`;
+    const key = `${platform2}-${buildId}`;
     if (metadata.executablePaths?.[key]) {
       delete metadata.executablePaths[key];
       this.writeMetadata(browser, metadata);
     }
-    fs2.rmSync(this.installationDir(browser, platform, buildId), {
+    fs2.rmSync(this.installationDir(browser, platform2, buildId), {
       force: true,
       recursive: true,
       maxRetries: 10,
@@ -72876,11 +73721,11 @@ function parseFolderPath(folderPath) {
   if (splits.length !== 2) {
     return;
   }
-  const [platform, buildId] = splits;
-  if (!buildId || !platform) {
+  const [platform2, buildId] = splits;
+  if (!buildId || !platform2) {
     return;
   }
-  return { platform, buildId };
+  return { platform: platform2, buildId };
 }
 var import_debug, debugCache;
 var init_Cache = __esm(() => {
@@ -73383,8 +74228,8 @@ class DefaultProvider {
   getDownloadUrl(options) {
     return this.#getDownloadUrl(options.browser, options.platform, options.buildId);
   }
-  #getDownloadUrl(browser, platform, buildId) {
-    return new URL(downloadUrls[browser](platform, buildId, this.#baseUrl));
+  #getDownloadUrl(browser, platform2, buildId) {
+    return new URL(downloadUrls[browser](platform2, buildId, this.#baseUrl));
   }
   getExecutablePath(options) {
     return executablePathByBrowser[options.browser](options.platform, options.buildId);
@@ -78079,7 +78924,7 @@ var require_tar_fs = __commonJS((exports) => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/fileUtil.js
-import { spawnSync, spawn } from "node:child_process";
+import { spawnSync as spawnSync2, spawn } from "node:child_process";
 import { createReadStream } from "node:fs";
 import { mkdir, readdir } from "node:fs/promises";
 import * as path7 from "node:path";
@@ -78097,7 +78942,7 @@ async function unpackArchive(archivePath, folderPath) {
     await mkdir(folderPath);
     await installDMG(archivePath, folderPath);
   } else if (archivePath.endsWith(".exe")) {
-    const result = spawnSync(archivePath, [`/ExtractDir=${folderPath}`], {
+    const result = spawnSync2(archivePath, [`/ExtractDir=${folderPath}`], {
       env: {
         __compat_layer: "RunAsInvoker"
       }
@@ -78171,7 +79016,7 @@ async function extractTar(tarPath, folderPath, decompressUtilityName) {
   });
 }
 async function installDMG(dmgPath, folderPath) {
-  const { stdout } = spawnSync(`hdiutil`, [
+  const { stdout } = spawnSync2(`hdiutil`, [
     "attach",
     "-nobrowse",
     "-noautoopen",
@@ -78191,9 +79036,9 @@ async function installDMG(dmgPath, folderPath) {
       throw new Error(`Cannot find app in ${mountPath}`);
     }
     const mountedPath = path7.join(mountPath, appName);
-    spawnSync("cp", ["-R", mountedPath, folderPath]);
+    spawnSync2("cp", ["-R", mountedPath, folderPath]);
   } finally {
-    spawnSync("hdiutil", ["detach", mountPath, "-quiet"]);
+    spawnSync2("hdiutil", ["detach", mountPath, "-quiet"]);
   }
 }
 var import_debug4, debugFileUtil, internalConstantsForTesting;
@@ -78208,8 +79053,8 @@ var init_fileUtil = __esm(() => {
 
 // node_modules/@puppeteer/browsers/lib/esm/install.js
 import assert2 from "node:assert";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync19 } from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
 import { mkdir as mkdir2, unlink } from "node:fs/promises";
 import os5 from "node:os";
 import path8 from "node:path";
@@ -78262,7 +79107,7 @@ async function installWithProviders(options) {
         continue;
       }
       debugInstall(`Successfully got URL from ${provider.getName()}: ${url}`);
-      if (!existsSync19(browserRoot)) {
+      if (!existsSync22(browserRoot)) {
         await mkdir2(browserRoot, { recursive: true });
       }
       return await installUrl(url, options, provider);
@@ -78295,21 +79140,21 @@ async function installDeps(installedBrowser) {
     return;
   }
   const depsPath = path8.join(path8.dirname(installedBrowser.executablePath), "deb.deps");
-  if (!existsSync19(depsPath)) {
+  if (!existsSync22(depsPath)) {
     debugInstall(`deb.deps file was not found at ${depsPath}`);
     return;
   }
-  const data = readFileSync19(depsPath, "utf-8").split(`
+  const data = readFileSync21(depsPath, "utf-8").split(`
 `).join(",");
   if (process.getuid?.() !== 0) {
     throw new Error("Installing system dependencies requires root privileges");
   }
-  let result = spawnSync2("apt-get", ["-v"]);
+  let result = spawnSync3("apt-get", ["-v"]);
   if (result.status !== 0) {
     throw new Error("Failed to install system dependencies: apt-get does not seem to be available");
   }
   debugInstall(`Trying to install dependencies: ${data}`);
-  result = spawnSync2("apt-get", [
+  result = spawnSync3("apt-get", [
     "satisfy",
     "-y",
     data,
@@ -78337,11 +79182,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 (!existsSync19(browserRoot)) {
+  if (!existsSync22(browserRoot)) {
     await mkdir2(browserRoot, { recursive: true });
   }
   if (!options.unpack) {
-    if (existsSync19(archivePath)) {
+    if (existsSync22(archivePath)) {
       return archivePath;
     }
     debugInstall(`Downloading binary from ${url}`);
@@ -78362,8 +79207,8 @@ async function installUrl(url, options, provider) {
     cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
   }
   try {
-    if (existsSync19(outputPath)) {
-      if (!existsSync19(installedBrowser.executablePath)) {
+    if (existsSync22(outputPath)) {
+      if (!existsSync22(installedBrowser.executablePath)) {
         throw new Error(`The browser folder (${outputPath}) exists but the executable (${installedBrowser.executablePath}) is missing`);
       }
       await runSetup(installedBrowser);
@@ -78372,7 +79217,7 @@ async function installUrl(url, options, provider) {
       }
       return installedBrowser;
     }
-    if (!existsSync19(archivePath)) {
+    if (!existsSync22(archivePath)) {
       debugInstall(`Downloading binary from ${url}`);
       try {
         debugTime("download");
@@ -78401,7 +79246,7 @@ async function installUrl(url, options, provider) {
     }
     return installedBrowser;
   } finally {
-    if (existsSync19(archivePath)) {
+    if (existsSync22(archivePath)) {
       await unlink(archivePath);
     }
   }
@@ -78412,10 +79257,10 @@ async function runSetup(installedBrowser) {
       debugTime("permissions");
       const browserDir = path8.dirname(installedBrowser.executablePath);
       const setupExePath = path8.join(browserDir, "setup.exe");
-      if (!existsSync19(setupExePath)) {
+      if (!existsSync22(setupExePath)) {
         return;
       }
-      spawnSync2(path8.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
+      spawnSync3(path8.join(browserDir, "setup.exe"), [`--configure-browser-in-directory=` + browserDir], {
         shell: true
       });
     } finally {
@@ -78458,8 +79303,8 @@ async function canDownload(options) {
   }
   return false;
 }
-function getDownloadUrl(browser, platform, buildId, baseUrl) {
-  return new URL(downloadUrls[browser](platform, buildId, baseUrl));
+function getDownloadUrl(browser, platform2, buildId, baseUrl) {
+  return new URL(downloadUrls[browser](platform2, buildId, baseUrl));
 }
 function makeProgressCallback(browser, buildId) {
   let progressBar;
@@ -78793,19 +79638,19 @@ var init_cliui = __esm(() => {
 });
 
 // node_modules/escalade/sync/index.mjs
-import { dirname as dirname8, resolve as resolve7 } from "path";
+import { dirname as dirname10, resolve as resolve7 } from "path";
 import { readdirSync as readdirSync6, statSync as statSync9 } from "fs";
 function sync_default(start, callback) {
   let dir = resolve7(".", start);
   let tmp, stats = statSync9(dir);
   if (!stats.isDirectory()) {
-    dir = dirname8(dir);
+    dir = dirname10(dir);
   }
   while (true) {
     tmp = callback(dir, readdirSync6(dir));
     if (tmp)
       return resolve7(dir, tmp);
-    dir = dirname8(tmp = dir);
+    dir = dirname10(tmp = dir);
     if (tmp === dir)
       break;
   }
@@ -79825,14 +80670,14 @@ var init_yerror = __esm(() => {
 });
 
 // node_modules/y18n/build/lib/platform-shims/node.js
-import { readFileSync as readFileSync20, statSync as statSync10, writeFile } from "fs";
+import { readFileSync as readFileSync22, statSync as statSync10, writeFile } from "fs";
 import { format as format2 } from "util";
 import { resolve as resolve9 } from "path";
 var node_default;
 var init_node = __esm(() => {
   node_default = {
     fs: {
-      readFileSync: readFileSync20,
+      readFileSync: readFileSync22,
       writeFile
     },
     format: format2,
@@ -80017,9 +80862,9 @@ var init_y18n = __esm(() => {
 // node_modules/yargs/lib/platform-shims/esm.mjs
 import { notStrictEqual, strictEqual } from "assert";
 import { inspect } from "util";
-import { readFileSync as readFileSync21 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { fileURLToPath } from "url";
-import { basename as basename10, dirname as dirname9, extname as extname3, relative as relative7, resolve as resolve10 } from "path";
+import { basename as basename10, dirname as dirname11, extname as extname3, relative as relative7, resolve as resolve10 } 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();
@@ -80052,7 +80897,7 @@ var init_esm = __esm(() => {
     Parser: lib_default,
     path: {
       basename: basename10,
-      dirname: dirname9,
+      dirname: dirname11,
       extname: extname3,
       relative: relative7,
       resolve: resolve10
@@ -80066,7 +80911,7 @@ var init_esm = __esm(() => {
       nextTick: process.nextTick,
       stdColumns: typeof process.stdout.columns !== "undefined" ? process.stdout.columns : null
     },
-    readFileSync: readFileSync21,
+    readFileSync: readFileSync23,
     require: () => {
       throw new YError(REQUIRE_ERROR);
     },
@@ -83399,8 +84244,8 @@ import * as readline2 from "node:readline";
 function isValidBrowser(browser) {
   return Object.values(Browser6).includes(browser);
 }
-function isValidPlatform(platform) {
-  return Object.values(BrowserPlatform).includes(platform);
+function isValidPlatform(platform2) {
+  return Object.values(BrowserPlatform).includes(platform2);
 }
 
 class CLI {
@@ -83451,11 +84296,11 @@ class CLI {
       desc: "Platform that the binary needs to be compatible with.",
       choices: Object.values(BrowserPlatform),
       default: detectBrowserPlatform(),
-      coerce: (platform) => {
-        if (!isValidPlatform(platform)) {
-          throw new Error(`Unsupported platform '${platform}'`);
+      coerce: (platform2) => {
+        if (!isValidPlatform(platform2)) {
+          throw new Error(`Unsupported platform '${platform2}'`);
         }
-        return platform;
+        return platform2;
       },
       defaultDescription: "Auto-detected"
     });
@@ -83660,8 +84505,8 @@ var init_CLI = __esm(() => {
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/provider.js
-function buildArchiveFilename(browser, platform, buildId, extension2 = "zip") {
-  return `${browser}-${platform}-${buildId}.${extension2}`;
+function buildArchiveFilename(browser, platform2, buildId, extension2 = "zip") {
+  return `${browser}-${platform2}-${buildId}.${extension2}`;
 }
 
 // node_modules/@puppeteer/browsers/lib/esm/main.js
@@ -83711,8 +84556,8 @@ var exports_LaunchOptions = {};
 __export(exports_LaunchOptions, {
   convertPuppeteerChannelToBrowsersChannel: () => convertPuppeteerChannelToBrowsersChannel
 });
-function convertPuppeteerChannelToBrowsersChannel(channel) {
-  switch (channel) {
+function convertPuppeteerChannelToBrowsersChannel(channel2) {
+  switch (channel2) {
     case "chrome":
       return ChromeReleaseChannel.STABLE;
     case "chrome-dev":
@@ -83739,8 +84584,8 @@ async function _connectToBrowser(options) {
   }
 }
 async function getConnectionTransport(options) {
-  const { browserWSEndpoint, browserURL, channel, transport, headers = {} } = options;
-  assert(Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) + Number(!!channel) === 1, "Exactly one of browserWSEndpoint, browserURL, transport or channel must be passed to puppeteer.connect");
+  const { browserWSEndpoint, browserURL, channel: channel2, transport, headers = {} } = options;
+  assert(Number(!!browserWSEndpoint) + Number(!!browserURL) + Number(!!transport) + Number(!!channel2) === 1, "Exactly one of browserWSEndpoint, browserURL, transport or channel must be passed to puppeteer.connect");
   if (transport) {
     return { connectionTransport: transport, endpointUrl: "" };
   } else if (browserWSEndpoint) {
@@ -83760,14 +84605,14 @@ async function getConnectionTransport(options) {
     };
   } else if (options.channel && isNode) {
     const { detectBrowserPlatform: detectBrowserPlatform2, resolveDefaultUserDataDir: resolveDefaultUserDataDir3, Browser: Browser7 } = await Promise.resolve().then(() => (init_main(), exports_main));
-    const platform = detectBrowserPlatform2();
-    if (!platform) {
+    const platform2 = detectBrowserPlatform2();
+    if (!platform2) {
       throw new Error("Could not detect required browser platform");
     }
     const { convertPuppeteerChannelToBrowsersChannel: convertPuppeteerChannelToBrowsersChannel2 } = await Promise.resolve().then(() => (init_LaunchOptions(), exports_LaunchOptions));
-    const { join: join20 } = await import("node:path");
-    const userDataDir = resolveDefaultUserDataDir3(Browser7.CHROME, platform, convertPuppeteerChannelToBrowsersChannel2(options.channel));
-    const portPath = join20(userDataDir, "DevToolsActivePort");
+    const { join: join22 } = await import("node:path");
+    const userDataDir = resolveDefaultUserDataDir3(Browser7.CHROME, platform2, convertPuppeteerChannelToBrowsersChannel2(options.channel));
+    const portPath = join22(userDataDir, "DevToolsActivePort");
     try {
       const fileContent = await environment.value.fs.promises.readFile(portPath, "ascii");
       const [rawPort, rawPath] = fileContent.split(`
@@ -83991,9 +84836,9 @@ var init_PipeTransport = __esm(() => {
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/BrowserLauncher.js
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 
 class BrowserLauncher {
   #browser;
@@ -84018,7 +84863,7 @@ class BrowserLauncher {
       ...options,
       protocol
     });
-    if (!existsSync20(launchArgs.executablePath)) {
+    if (!existsSync23(launchArgs.executablePath)) {
       throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
     }
     const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
@@ -84093,7 +84938,7 @@ class BrowserLauncher {
       browserCloseCallback();
       const logs = browserProcess.getRecentLogs().join(`
 `);
-      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync20(join20(launchArgs.userDataDir, "lockfile"))) {
+      if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync23(join22(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) {
@@ -84183,12 +85028,12 @@ class BrowserLauncher {
     });
   }
   getProfilePath() {
-    return join20(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+    return join22(this.puppeteer.configuration.temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
   }
   resolveExecutablePath(headless, validatePath = true) {
     let executablePath = this.puppeteer.configuration.executablePath;
     if (executablePath) {
-      if (validatePath && !existsSync20(executablePath)) {
+      if (validatePath && !existsSync23(executablePath)) {
         throw new Error(`Tried to find the browser at the configured path (${executablePath}), but no executable was found.`);
       }
       return executablePath;
@@ -84211,7 +85056,7 @@ class BrowserLauncher {
       browser: browserType,
       buildId: this.puppeteer.browserVersion
     });
-    if (validatePath && !existsSync20(executablePath)) {
+    if (validatePath && !existsSync23(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.`);
@@ -84311,7 +85156,7 @@ var init_ChromeLauncher = __esm(() => {
       return super.launch(options);
     }
     async computeLaunchArguments(options = {}) {
-      const { ignoreDefaultArgs = false, args = [], pipe: pipe2 = false, debuggingPort, channel, executablePath } = options;
+      const { ignoreDefaultArgs = false, args = [], pipe: pipe2 = false, debuggingPort, channel: channel2, executablePath } = options;
       const chromeArguments = [];
       if (!ignoreDefaultArgs) {
         chromeArguments.push(...this.defaultArgs(options));
@@ -84345,8 +85190,8 @@ var init_ChromeLauncher = __esm(() => {
       assert(typeof userDataDir === "string", "`--user-data-dir` is malformed");
       let chromeExecutable = executablePath;
       if (!chromeExecutable) {
-        assert(channel || !this.puppeteer._isPuppeteerCore, `An \`executablePath\` or \`channel\` must be specified for \`puppeteer-core\``);
-        chromeExecutable = channel ? this.executablePath(channel) : this.resolveExecutablePath(options.headless ?? true);
+        assert(channel2 || !this.puppeteer._isPuppeteerCore, `An \`executablePath\` or \`channel\` must be specified for \`puppeteer-core\``);
+        chromeExecutable = channel2 ? this.executablePath(channel2) : this.resolveExecutablePath(options.headless ?? true);
       }
       return {
         executablePath: chromeExecutable,
@@ -84450,11 +85295,11 @@ var init_ChromeLauncher = __esm(() => {
       chromeArguments.push(...args);
       return chromeArguments;
     }
-    executablePath(channel, validatePath = true) {
-      if (channel) {
+    executablePath(channel2, validatePath = true) {
+      if (channel2) {
         return computeSystemExecutablePath({
           browser: Browser6.CHROME,
-          channel: convertPuppeteerChannelToBrowsersChannel(channel)
+          channel: convertPuppeteerChannelToBrowsersChannel(channel2)
         });
       } else {
         return this.resolveExecutablePath(undefined, validatePath);
@@ -84697,8 +85542,8 @@ var init_PuppeteerNode = __esm(() => {
       return this.#getLauncher(options.browser ?? this.lastLaunchedBrowser).defaultArgs(options);
     }
     async trimCache() {
-      const platform = detectBrowserPlatform();
-      if (!platform) {
+      const platform2 = detectBrowserPlatform();
+      if (!platform2) {
         throw new Error("The current platform is not supported.");
       }
       const cacheDir = this.configuration.cacheDirectory;
@@ -84719,7 +85564,7 @@ var init_PuppeteerNode = __esm(() => {
       ];
       await Promise.all(puppeteerBrowsers.map(async (item) => {
         const tag = this.configuration?.[item.product]?.version ?? PUPPETEER_REVISIONS[item.product];
-        item.currentBuildId = await resolveBuildId4(item.browser, platform, tag);
+        item.currentBuildId = await resolveBuildId4(item.browser, platform2, tag);
       }));
       const currentBrowserBuilds = new Set(puppeteerBrowsers.map((browser) => {
         return `${browser.browser}_${browser.currentBuildId}`;
@@ -84736,7 +85581,7 @@ var init_PuppeteerNode = __esm(() => {
         }
         await uninstall({
           browser: installedBrowser.browser,
-          platform,
+          platform: platform2,
           cacheDir,
           buildId: installedBrowser.buildId
         });
@@ -84746,10 +85591,10 @@ var init_PuppeteerNode = __esm(() => {
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js
-import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "node:child_process";
 import fs5 from "node:fs";
 import os8 from "node:os";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 import { PassThrough } from "node:stream";
 var import_debug6, __runInitializers22 = function(thisArg, initializers, value) {
   var useValue = arguments.length > 2;
@@ -84850,7 +85695,7 @@ var init_ScreenRecorder = __esm(() => {
         colors ??= 256;
         overwrite ??= true;
         this.#fps = fps;
-        const { error } = spawnSync3(ffmpegPath);
+        const { error } = spawnSync4(ffmpegPath);
         if (error) {
           throw error;
         }
@@ -84873,7 +85718,7 @@ var init_ScreenRecorder = __esm(() => {
           filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
         }
         if (path11) {
-          fs5.mkdirSync(dirname10(path11), { recursive: overwrite });
+          fs5.mkdirSync(dirname12(path11), { recursive: overwrite });
         }
         this.#process = spawn2(ffmpegPath, [
           ["-loglevel", "error"],
@@ -85026,17 +85871,17 @@ var init_puppeteer_core = __esm(() => {
 });
 
 // src/core/design-eval/capture.ts
-import { mkdirSync as mkdirSync8, statSync as statSync11, existsSync as existsSync21 } from "fs";
-import { join as join21 } from "path";
+import { mkdirSync as mkdirSync11, statSync as statSync11, existsSync as existsSync24 } from "fs";
+import { join as join23 } from "path";
 function findBrowser() {
-  const platform = process.platform;
-  const paths = CHROME_PATHS[platform] ?? [];
+  const platform2 = process.platform;
+  const paths = CHROME_PATHS[platform2] ?? [];
   for (const p of paths) {
-    if (existsSync21(p))
+    if (existsSync24(p))
       return p;
   }
-  const minkBrowsers = join21(minkRoot(), "browsers");
-  if (existsSync21(minkBrowsers)) {
+  const minkBrowsers = join23(minkRoot(), "browsers");
+  if (existsSync24(minkBrowsers)) {
     const found = findChromeInDir(minkBrowsers);
     if (found)
       return found;
@@ -85057,7 +85902,7 @@ function findChromeInDir(dir) {
   try {
     const entries = readdirSync7(dir);
     for (const entry of entries) {
-      const full = join21(dir, entry);
+      const full = join23(dir, entry);
       try {
         const stat2 = statSync12(full);
         if (stat2.isDirectory()) {
@@ -85105,7 +85950,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 = join21(options.outputDir, fileName);
+    const filePath = join23(options.outputDir, fileName);
     await page.screenshot({
       path: filePath,
       type: "jpeg",
@@ -85137,7 +85982,7 @@ async function captureRoute(page, route, baseUrl, viewport, options) {
   return results;
 }
 async function captureAllRoutes(routes, baseUrl, viewports, options, outputDir) {
-  mkdirSync8(outputDir, { recursive: true });
+  mkdirSync11(outputDir, { recursive: true });
   const executablePath = findBrowser();
   const browser = await puppeteer_core_default.launch({
     executablePath,
@@ -86565,22 +87410,22 @@ var init_framework_advisor2 = __esm(() => {
 });
 
 // src/core/vault-templates.ts
-import { join as join22 } from "path";
-import { existsSync as existsSync22, writeFileSync as writeFileSync5, readFileSync as readFileSync22, mkdirSync as mkdirSync9 } from "fs";
+import { join as join24 } from "path";
+import { existsSync as existsSync25, writeFileSync as writeFileSync8, readFileSync as readFileSync24, mkdirSync as mkdirSync12 } from "fs";
 function seedTemplates(templatesDir) {
-  mkdirSync9(templatesDir, { recursive: true });
+  mkdirSync12(templatesDir, { recursive: true });
   for (const [name, content] of Object.entries(DEFAULT_TEMPLATES)) {
-    const filePath = join22(templatesDir, `${name}.md`);
-    if (!existsSync22(filePath)) {
-      writeFileSync5(filePath, content);
+    const filePath = join24(templatesDir, `${name}.md`);
+    if (!existsSync25(filePath)) {
+      writeFileSync8(filePath, content);
     }
   }
 }
 function loadTemplate(templatesDir, templateName, vars) {
-  const filePath = join22(templatesDir, `${templateName}.md`);
+  const filePath = join24(templatesDir, `${templateName}.md`);
   let content;
-  if (existsSync22(filePath)) {
-    content = readFileSync22(filePath, "utf-8");
+  if (existsSync25(filePath)) {
+    content = readFileSync24(filePath, "utf-8");
   } else if (DEFAULT_TEMPLATES[templateName]) {
     content = DEFAULT_TEMPLATES[templateName];
   } else {
@@ -86733,8 +87578,8 @@ category: resources
 });
 
 // src/core/note-linker.ts
-import { join as join23 } from "path";
-import { existsSync as existsSync23, readFileSync as readFileSync23, readdirSync as readdirSync7, statSync as statSync12 } from "fs";
+import { join as join25 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync25, readdirSync as readdirSync7, statSync as statSync12 } from "fs";
 function updateMasterIndex(vaultRootPath) {
   const now = new Date().toISOString().split("T")[0];
   const sections = [
@@ -86756,8 +87601,8 @@ function updateMasterIndex(vaultRootPath) {
     { name: "Patterns", dir: "patterns", emoji: "" }
   ];
   for (const cat of categories) {
-    const dirPath = join23(vaultRootPath, cat.dir);
-    if (!existsSync23(dirPath))
+    const dirPath = join25(vaultRootPath, cat.dir);
+    if (!existsSync26(dirPath))
       continue;
     const files = collectMarkdownFiles(dirPath, vaultRootPath);
     if (files.length === 0 && cat.dir !== "inbox")
@@ -86786,7 +87631,7 @@ function collectMarkdownFiles(dirPath, rootPath) {
   try {
     const entries = readdirSync7(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join23(dirPath, entry.name);
+      const fullPath = join25(dirPath, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectMarkdownFiles(fullPath, rootPath));
       } else if (entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
@@ -86809,7 +87654,7 @@ var exports_wiki = {};
 __export(exports_wiki, {
   wiki: () => wiki
 });
-import { existsSync as existsSync24, statSync as statSync13 } from "fs";
+import { existsSync as existsSync27, statSync as statSync13 } from "fs";
 import { resolve as resolve11 } from "path";
 import { homedir as homedir4 } from "os";
 async function wiki(_cwd, args) {
@@ -86865,7 +87710,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 = existsSync24(targetPath) && statSync13(targetPath).isDirectory();
+  const isExisting = existsSync27(targetPath) && statSync13(targetPath).isDirectory();
   setConfigValue("wiki.path", targetPath);
   ensureVaultStructure();
   seedTemplates(vaultTemplates());
@@ -87083,8 +87928,8 @@ var init_wiki = __esm(() => {
 });
 
 // src/core/note-writer.ts
-import { join as join24 } from "path";
-import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
+import { join as join26 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
 function slugifyTitle(title) {
   return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
 }
@@ -87117,7 +87962,7 @@ function createNote(meta) {
   const now = meta.created || new Date().toISOString();
   const slug = slugifyTitle(meta.title);
   const dir = categoryToDir(meta.category, meta.projectSlug);
-  const filePath = join24(dir, `${slug}.md`);
+  const filePath = join26(dir, `${slug}.md`);
   let content;
   if (meta.template) {
     const rendered = loadTemplate(vaultTemplates(), meta.template, {
@@ -87151,9 +87996,9 @@ ${meta.body}
 }
 function appendToDaily(date, content) {
   const dir = vaultDailyDir();
-  const filePath = join24(dir, `${date}.md`);
-  if (existsSync25(filePath)) {
-    const existing = readFileSync24(filePath, "utf-8");
+  const filePath = join26(dir, `${date}.md`);
+  if (existsSync28(filePath)) {
+    const existing = readFileSync26(filePath, "utf-8");
     const timestamp = new Date().toLocaleTimeString("en-US", {
       hour: "2-digit",
       minute: "2-digit",
@@ -87191,7 +88036,7 @@ ${content}
   return filePath;
 }
 function ingestFile(sourcePath, meta) {
-  const raw = readFileSync24(sourcePath, "utf-8");
+  const raw = readFileSync26(sourcePath, "utf-8");
   const now = new Date().toISOString();
   const headingMatch = raw.match(/^#\s+(.+)$/m);
   const title = headingMatch?.[1] ?? sourcePath.split("/").pop().replace(/\.md$/, "");
@@ -87229,7 +88074,7 @@ ${raw}`;
   }
   const slug = slugifyTitle(title);
   const dir = categoryToDir(meta.category, meta.projectSlug);
-  const filePath = join24(dir, `${slug}.md`);
+  const filePath = join26(dir, `${slug}.md`);
   atomicWriteText(filePath, content);
   return { filePath, content };
 }
@@ -87245,7 +88090,7 @@ __export(exports_note, {
   note: () => note
 });
 import { resolve as resolve12 } from "path";
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync27 } from "fs";
 async function note(cwd, args) {
   if (!isWikiEnabled()) {
     console.error("[mink] wiki feature is disabled");
@@ -87270,13 +88115,13 @@ async function note(cwd, args) {
     const date = new Date().toISOString().split("T")[0];
     const content = parsed.positional || parsed.body || "";
     const filePath = appendToDaily(date, content);
-    updateVaultIndexForFile(filePath, readFileSync25(filePath, "utf-8"));
+    updateVaultIndexForFile(filePath, readFileSync27(filePath, "utf-8"));
     console.log(`[mink] daily note: ${filePath}`);
     return;
   }
   if (parsed.file) {
     const sourcePath = resolve12(cwd, parsed.file);
-    if (!existsSync26(sourcePath)) {
+    if (!existsSync29(sourcePath)) {
       console.error(`[mink] file not found: ${sourcePath}`);
       process.exit(1);
     }
@@ -87437,29 +88282,29 @@ var exports_skill = {};
 __export(exports_skill, {
   skill: () => skill
 });
-import { join as join25, resolve as resolve13, dirname as dirname11 } from "path";
+import { join as join27, resolve as resolve13, dirname as dirname13 } from "path";
 import { homedir as homedir5 } from "os";
 import {
-  existsSync as existsSync27,
-  mkdirSync as mkdirSync10,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync13,
   copyFileSync,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   readdirSync as readdirSync8,
   rmSync,
   symlinkSync as symlinkSync2,
   lstatSync as lstatSync2
 } from "fs";
 function getSkillsSourceDir() {
-  return resolve13(dirname11(new URL(import.meta.url).pathname), "../../skills");
+  return resolve13(dirname13(new URL(import.meta.url).pathname), "../../skills");
 }
 function getAvailableSkills() {
   const dir = getSkillsSourceDir();
-  if (!existsSync27(dir))
+  if (!existsSync30(dir))
     return [];
-  return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync27(join25(dir, d.name, "SKILL.md"))).map((d) => d.name);
+  return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && existsSync30(join27(dir, d.name, "SKILL.md"))).map((d) => d.name);
 }
 function isInstalled(skillName) {
-  return existsSync27(join25(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
+  return existsSync30(join27(AGENTS_SKILLS_DIR, skillName, "SKILL.md"));
 }
 async function skill(args) {
   const sub = args[0];
@@ -87493,28 +88338,28 @@ function skillInstall(name) {
     console.error("  Expected skills at: " + sourceDir);
     return;
   }
-  mkdirSync10(AGENTS_SKILLS_DIR, { recursive: true });
+  mkdirSync13(AGENTS_SKILLS_DIR, { recursive: true });
   for (const skillName of skills) {
-    const srcDir = join25(sourceDir, skillName);
-    const srcFile = join25(srcDir, "SKILL.md");
-    const destDir = join25(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync27(srcFile)) {
+    const srcDir = join27(sourceDir, skillName);
+    const srcFile = join27(srcDir, "SKILL.md");
+    const destDir = join27(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync30(srcFile)) {
       console.error(`[mink] skill not found: ${skillName}`);
       continue;
     }
-    mkdirSync10(destDir, { recursive: true });
+    mkdirSync13(destDir, { recursive: true });
     copyDirRecursive(srcDir, destDir);
-    mkdirSync10(CLAUDE_SKILLS_DIR, { recursive: true });
-    const symlink = join25(CLAUDE_SKILLS_DIR, skillName);
+    mkdirSync13(CLAUDE_SKILLS_DIR, { recursive: true });
+    const symlink = join27(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync27(symlink)) {
+      if (existsSync30(symlink)) {
         if (lstatSync2(symlink).isSymbolicLink() || lstatSync2(symlink).isFile()) {
-          unlinkSync3(symlink);
+          unlinkSync4(symlink);
         } else {
           rmSync(symlink, { recursive: true, force: true });
         }
       }
-      const relativeTarget = join25("..", "..", ".agents", "skills", skillName);
+      const relativeTarget = join27("..", "..", ".agents", "skills", skillName);
       symlinkSync2(relativeTarget, symlink);
     } catch {}
     console.log(`[mink] installed: ${skillName} -> ${destDir}`);
@@ -87525,16 +88370,16 @@ function skillInstall(name) {
 function skillUninstall(name) {
   const skills = name ? [name] : getAvailableSkills();
   for (const skillName of skills) {
-    const destDir = join25(AGENTS_SKILLS_DIR, skillName);
-    if (!existsSync27(destDir)) {
+    const destDir = join27(AGENTS_SKILLS_DIR, skillName);
+    if (!existsSync30(destDir)) {
       console.log(`[mink] not installed: ${skillName}`);
       continue;
     }
     rmSync(destDir, { recursive: true, force: true });
-    const symlink = join25(CLAUDE_SKILLS_DIR, skillName);
+    const symlink = join27(CLAUDE_SKILLS_DIR, skillName);
     try {
-      if (existsSync27(symlink))
-        unlinkSync3(symlink);
+      if (existsSync30(symlink))
+        unlinkSync4(symlink);
     } catch {}
     console.log(`[mink] uninstalled: ${skillName}`);
   }
@@ -87548,7 +88393,7 @@ function skillList() {
   if (installed.length > 0) {
     console.log("  Installed:");
     for (const s of installed) {
-      console.log(`    ${s}  (${join25(AGENTS_SKILLS_DIR, s)})`);
+      console.log(`    ${s}  (${join27(AGENTS_SKILLS_DIR, s)})`);
     }
   }
   if (notInstalled.length > 0) {
@@ -87567,10 +88412,10 @@ function skillList() {
 function copyDirRecursive(src, dest) {
   const entries = readdirSync8(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = join25(src, entry.name);
-    const destPath = join25(dest, entry.name);
+    const srcPath = join27(src, entry.name);
+    const destPath = join27(dest, entry.name);
     if (entry.isDirectory()) {
-      mkdirSync10(destPath, { recursive: true });
+      mkdirSync13(destPath, { recursive: true });
       copyDirRecursive(srcPath, destPath);
     } else {
       copyFileSync(srcPath, destPath);
@@ -87579,8 +88424,8 @@ function copyDirRecursive(src, dest) {
 }
 var AGENTS_SKILLS_DIR, CLAUDE_SKILLS_DIR;
 var init_skill = __esm(() => {
-  AGENTS_SKILLS_DIR = join25(homedir5(), ".agents", "skills");
-  CLAUDE_SKILLS_DIR = join25(homedir5(), ".claude", "skills");
+  AGENTS_SKILLS_DIR = join27(homedir5(), ".agents", "skills");
+  CLAUDE_SKILLS_DIR = join27(homedir5(), ".claude", "skills");
 });
 
 // src/commands/sync.ts
@@ -87672,6 +88517,70 @@ var init_sync3 = __esm(() => {
   init_global_config();
 });
 
+// src/commands/device.ts
+var exports_device2 = {};
+__export(exports_device2, {
+  device: () => device
+});
+import { hostname as hostname2, platform as platform2 } from "os";
+function device(args) {
+  const sub = args[0] ?? "status";
+  switch (sub) {
+    case "status": {
+      const id = getOrCreateDeviceId();
+      const devices = listDevices();
+      const current = devices.find((d) => d.id === id);
+      console.log("[mink] device info:");
+      console.log(`  id:        ${id}`);
+      console.log(`  name:      ${current?.name ?? hostname2()}`);
+      console.log(`  hostname:  ${hostname2()}`);
+      console.log(`  platform:  ${platform2()}`);
+      if (current?.firstSeen) {
+        console.log(`  first seen: ${current.firstSeen}`);
+      }
+      if (current?.lastSeen) {
+        console.log(`  last seen:  ${current.lastSeen}`);
+      }
+      break;
+    }
+    case "list": {
+      const devices = listDevices();
+      const currentId = getOrCreateDeviceId();
+      if (devices.length === 0) {
+        console.log("[mink] no devices registered yet");
+        return;
+      }
+      console.log("[mink] registered devices:");
+      for (const d of devices) {
+        const marker = d.id === currentId ? " (this device)" : "";
+        console.log(`  ${d.name}${marker}`);
+        console.log(`    id:       ${d.id}`);
+        console.log(`    hostname: ${d.hostname}`);
+        console.log(`    platform: ${d.platform}`);
+        console.log(`    last seen: ${d.lastSeen}`);
+      }
+      break;
+    }
+    case "rename": {
+      const name = args.slice(1).join(" ");
+      if (!name) {
+        console.error("Usage: mink device rename <name>");
+        process.exit(1);
+      }
+      setDeviceName(name);
+      console.log(`[mink] device renamed to "${name}"`);
+      break;
+    }
+    default:
+      console.error(`[mink] unknown device subcommand: ${sub}`);
+      console.error("Usage: mink device [status|list|rename <name>]");
+      process.exit(1);
+  }
+}
+var init_device2 = __esm(() => {
+  init_device();
+});
+
 // src/commands/bug-search.ts
 var exports_bug_search = {};
 __export(exports_bug_search, {
@@ -87713,8 +88622,16 @@ init_fs_utils();
 init_action_log();
 init_vault();
 init_note_index();
-import { mkdirSync as mkdirSync3 } from "fs";
+import { mkdirSync as mkdirSync4 } from "fs";
 function sessionStart(cwd) {
+  try {
+    const { migrateConfigIfNeeded: migrateConfigIfNeeded2 } = (init_global_config(), __toCommonJS(exports_global_config));
+    migrateConfigIfNeeded2();
+  } catch {}
+  try {
+    const { updateDeviceHeartbeat: updateDeviceHeartbeat2 } = (init_device(), __toCommonJS(exports_device));
+    updateDeviceHeartbeat2();
+  } catch {}
   try {
     const { isSyncInitialized: isSyncInitialized2, syncPull: syncPull2 } = (init_sync(), __toCommonJS(exports_sync));
     if (isSyncInitialized2()) {
@@ -87722,7 +88639,7 @@ function sessionStart(cwd) {
     }
   } catch {}
   const dir = projectDir(cwd);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   const state = createSessionState();
   atomicWriteJson(sessionPath(cwd), state);
   try {
@@ -87751,8 +88668,8 @@ init_token_ledger();
 init_bug_memory();
 init_action_log();
 init_vault();
-import { statSync as statSync2, existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { statSync as statSync2, existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
 function hasActivity(state) {
   return Object.keys(state.reads).length > 0 || state.writes.length > 0;
 }
@@ -87783,7 +88700,7 @@ function sessionStop(sessionFile, finalizer, onReminder = (msg) => console.error
   }
   const state = raw;
   state.stopCount++;
-  const projDir = dirname2(sessionFile);
+  const projDir = dirname3(sessionFile);
   const effectiveFinalizer = finalizer ?? createLedgerFinalizer(projDir);
   if (hasActivity(state)) {
     const summary = buildSummary(state);
@@ -87816,7 +88733,7 @@ function sessionStop(sessionFile, finalizer, onReminder = (msg) => console.error
   }
   const memoryPath = join6(projDir, "learning-memory.md");
   const cfgPath = join6(projDir, "config.json");
-  if (existsSync5(memoryPath)) {
+  if (existsSync6(memoryPath)) {
     reflect(projDir, memoryPath, cfgPath);
   }
   if (isLearningMemoryStale(memoryPath)) {
@@ -87867,8 +88784,8 @@ function writeSessionToWiki(state, projDir) {
     }
   }
   entry.push("");
-  if (existsSync5(sessionFile)) {
-    const existing = readFileSync6(sessionFile, "utf-8");
+  if (existsSync6(sessionFile)) {
+    const existing = readFileSync7(sessionFile, "utf-8");
     atomicWriteText(sessionFile, existing.trimEnd() + `
 ` + entry.join(`
 `));
@@ -87963,6 +88880,11 @@ switch (command2) {
     await daemon2(cwd, process.argv.slice(3));
     break;
   }
+  case "channel": {
+    const { channel: channel2 } = await Promise.resolve().then(() => (init_channel(), exports_channel));
+    await channel2(process.argv.slice(3));
+    break;
+  }
   case "config": {
     const { config: config3 } = await Promise.resolve().then(() => (init_config2(), exports_config));
     await config3(process.argv.slice(3));
@@ -88008,6 +88930,11 @@ switch (command2) {
     await sync2(process.argv.slice(3));
     break;
   }
+  case "device": {
+    const { device: device2 } = await Promise.resolve().then(() => (init_device2(), exports_device2));
+    device2(process.argv.slice(3));
+    break;
+  }
   case "bug-search": {
     const { bugSearch: bugSearch2 } = await Promise.resolve().then(() => (init_bug_search(), exports_bug_search));
     bugSearch2(cwd, process.argv.slice(3).join(" "));
@@ -88027,11 +88954,11 @@ switch (command2) {
   case "version":
   case "--version":
   case "-v": {
-    const { resolve: resolve14, dirname: dirname12 } = await import("path");
-    const cliPath = resolve14(dirname12(new URL(import.meta.url).pathname));
-    const { readFileSync: readFileSync26 } = await import("fs");
+    const { resolve: resolve14, dirname: dirname14 } = await import("path");
+    const cliPath = resolve14(dirname14(new URL(import.meta.url).pathname));
+    const { readFileSync: readFileSync28 } = await import("fs");
     try {
-      const pkg = JSON.parse(readFileSync26(resolve14(cliPath, "../package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync28(resolve14(cliPath, "../package.json"), "utf-8"));
       console.log(`mink ${pkg.version}`);
     } catch {
       console.log("mink (unknown version)");
@@ -88060,7 +88987,10 @@ switch (command2) {
     console.log("  note search <term>      Full-text search across the vault");
     console.log("  skill install           Install /mink:note skill for Claude Code");
     console.log();
-    console.log("Sync:");
+    console.log("Devices & Sync:");
+    console.log("  device                  Show current device info");
+    console.log("  device list             List all registered devices");
+    console.log("  device rename <name>    Set a friendly name for this device");
     console.log("  sync                    Full manual sync (pull then push)");
     console.log("  sync init <remote-url>  Connect ~/.mink to a git remote for cross-device sync");
     console.log("  sync status             Show sync state (remote, last sync, pending changes)");
@@ -88069,6 +88999,13 @@ switch (command2) {
     console.log("  sync pause / resume     Temporarily disable/enable auto-sync");
     console.log("  sync disconnect         Remove git tracking (data preserved)");
     console.log();
+    console.log("Channels (conversational companion):");
+    console.log("  channel setup discord --token <t>  Configure Discord bot token");
+    console.log("  channel start [platform]           Launch a Claude Code session with --channels in the vault");
+    console.log("  channel stop                       Stop the channel session");
+    console.log("  channel status                     Show channel status");
+    console.log("  channel logs                       Tail channel log");
+    console.log();
     console.log("Automation & Analysis:");
     console.log("  dashboard [--port=N]    Open the real-time web dashboard");
     console.log("  daemon <cmd>            Manage the background daemon (start|stop|restart|logs)");