@hasna/machines 0.0.2 → 0.0.4

package/dist/index.js

@@ -6515,6 +6515,8 @@ var require_dist2 = __commonJS((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = formatsPlugin;
 });
+// src/cross-project-types.ts
+var CROSSREFS_KEY = "_crossRefs";
 // src/paths.ts
 import { existsSync, mkdirSync } from "fs";
 import { dirname, join, resolve } from "path";
@@ -6533,6 +6535,12 @@ function getManifestPath() {
 function getNotificationsPath() {
   return process.env["HASNA_MACHINES_NOTIFICATIONS_PATH"] || join(getDataDir(), "notifications.json");
 }
+function getClipboardKeyPath() {
+  return process.env["HASNA_MACHINES_CLIPBOARD_KEY_PATH"] || join(getDataDir(), "clipboard.key");
+}
+function getClipboardHistoryPath() {
+  return process.env["HASNA_MACHINES_CLIPBOARD_HISTORY_PATH"] || join(getDataDir(), "clipboard-history.json");
+}
 function ensureParentDir(filePath) {
   if (filePath === ":memory:")
     return;
@@ -20335,17 +20343,95 @@ function runBackup(bucket, prefix = "machines", options = {}) {
     executed
   };
 }
+// src/remote.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/commands/ssh.ts
+import { spawnSync } from "child_process";
+function envReachableHosts() {
+  const raw = process.env["HASNA_MACHINES_REACHABLE_HOSTS"];
+  return new Set((raw || "").split(",").map((value) => value.trim()).filter(Boolean));
+}
+function isReachable(host) {
+  const overrides = envReachableHosts();
+  if (overrides.size > 0) {
+    return overrides.has(host);
+  }
+  const probe = spawnSync("bash", ["-lc", `getent hosts ${host} >/dev/null 2>&1 || ping -c 1 -W 1 ${host} >/dev/null 2>&1`], {
+    stdio: "ignore"
+  });
+  return probe.status === 0;
+}
+function resolveSshTarget(machineId) {
+  const machine = getManifestMachine(machineId);
+  if (!machine) {
+    throw new Error(`Machine not found in manifest: ${machineId}`);
+  }
+  const current = detectCurrentMachineManifest();
+  if (machine.id === current.id) {
+    return {
+      machineId,
+      target: "localhost",
+      route: "local"
+    };
+  }
+  const lanTarget = machine.sshAddress || machine.hostname || machine.id;
+  const tailscaleTarget = machine.tailscaleName || machine.hostname || machine.id;
+  const route = isReachable(lanTarget) ? "lan" : "tailscale";
+  return {
+    machineId,
+    target: route === "lan" ? lanTarget : tailscaleTarget,
+    route
+  };
+}
+function buildSshCommand(machineId, remoteCommand) {
+  const resolved = resolveSshTarget(machineId);
+  return remoteCommand ? `ssh ${resolved.target} ${JSON.stringify(remoteCommand)}` : `ssh ${resolved.target}`;
+}
+
+// src/remote.ts
+function runMachineCommand(machineId, command) {
+  const localMachineId = getLocalMachineId();
+  const isLocal = machineId === localMachineId;
+  const route = isLocal ? "local" : resolveSshTarget(machineId).route;
+  const shellCommand = isLocal ? command : buildSshCommand(machineId, command);
+  const result = spawnSync2("bash", ["-lc", shellCommand], {
+    encoding: "utf8",
+    env: process.env
+  });
+  return {
+    machineId,
+    source: route,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    exitCode: result.status ?? 1
+  };
+}
+
 // src/commands/apps.ts
 function getPackageName(app) {
   return app.packageName || app.name;
 }
+function getAppManager(machine, app) {
+  if (app.manager)
+    return app.manager;
+  if (machine.platform === "macos")
+    return "brew";
+  if (machine.platform === "windows")
+    return "winget";
+  return "apt";
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function buildAppCommand(machine, app) {
   const packageName = getPackageName(app);
-  if (app.manager === "custom") {
+  const manager = getAppManager(machine, app);
+  if (manager === "custom") {
     return packageName;
   }
   if (machine.platform === "macos") {
-    if (app.manager === "cask") {
+    if (manager === "cask") {
       return `brew install --cask ${packageName}`;
     }
     return `brew install ${packageName}`;
@@ -20355,18 +20441,48 @@ function buildAppCommand(machine, app) {
   }
   return `sudo apt-get install -y ${packageName}`;
 }
+function buildAppProbeCommand(machine, app) {
+  const packageName = shellQuote(getPackageName(app));
+  const manager = getAppManager(machine, app);
+  if (manager === "custom") {
+    return `if command -v ${packageName} >/dev/null 2>&1; then printf 'installed=1\\nversion=custom\\n'; else printf 'installed=0\\n'; fi`;
+  }
+  if (machine.platform === "macos") {
+    if (manager === "cask") {
+      return `if brew list --cask ${packageName} >/dev/null 2>&1; then printf 'installed=1\\nversion=installed\\n'; else printf 'installed=0\\n'; fi`;
+    }
+    return `if brew list --versions ${packageName} >/dev/null 2>&1; then printf 'installed=1\\nversion='; brew list --versions ${packageName} | awk '{print $2}'; printf '\\n'; else printf 'installed=0\\n'; fi`;
+  }
+  if (machine.platform === "windows") {
+    return `if winget list --id ${packageName} --exact >/dev/null 2>&1; then printf 'installed=1\\nversion=installed\\n'; else printf 'installed=0\\n'; fi`;
+  }
+  return `if dpkg-query -W -f='${"${Version}"}' ${packageName} >/tmp/machines-app-version 2>/dev/null; then printf 'installed=1\\nversion='; cat /tmp/machines-app-version; printf '\\n'; rm -f /tmp/machines-app-version; else printf 'installed=0\\n'; fi`;
+}
 function buildAppSteps(machine) {
   return (machine.apps || []).map((app) => ({
     id: `app-${app.name}`,
     title: `Install ${app.name} on ${machine.id}`,
     command: buildAppCommand(machine, app),
-    manager: app.manager === "custom" ? "custom" : machine.platform === "macos" ? "brew" : machine.platform === "windows" ? "custom" : "apt",
+    manager: getAppManager(machine, app) === "custom" ? "custom" : machine.platform === "macos" ? "brew" : machine.platform === "windows" ? "custom" : "apt",
     privileged: machine.platform === "linux"
   }));
 }
 function resolveMachine(machineId) {
   return (machineId ? getManifestMachine(machineId) : null) || detectCurrentMachineManifest();
 }
+function parseProbeOutput(app, machine, stdout) {
+  const lines = stdout.trim().split(`
+`).filter(Boolean);
+  const installedLine = lines.find((line) => line.startsWith("installed="));
+  const versionLine = lines.find((line) => line.startsWith("version="));
+  return {
+    name: app.name,
+    packageName: getPackageName(app),
+    manager: getAppManager(machine, app),
+    installed: installedLine === "installed=1",
+    version: versionLine?.slice("version=".length) || undefined
+  };
+}
 function listApps(machineId) {
   const machine = resolveMachine(machineId);
   return {
@@ -20383,6 +20499,26 @@ function buildAppsPlan(machineId) {
     executed: 0
   };
 }
+function getAppsStatus(machineId) {
+  const machine = resolveMachine(machineId);
+  const apps = (machine.apps || []).map((app) => {
+    const probe = runMachineCommand(machine.id, buildAppProbeCommand(machine, app));
+    return parseProbeOutput(app, machine, probe.stdout);
+  });
+  return {
+    machineId: machine.id,
+    source: apps.length > 0 ? runMachineCommand(machine.id, "true").source : machine.id === detectCurrentMachineManifest().id ? "local" : runMachineCommand(machine.id, "true").source,
+    apps
+  };
+}
+function diffApps(machineId) {
+  const status = getAppsStatus(machineId);
+  return {
+    ...status,
+    missing: status.apps.filter((app) => !app.installed).map((app) => app.name),
+    installed: status.apps.filter((app) => app.installed).map((app) => app.name)
+  };
+}
 function runAppsInstall(machineId, options = {}) {
   const plan = buildAppsPlan(machineId);
   if (!options.apply)
@@ -20529,6 +20665,58 @@ function renderDomainMapping(domain) {
     keyPath: join8(getDataDir(), "certs", `${entry.domain}-key.pem`)
   };
 }
+// src/commands/doctor.ts
+function makeCheck(id, status, summary, detail) {
+  return { id, status, summary, detail };
+}
+function parseKeyValueOutput(stdout) {
+  return Object.fromEntries(stdout.trim().split(`
+`).map((line) => line.split("=")).filter((parts) => parts.length === 2).map(([key, value]) => [key, value]));
+}
+function buildDoctorCommand() {
+  return [
+    'data_dir="${HASNA_MACHINES_DIR:-$HOME/.hasna/machines}"',
+    'manifest_path="${HASNA_MACHINES_MANIFEST_PATH:-$data_dir/machines.json}"',
+    'db_path="${HASNA_MACHINES_DB_PATH:-$data_dir/machines.db}"',
+    'notifications_path="${HASNA_MACHINES_NOTIFICATIONS_PATH:-$data_dir/notifications.json}"',
+    `printf 'manifest_path=%s\\n' "$manifest_path"`,
+    `printf 'db_path=%s\\n' "$db_path"`,
+    `printf 'notifications_path=%s\\n' "$notifications_path"`,
+    `printf 'manifest_exists=%s\\n' "$(test -e "$manifest_path" && printf yes || printf no)"`,
+    `printf 'db_exists=%s\\n' "$(test -e "$db_path" && printf yes || printf no)"`,
+    `printf 'notifications_exists=%s\\n' "$(test -e "$notifications_path" && printf yes || printf no)"`,
+    `printf 'bun=%s\\n' "$(bun --version 2>/dev/null || printf missing)"`,
+    `printf 'ssh=%s\\n' "$(command -v ssh >/dev/null 2>&1 && printf ok || printf missing)"`,
+    `printf 'machines=%s\\n' "$(command -v machines 2>/dev/null || printf missing)"`,
+    `printf 'machines_agent=%s\\n' "$(command -v machines-agent 2>/dev/null || printf missing)"`,
+    `printf 'machines_mcp=%s\\n' "$(command -v machines-mcp 2>/dev/null || printf missing)"`
+  ].join("; ");
+}
+function runDoctor(machineId = getLocalMachineId()) {
+  const manifest = readManifest();
+  const commandChecks = runMachineCommand(machineId, buildDoctorCommand());
+  const details = parseKeyValueOutput(commandChecks.stdout);
+  const machineInManifest = manifest.machines.find((machine) => machine.id === machineId);
+  const checks = [
+    makeCheck("manifest-entry", machineInManifest ? "ok" : "warn", machineInManifest ? "Machine exists in manifest" : "Machine missing from manifest", machineInManifest ? JSON.stringify(machineInManifest) : `No manifest entry for ${machineId}`),
+    makeCheck("manifest-path", details["manifest_exists"] === "yes" ? "ok" : "warn", "Manifest path check", `${details["manifest_path"] || "unknown"} ${details["manifest_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck("db-path", details["db_exists"] === "yes" ? "ok" : "warn", "DB path check", `${details["db_path"] || "unknown"} ${details["db_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck("notifications-path", details["notifications_exists"] === "yes" ? "ok" : "warn", "Notifications path check", `${details["notifications_path"] || "unknown"} ${details["notifications_exists"] === "yes" ? "exists" : "missing"}`),
+    makeCheck("bun", details["bun"] && details["bun"] !== "missing" ? "ok" : "fail", "Bun availability", details["bun"] || "missing"),
+    makeCheck("machines-cli", details["machines"] && details["machines"] !== "missing" ? "ok" : "warn", "machines CLI availability", details["machines"] || "missing"),
+    makeCheck("machines-agent-cli", details["machines_agent"] && details["machines_agent"] !== "missing" ? "ok" : "warn", "machines-agent availability", details["machines_agent"] || "missing"),
+    makeCheck("machines-mcp-cli", details["machines_mcp"] && details["machines_mcp"] !== "missing" ? "ok" : "warn", "machines-mcp availability", details["machines_mcp"] || "missing"),
+    makeCheck("ssh", details["ssh"] === "ok" ? "ok" : "warn", "SSH availability", details["ssh"] || "missing")
+  ];
+  return {
+    machineId,
+    source: commandChecks.source,
+    manifestPath: details["manifest_path"],
+    dbPath: details["db_path"],
+    notificationsPath: details["notifications_path"],
+    checks
+  };
+}
 // src/commands/manifest.ts
 function manifestInit() {
   return writeManifest(getDefaultManifest(), getManifestPath());
@@ -20608,6 +20796,13 @@ var AI_CLI_PACKAGES = {
   codex: "@openai/codex",
   gemini: "@google/gemini-cli"
 };
+function getToolBinary(tool) {
+  if (tool === "claude")
+    return process.env["HASNA_MACHINES_CLAUDE_BINARY"] || "claude";
+  if (tool === "codex")
+    return process.env["HASNA_MACHINES_CODEX_BINARY"] || "codex";
+  return process.env["HASNA_MACHINES_GEMINI_BINARY"] || "gemini";
+}
 function normalizeTools(tools) {
   if (!tools || tools.length === 0) {
     return ["claude", "codex", "gemini"];
@@ -20627,8 +20822,27 @@ function buildInstallSteps(machine, tools) {
     manager: "bun"
   }));
 }
+function resolveMachine2(machineId) {
+  return (machineId ? getManifestMachine(machineId) : null) || detectCurrentMachineManifest();
+}
+function buildProbeCommand(tool) {
+  const binary = getToolBinary(tool);
+  return `if command -v ${binary} >/dev/null 2>&1; then printf 'installed=1\\nversion='; ${binary} --version 2>/dev/null | head -n 1; printf '\\n'; else printf 'installed=0\\n'; fi`;
+}
+function parseProbe(tool, stdout) {
+  const lines = stdout.trim().split(`
+`).filter(Boolean);
+  const installedLine = lines.find((line) => line.startsWith("installed="));
+  const versionLine = lines.find((line) => line.startsWith("version="));
+  return {
+    tool,
+    packageName: AI_CLI_PACKAGES[tool],
+    installed: installedLine === "installed=1",
+    version: versionLine?.slice("version=".length) || undefined
+  };
+}
 function buildClaudeInstallPlan(machineId, tools) {
-  const machine = (machineId ? getManifestMachine(machineId) : null) || detectCurrentMachineManifest();
+  const machine = resolveMachine2(machineId);
   return {
     machineId: machine.id,
     mode: "plan",
@@ -20636,6 +20850,24 @@ function buildClaudeInstallPlan(machineId, tools) {
     executed: 0
   };
 }
+function getClaudeCliStatus(machineId, tools) {
+  const machine = resolveMachine2(machineId);
+  const normalizedTools = normalizeTools(tools);
+  const route = runMachineCommand(machine.id, "true").source;
+  return {
+    machineId: machine.id,
+    source: route,
+    tools: normalizedTools.map((tool) => parseProbe(tool, runMachineCommand(machine.id, buildProbeCommand(tool)).stdout))
+  };
+}
+function diffClaudeCli(machineId, tools) {
+  const status = getClaudeCliStatus(machineId, tools);
+  return {
+    ...status,
+    missing: status.tools.filter((tool) => !tool.installed).map((tool) => tool.tool),
+    installed: status.tools.filter((tool) => tool.installed).map((tool) => tool.tool)
+  };
+}
 function runClaudeInstall(machineId, tools, options = {}) {
   const plan = buildClaudeInstallPlan(machineId, tools);
   if (!options.apply)
@@ -20746,6 +20978,138 @@ var notificationConfigSchema = exports_external2.object({
 function sortChannels(channels) {
   return [...channels].sort((left, right) => left.id.localeCompare(right.id));
 }
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function hasCommand(binary) {
+  const result = Bun.spawnSync(["bash", "-lc", `command -v ${binary} >/dev/null 2>&1`], {
+    stdout: "ignore",
+    stderr: "ignore",
+    env: process.env
+  });
+  return result.exitCode === 0;
+}
+function buildNotificationPreview(channel, event, message) {
+  if (channel.type === "email") {
+    return `send email to ${channel.target}: [${event}] ${message}`;
+  }
+  if (channel.type === "webhook") {
+    return `POST ${channel.target} with payload {"event":"${event}","message":"${message}"}`;
+  }
+  return `${channel.target} --event ${event} --message ${JSON.stringify(message)}`;
+}
+async function dispatchEmail(channel, event, message) {
+  const subject = `[${event}] machines notification`;
+  const body = `To: ${channel.target}
+Subject: ${subject}
+Content-Type: text/plain; charset=utf-8
+
+${message}
+`;
+  if (hasCommand("sendmail")) {
+    const result = Bun.spawnSync(["bash", "-lc", "sendmail -t"], {
+      stdin: new TextEncoder().encode(body),
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.toString().trim() || `sendmail exited with ${result.exitCode}`);
+    }
+    return {
+      channelId: channel.id,
+      event,
+      delivered: true,
+      transport: channel.type,
+      detail: `Delivered via sendmail to ${channel.target}`
+    };
+  }
+  if (hasCommand("mail")) {
+    const command = `printf %s ${shellQuote2(message)} | mail -s ${shellQuote2(subject)} ${shellQuote2(channel.target)}`;
+    const result = Bun.spawnSync(["bash", "-lc", command], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr.toString().trim() || `mail exited with ${result.exitCode}`);
+    }
+    return {
+      channelId: channel.id,
+      event,
+      delivered: true,
+      transport: channel.type,
+      detail: `Delivered via mail to ${channel.target}`
+    };
+  }
+  throw new Error("No local email transport available. Install sendmail or mail.");
+}
+async function dispatchWebhook(channel, event, message) {
+  const response = await fetch(channel.target, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      channelId: channel.id,
+      event,
+      message,
+      sentAt: new Date().toISOString()
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Webhook responded ${response.status}: ${text || response.statusText}`);
+  }
+  return {
+    channelId: channel.id,
+    event,
+    delivered: true,
+    transport: channel.type,
+    detail: `Webhook accepted with HTTP ${response.status}`
+  };
+}
+async function dispatchCommand(channel, event, message) {
+  const result = Bun.spawnSync(["bash", "-lc", channel.target], {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      HASNA_MACHINES_NOTIFICATION_CHANNEL: channel.id,
+      HASNA_MACHINES_NOTIFICATION_EVENT: event,
+      HASNA_MACHINES_NOTIFICATION_MESSAGE: message
+    }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.toString().trim() || `command exited with ${result.exitCode}`);
+  }
+  const stdout = result.stdout.toString().trim();
+  return {
+    channelId: channel.id,
+    event,
+    delivered: true,
+    transport: channel.type,
+    detail: stdout || "Command completed successfully"
+  };
+}
+async function dispatchChannel(channel, event, message) {
+  if (!channel.enabled) {
+    return {
+      channelId: channel.id,
+      event,
+      delivered: false,
+      transport: channel.type,
+      detail: "Channel is disabled"
+    };
+  }
+  if (channel.type === "email") {
+    return dispatchEmail(channel, event, message);
+  }
+  if (channel.type === "webhook") {
+    return dispatchWebhook(channel, event, message);
+  }
+  return dispatchCommand(channel, event, message);
+}
 function getDefaultNotificationConfig() {
   return {
     version: 1,
@@ -20789,16 +21153,34 @@ function removeNotificationChannel(channelId) {
     channels: config.channels.filter((channel) => channel.id !== channelId)
   });
 }
-function buildNotificationPreview(channel, event, message) {
-  if (channel.type === "email") {
-    return `send email to ${channel.target}: [${event}] ${message}`;
-  }
-  if (channel.type === "webhook") {
-    return `POST ${channel.target} with payload {"event":"${event}","message":"${message}"}`;
+async function dispatchNotificationEvent(event, message, options = {}) {
+  const channels = readNotificationConfig().channels.filter((channel) => {
+    if (options.channelId && channel.id !== options.channelId) {
+      return false;
+    }
+    return channel.events.includes(event) || event === "manual.test";
+  });
+  const deliveries = [];
+  for (const channel of channels) {
+    try {
+      deliveries.push(await dispatchChannel(channel, event, message));
+    } catch (error) {
+      deliveries.push({
+        channelId: channel.id,
+        event,
+        delivered: false,
+        transport: channel.type,
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
-  return `${channel.target} --event ${event} --message ${JSON.stringify(message)}`;
+  return {
+    event,
+    message,
+    deliveries
+  };
 }
-function testNotificationChannel(channelId, event = "manual.test", message = "machines notification test", options = {}) {
+async function testNotificationChannel(channelId, event = "manual.test", message = "machines notification test", options = {}) {
   const channel = readNotificationConfig().channels.find((entry) => entry.id === channelId);
   if (!channel) {
     throw new Error(`Notification channel not found: ${channelId}`);
@@ -20809,76 +21191,24 @@ function testNotificationChannel(channelId, event = "manual.test", message = "ma
       channelId,
       mode: "plan",
       delivered: false,
-      preview
+      preview,
+      detail: "Preview only"
     };
   }
   if (!options.yes) {
     throw new Error("Notification test execution requires --yes.");
   }
-  if (channel.type === "command") {
-    const result = Bun.spawnSync(["bash", "-lc", preview], {
-      stdout: "pipe",
-      stderr: "pipe",
-      env: process.env
-    });
-    if (result.exitCode !== 0) {
-      throw new Error(`Notification command failed (${channel.id}): ${result.stderr.toString().trim()}`);
-    }
-  }
+  const delivery = await dispatchChannel(channel, event, message);
   return {
     channelId,
     mode: "apply",
-    delivered: channel.enabled,
-    preview
+    delivered: delivery.delivered,
+    preview,
+    detail: delivery.detail
   };
 }
 // src/commands/ports.ts
-import { spawnSync as spawnSync2 } from "child_process";
-
-// src/commands/ssh.ts
-import { spawnSync } from "child_process";
-function envReachableHosts() {
-  const raw = process.env["HASNA_MACHINES_REACHABLE_HOSTS"];
-  return new Set((raw || "").split(",").map((value) => value.trim()).filter(Boolean));
-}
-function isReachable(host) {
-  const overrides = envReachableHosts();
-  if (overrides.size > 0) {
-    return overrides.has(host);
-  }
-  const probe = spawnSync("bash", ["-lc", `getent hosts ${host} >/dev/null 2>&1 || ping -c 1 -W 1 ${host} >/dev/null 2>&1`], {
-    stdio: "ignore"
-  });
-  return probe.status === 0;
-}
-function resolveSshTarget(machineId) {
-  const machine = getManifestMachine(machineId);
-  if (!machine) {
-    throw new Error(`Machine not found in manifest: ${machineId}`);
-  }
-  const current = detectCurrentMachineManifest();
-  if (machine.id === current.id) {
-    return {
-      machineId,
-      target: "localhost",
-      route: "local"
-    };
-  }
-  const lanTarget = machine.sshAddress || machine.hostname || machine.id;
-  const tailscaleTarget = machine.tailscaleName || machine.hostname || machine.id;
-  const route = isReachable(lanTarget) ? "lan" : "tailscale";
-  return {
-    machineId,
-    target: route === "lan" ? lanTarget : tailscaleTarget,
-    route
-  };
-}
-function buildSshCommand(machineId, remoteCommand) {
-  const resolved = resolveSshTarget(machineId);
-  return remoteCommand ? `ssh ${resolved.target} ${JSON.stringify(remoteCommand)}` : `ssh ${resolved.target}`;
-}
-
-// src/commands/ports.ts
+import { spawnSync as spawnSync3 } from "child_process";
 function parseSsOutput(output) {
   return output.trim().split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => {
@@ -20920,7 +21250,7 @@ function listPorts(machineId) {
   const isLocal = targetMachineId === getLocalMachineId();
   const localCommand = "if command -v ss >/dev/null 2>&1; then ss -ltnpH; else lsof -nP -iTCP -sTCP:LISTEN; fi";
   const command = isLocal ? localCommand : buildSshCommand(targetMachineId, localCommand);
-  const result = spawnSync2("bash", ["-lc", command], { encoding: "utf8" });
+  const result = spawnSync3("bash", ["-lc", command], { encoding: "utf8" });
   if (result.status !== 0) {
     throw new Error(result.stderr || `Failed to list ports for ${targetMachineId}`);
   }
@@ -20930,6 +21260,24 @@ function listPorts(machineId) {
     listeners: parsePortOutput(result.stdout, format)
   };
 }
+// src/version.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const here = dirname4(fileURLToPath(import.meta.url));
+    const candidates = [join9(here, "..", "package.json"), join9(here, "..", "..", "package.json")];
+    const pkgPath = candidates.find((candidate) => existsSync8(candidate));
+    if (!pkgPath) {
+      return "0.0.0";
+    }
+    return JSON.parse(readFileSync5(pkgPath, "utf8")).version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
 // src/commands/status.ts
 function getStatus() {
   const manifest = readManifest();
@@ -20973,13 +21321,27 @@ function getServeInfo(options = {}) {
     host,
     port,
     url: `http://${host}:${port}`,
-    routes: ["/", "/health", "/api/status", "/api/manifest", "/api/notifications"]
+    routes: [
+      "/",
+      "/health",
+      "/api/status",
+      "/api/manifest",
+      "/api/notifications",
+      "/api/doctor",
+      "/api/self-test",
+      "/api/apps/status",
+      "/api/apps/diff",
+      "/api/install-claude/status",
+      "/api/install-claude/diff",
+      "/api/notifications/test"
+    ]
   };
 }
 function renderDashboardHtml() {
   const status = getStatus();
   const manifest = manifestList();
   const notifications = listNotificationChannels();
+  const doctor = runDoctor();
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -20995,21 +21357,26 @@ function renderDashboardHtml() {
       .card { background: #121933; border: 1px solid #243057; border-radius: 16px; padding: 20px; }
       .stat { font-size: 32px; font-weight: 700; margin-top: 8px; }
       table { width: 100%; border-collapse: collapse; }
-      th, td { text-align: left; padding: 10px 8px; border-bottom: 1px solid #243057; }
+      th, td { text-align: left; padding: 10px 8px; border-bottom: 1px solid #243057; vertical-align: top; }
       code { color: #9ed0ff; }
       .badge { display: inline-block; border-radius: 999px; padding: 4px 10px; font-size: 12px; }
-      .online { background: #12351f; color: #74f0a7; }
-      .offline { background: #3b1a1a; color: #ff8c8c; }
-      .unknown { background: #2f2b16; color: #ffd76a; }
+      .online, .ok { background: #12351f; color: #74f0a7; }
+      .offline, .fail { background: #3b1a1a; color: #ff8c8c; }
+      .unknown, .warn { background: #2f2b16; color: #ffd76a; }
+      ul { margin: 8px 0 0; padding-left: 18px; }
+      .muted { color: #9fb0d9; }
+      .refresh { font-size: 12px; color: #6b7fa3; margin-left: auto; }
+      .updated { transition: opacity 0.3s; }
     </style>
   </head>
   <body>
     <main>
-      <h1>Machines Dashboard</h1>
+      <h1>Machines Dashboard <span class="refresh" id="last-updated"></span></h1>
       <div class="grid">
         <section class="card"><div>Manifest machines</div><div class="stat">${status.manifestMachineCount}</div></section>
         <section class="card"><div>Heartbeats</div><div class="stat">${status.heartbeatCount}</div></section>
         <section class="card"><div>Notification channels</div><div class="stat">${notifications.channels.length}</div></section>
+        <section class="card"><div>Doctor warnings</div><div class="stat">${doctor.checks.filter((entry) => entry.status !== "ok").length}</div></section>
       </div>
 
       <section class="card" style="margin-top:16px">
@@ -21027,21 +21394,119 @@ function renderDashboardHtml() {
         </table>
       </section>
 
+      <section class="card" style="margin-top:16px">
+        <h2>Doctor</h2>
+        <table>
+          <thead><tr><th>Check</th><th>Status</th><th>Detail</th></tr></thead>
+          <tbody id="doctor-tbody">
+            ${doctor.checks.map((entry) => `<tr>
+              <td>${escapeHtml(entry.summary)}</td>
+              <td><span class="badge ${escapeHtml(entry.status)}">${escapeHtml(entry.status)}</span></td>
+              <td class="muted">${escapeHtml(entry.detail)}</td>
+            </tr>`).join("")}
+          </tbody>
+        </table>
+      </section>
+
+      <section class="card" style="margin-top:16px">
+        <h2>Apps</h2>
+        <p class="muted">Use <code>/api/apps/status</code> for the full app inventory payload.</p>
+      </section>
+
+      <section class="card" style="margin-top:16px">
+        <h2>AI CLIs</h2>
+        <p class="muted">Use <code>/api/install-claude/status</code> for the full CLI inventory payload.</p>
+      </section>
+
+      <section class="card" style="margin-top:16px">
+        <h2>Self Test</h2>
+        <p class="muted">Use <code>/api/self-test</code> for the full smoke-check payload.</p>
+      </section>
+
       <section class="card" style="margin-top:16px">
         <h2>Manifest</h2>
-        <pre>${escapeHtml(JSON.stringify(manifest, null, 2))}</pre>
+        <pre id="manifest-json">${escapeHtml(JSON.stringify(manifest, null, 2))}</pre>
       </section>
     </main>
+    <script>
+      // Auto-refresh dashboard data every 15s
+      const REFRESH_INTERVAL = 15000;
+      async function refreshData() {
+        try {
+          const [statusRes, doctorRes] = await Promise.all([
+            fetch("/api/status"),
+            fetch("/api/doctor"),
+          ]);
+          const status = await statusRes.json();
+          const doctor = await doctorRes.json();
+
+          // Update stat cards
+          const stats = document.querySelectorAll(".stat");
+          if (stats[0]) stats[0].textContent = status.manifestMachineCount;
+          if (stats[1]) stats[1].textContent = status.heartbeatCount;
+
+          // Update machine table
+          const tbody = document.querySelector("tbody");
+          if (tbody && status.machines) {
+            tbody.innerHTML = status.machines
+              .map((m) =>
+                "<tr>" +
+                "<td><code>" + m.machineId + "</code></td>" +
+                "<td>" + (m.platform || "unknown") + "</td>" +
+                '<td><span class="badge ' + m.heartbeatStatus + '">' + m.heartbeatStatus + '</span></td>' +
+                "<td>" + (m.lastHeartbeatAt || "\\u2014") + "</td>" +
+                "</tr>"
+              )
+              .join("");
+          }
+
+          // Update doctor table
+          const doctorTbody = document.getElementById("doctor-tbody");
+          if (doctorTbody && doctor.checks) {
+            doctorTbody.innerHTML = doctor.checks
+              .map((c) =>
+                "<tr>" +
+                "<td>" + c.summary + "</td>" +
+                '<td><span class="badge ' + c.status + '">' + c.status + '</span></td>' +
+                '<td class="muted">' + c.detail + "</td>" +
+                "</tr>"
+              )
+              .join("");
+          }
+
+          // Update timestamp
+          document.getElementById("last-updated").textContent =
+            "updated " + new Date().toLocaleTimeString();
+        } catch (e) {
+          // Silently ignore fetch errors during page unload
+        }
+      }
+      document.getElementById("last-updated").textContent =
+        "updated " + new Date().toLocaleTimeString();
+      setInterval(refreshData, REFRESH_INTERVAL);
+    </script>
   </body>
 </html>`;
 }
+async function parseJsonBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    return {};
+  }
+}
+function jsonError(message, status = 400) {
+  return Response.json({ error: message }, { status });
+}
 function startDashboardServer(options = {}) {
   const info = getServeInfo(options);
   return Bun.serve({
     hostname: info.host,
     port: info.port,
-    fetch(request) {
+    async fetch(request) {
       const url = new URL(request.url);
+      const machineId = url.searchParams.get("machine") || undefined;
+      const tools = url.searchParams.get("tools")?.split(",").map((value) => value.trim()).filter(Boolean);
       if (url.pathname === "/health") {
         return Response.json({ ok: true, ...getServeInfo(options) });
       }
@@ -21054,6 +21519,43 @@ function startDashboardServer(options = {}) {
       if (url.pathname === "/api/notifications") {
         return Response.json(listNotificationChannels());
       }
+      if (url.pathname === "/api/doctor") {
+        return Response.json(runDoctor(machineId));
+      }
+      if (url.pathname === "/api/self-test") {
+        return Response.json(runSelfTest());
+      }
+      if (url.pathname === "/api/apps/status") {
+        return Response.json(getAppsStatus(machineId));
+      }
+      if (url.pathname === "/api/apps/diff") {
+        return Response.json(diffApps(machineId));
+      }
+      if (url.pathname === "/api/install-claude/status") {
+        return Response.json(getClaudeCliStatus(machineId, tools));
+      }
+      if (url.pathname === "/api/install-claude/diff") {
+        return Response.json(diffClaudeCli(machineId, tools));
+      }
+      if (url.pathname === "/api/notifications/test") {
+        if (request.method !== "POST") {
+          return jsonError("Use POST for notification tests.", 405);
+        }
+        const body = await parseJsonBody(request);
+        const channelId = typeof body["channelId"] === "string" ? body["channelId"] : undefined;
+        if (!channelId) {
+          return jsonError("channelId is required.");
+        }
+        const event = typeof body["event"] === "string" ? body["event"] : undefined;
+        const message = typeof body["message"] === "string" ? body["message"] : undefined;
+        const apply = body["apply"] === true;
+        const yes = body["yes"] === true;
+        try {
+          return Response.json(await testNotificationChannel(channelId, event, message, { apply, yes }));
+        } catch (error) {
+          return jsonError(error instanceof Error ? error.message : String(error));
+        }
+      }
       return new Response(renderDashboardHtml(), {
         headers: {
           "content-type": "text/html; charset=utf-8"
@@ -21062,6 +21564,36 @@ function startDashboardServer(options = {}) {
     }
   });
 }
+
+// src/commands/self-test.ts
+function check(id, status, summary, detail) {
+  return { id, status, summary, detail };
+}
+function runSelfTest() {
+  const version = getPackageVersion();
+  const status = getStatus();
+  const doctor = runDoctor();
+  const serveInfo = getServeInfo();
+  const html = renderDashboardHtml();
+  const notifications = listNotificationChannels();
+  const apps = listApps(status.machineId);
+  const appsDiff = diffApps(status.machineId);
+  const cliPlan = buildClaudeInstallPlan(status.machineId);
+  return {
+    machineId: getLocalMachineId(),
+    checks: [
+      check("package-version", version === "0.0.0" ? "fail" : "ok", "Package version resolves", version),
+      check("status", "ok", "Status loads", JSON.stringify({ machines: status.manifestMachineCount, heartbeats: status.heartbeatCount })),
+      check("doctor", doctor.checks.some((entry) => entry.status === "fail") ? "warn" : "ok", "Doctor completed", `${doctor.checks.length} checks`),
+      check("serve-info", "ok", "Dashboard info renders", `${serveInfo.url} routes=${serveInfo.routes.length}`),
+      check("dashboard-html", html.includes("Machines Dashboard") ? "ok" : "fail", "Dashboard HTML renders", html.slice(0, 80)),
+      check("notifications", "ok", "Notifications config loads", `${notifications.channels.length} channels`),
+      check("apps", "ok", "Apps manifest loads", `${apps.apps.length} apps`),
+      check("apps-diff", appsDiff.missing.length === 0 ? "ok" : "warn", "Apps diff computed", `missing=${appsDiff.missing.length} installed=${appsDiff.installed.length}`),
+      check("install-claude-plan", cliPlan.steps.length > 0 ? "ok" : "warn", "Install plan renders", `${cliPlan.steps.length} steps`)
+    ]
+  };
+}
 // src/commands/setup.ts
 function quote3(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -21177,7 +21709,7 @@ function runSetup(machineId, options = {}) {
   return summary;
 }
 // src/commands/sync.ts
-import { existsSync as existsSync8, lstatSync, readFileSync as readFileSync5, symlinkSync, copyFileSync as copyFileSync2 } from "fs";
+import { existsSync as existsSync9, lstatSync, readFileSync as readFileSync6, symlinkSync, copyFileSync as copyFileSync2 } from "fs";
 function quote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -21208,12 +21740,12 @@ function packageInstallCommand(machine, packageName, manager = machine.platform
 function detectPackageActions(machine) {
   return (machine.packages || []).map((pkg, index) => {
     const manager = pkg.manager || (machine.platform === "macos" ? "brew" : "apt");
-    const check = Bun.spawnSync(["bash", "-lc", packageCheckCommand(machine, pkg.name, manager)], {
+    const check2 = Bun.spawnSync(["bash", "-lc", packageCheckCommand(machine, pkg.name, manager)], {
       stdout: "ignore",
       stderr: "ignore",
       env: process.env
     });
-    const installed = check.exitCode === 0;
+    const installed = check2.exitCode === 0;
     return {
       id: `package-${index + 1}`,
       title: `${installed ? "Package present" : "Install package"} ${pkg.name}`,
@@ -21225,15 +21757,15 @@ function detectPackageActions(machine) {
 }
 function detectFileActions(machine) {
   return (machine.files || []).map((file, index) => {
-    const sourceExists = existsSync8(file.source);
-    const targetExists = existsSync8(file.target);
+    const sourceExists = existsSync9(file.source);
+    const targetExists = existsSync9(file.target);
     let status = "missing";
     if (sourceExists && targetExists) {
       if (file.mode === "symlink") {
         status = lstatSync(file.target).isSymbolicLink() ? "ok" : "drifted";
       } else {
-        const source = readFileSync5(file.source, "utf8");
-        const target = readFileSync5(file.target, "utf8");
+        const source = readFileSync6(file.source, "utf8");
+        const target = readFileSync6(file.target, "utf8");
         status = source === target ? "ok" : "drifted";
       }
     }
@@ -25384,7 +25916,7 @@ var ZodType3 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync3(inst, data, params);
   inst.spa = inst.safeParseAsync;
-  inst.refine = (check, params) => inst.check(refine(check, params));
+  inst.refine = (check2, params) => inst.check(refine(check2, params));
   inst.superRefine = (refinement) => inst.check(superRefine(refinement));
   inst.overwrite = (fn) => inst.check(_overwrite(fn));
   inst.optional = () => optional(inst);
@@ -25928,7 +26460,7 @@ var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType3.init(inst, def);
 });
-function check(fn) {
+function check2(fn) {
   const ch = new $ZodCheck({
     check: "custom"
   });
@@ -25942,7 +26474,7 @@ function refine(fn, _params = {}) {
   return _refine(ZodCustom, fn, _params);
 }
 function superRefine(fn) {
-  const ch = check((payload) => {
+  const ch = check2((payload) => {
     payload.addIssue = (issue2) => {
       if (typeof issue2 === "string") {
         payload.issues.push(exports_util.issue(issue2, payload.value, ch._zod.def));
@@ -26941,38 +27473,38 @@ function parseBigintDef(def, refs) {
   };
   if (!def.checks)
     return res;
-  for (const check2 of def.checks) {
-    switch (check2.kind) {
+  for (const check3 of def.checks) {
+    switch (check3.kind) {
       case "min":
         if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          if (check3.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check3.value, check3.message, refs);
           } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+            setResponseValueAndErrors(res, "exclusiveMinimum", check3.value, check3.message, refs);
           }
         } else {
-          if (!check2.inclusive) {
+          if (!check3.inclusive) {
             res.exclusiveMinimum = true;
           }
-          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "minimum", check3.value, check3.message, refs);
         }
         break;
       case "max":
         if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          if (check3.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check3.value, check3.message, refs);
           } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+            setResponseValueAndErrors(res, "exclusiveMaximum", check3.value, check3.message, refs);
           }
         } else {
-          if (!check2.inclusive) {
+          if (!check3.inclusive) {
             res.exclusiveMaximum = true;
           }
-          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "maximum", check3.value, check3.message, refs);
         }
         break;
       case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        setResponseValueAndErrors(res, "multipleOf", check3.value, check3.message, refs);
         break;
     }
   }
@@ -27028,13 +27560,13 @@ var integerDateParser = (def, refs) => {
   if (refs.target === "openApi3") {
     return res;
   }
-  for (const check2 of def.checks) {
-    switch (check2.kind) {
+  for (const check3 of def.checks) {
+    switch (check3.kind) {
       case "min":
-        setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        setResponseValueAndErrors(res, "minimum", check3.value, check3.message, refs);
         break;
       case "max":
-        setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        setResponseValueAndErrors(res, "maximum", check3.value, check3.message, refs);
         break;
     }
   }
@@ -27152,125 +27684,125 @@ function parseStringDef(def, refs) {
     type: "string"
   };
   if (def.checks) {
-    for (const check2 of def.checks) {
-      switch (check2.kind) {
+    for (const check3 of def.checks) {
+      switch (check3.kind) {
         case "min":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value, check3.message, refs);
           break;
         case "max":
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value, check3.message, refs);
           break;
         case "email":
           switch (refs.emailStrategy) {
             case "format:email":
-              addFormat(res, "email", check2.message, refs);
+              addFormat(res, "email", check3.message, refs);
               break;
             case "format:idn-email":
-              addFormat(res, "idn-email", check2.message, refs);
+              addFormat(res, "idn-email", check3.message, refs);
               break;
             case "pattern:zod":
-              addPattern(res, zodPatterns.email, check2.message, refs);
+              addPattern(res, zodPatterns.email, check3.message, refs);
               break;
           }
           break;
         case "url":
-          addFormat(res, "uri", check2.message, refs);
+          addFormat(res, "uri", check3.message, refs);
           break;
         case "uuid":
-          addFormat(res, "uuid", check2.message, refs);
+          addFormat(res, "uuid", check3.message, refs);
           break;
         case "regex":
-          addPattern(res, check2.regex, check2.message, refs);
+          addPattern(res, check3.regex, check3.message, refs);
           break;
         case "cuid":
-          addPattern(res, zodPatterns.cuid, check2.message, refs);
+          addPattern(res, zodPatterns.cuid, check3.message, refs);
           break;
         case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check2.message, refs);
+          addPattern(res, zodPatterns.cuid2, check3.message, refs);
           break;
         case "startsWith":
-          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check2.value, refs)}`), check2.message, refs);
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check3.value, refs)}`), check3.message, refs);
           break;
         case "endsWith":
-          addPattern(res, RegExp(`${escapeLiteralCheckValue(check2.value, refs)}$`), check2.message, refs);
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check3.value, refs)}$`), check3.message, refs);
           break;
         case "datetime":
-          addFormat(res, "date-time", check2.message, refs);
+          addFormat(res, "date-time", check3.message, refs);
           break;
         case "date":
-          addFormat(res, "date", check2.message, refs);
+          addFormat(res, "date", check3.message, refs);
           break;
         case "time":
-          addFormat(res, "time", check2.message, refs);
+          addFormat(res, "time", check3.message, refs);
           break;
         case "duration":
-          addFormat(res, "duration", check2.message, refs);
+          addFormat(res, "duration", check3.message, refs);
           break;
         case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check2.value) : check2.value, check2.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check2.value) : check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check3.value) : check3.value, check3.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check3.value) : check3.value, check3.message, refs);
           break;
         case "includes": {
-          addPattern(res, RegExp(escapeLiteralCheckValue(check2.value, refs)), check2.message, refs);
+          addPattern(res, RegExp(escapeLiteralCheckValue(check3.value, refs)), check3.message, refs);
           break;
         }
         case "ip": {
-          if (check2.version !== "v6") {
-            addFormat(res, "ipv4", check2.message, refs);
+          if (check3.version !== "v6") {
+            addFormat(res, "ipv4", check3.message, refs);
           }
-          if (check2.version !== "v4") {
-            addFormat(res, "ipv6", check2.message, refs);
+          if (check3.version !== "v4") {
+            addFormat(res, "ipv6", check3.message, refs);
           }
           break;
         }
         case "base64url":
-          addPattern(res, zodPatterns.base64url, check2.message, refs);
+          addPattern(res, zodPatterns.base64url, check3.message, refs);
           break;
         case "jwt":
-          addPattern(res, zodPatterns.jwt, check2.message, refs);
+          addPattern(res, zodPatterns.jwt, check3.message, refs);
           break;
         case "cidr": {
-          if (check2.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check2.message, refs);
+          if (check3.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check3.message, refs);
           }
-          if (check2.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check2.message, refs);
+          if (check3.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check3.message, refs);
           }
           break;
         }
         case "emoji":
-          addPattern(res, zodPatterns.emoji(), check2.message, refs);
+          addPattern(res, zodPatterns.emoji(), check3.message, refs);
           break;
         case "ulid": {
-          addPattern(res, zodPatterns.ulid, check2.message, refs);
+          addPattern(res, zodPatterns.ulid, check3.message, refs);
           break;
         }
         case "base64": {
           switch (refs.base64Strategy) {
             case "format:binary": {
-              addFormat(res, "binary", check2.message, refs);
+              addFormat(res, "binary", check3.message, refs);
               break;
             }
             case "contentEncoding:base64": {
-              setResponseValueAndErrors(res, "contentEncoding", "base64", check2.message, refs);
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check3.message, refs);
               break;
             }
             case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check2.message, refs);
+              addPattern(res, zodPatterns.base64, check3.message, refs);
               break;
             }
           }
           break;
         }
         case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check2.message, refs);
+          addPattern(res, zodPatterns.nanoid, check3.message, refs);
         }
         case "toLowerCase":
         case "toUpperCase":
         case "trim":
           break;
         default:
-          ((_) => {})(check2);
+          ((_) => {})(check3);
       }
     }
   }
@@ -27639,42 +28171,42 @@ function parseNumberDef(def, refs) {
   };
   if (!def.checks)
     return res;
-  for (const check2 of def.checks) {
-    switch (check2.kind) {
+  for (const check3 of def.checks) {
+    switch (check3.kind) {
       case "int":
         res.type = "integer";
-        addErrorMessage(res, "type", check2.message, refs);
+        addErrorMessage(res, "type", check3.message, refs);
         break;
       case "min":
         if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          if (check3.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check3.value, check3.message, refs);
           } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+            setResponseValueAndErrors(res, "exclusiveMinimum", check3.value, check3.message, refs);
           }
         } else {
-          if (!check2.inclusive) {
+          if (!check3.inclusive) {
             res.exclusiveMinimum = true;
           }
-          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "minimum", check3.value, check3.message, refs);
         }
         break;
       case "max":
         if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          if (check3.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check3.value, check3.message, refs);
           } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+            setResponseValueAndErrors(res, "exclusiveMaximum", check3.value, check3.message, refs);
           }
         } else {
-          if (!check2.inclusive) {
+          if (!check3.inclusive) {
             res.exclusiveMaximum = true;
           }
-          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          setResponseValueAndErrors(res, "maximum", check3.value, check3.message, refs);
         }
         break;
       case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        setResponseValueAndErrors(res, "multipleOf", check3.value, check3.message, refs);
         break;
     }
   }
@@ -30238,7 +30770,11 @@ var EMPTY_COMPLETION_RESULT = {
 // src/mcp/server.ts
 var MACHINE_MCP_TOOL_NAMES = [
   "machines_status",
+  "machines_doctor",
+  "machines_self_test",
   "machines_apps_list",
+  "machines_apps_status",
+  "machines_apps_diff",
   "machines_apps_plan",
   "machines_apps_apply",
   "machines_manifest",
@@ -30254,6 +30790,8 @@ var MACHINE_MCP_TOOL_NAMES = [
   "machines_diff",
   "machines_install_tailscale_preview",
   "machines_install_tailscale_apply",
+  "machines_install_claude_status",
+  "machines_install_claude_diff",
   "machines_install_claude_preview",
   "machines_install_claude_apply",
   "machines_ssh_resolve",
@@ -30268,30 +30806,25 @@ var MACHINE_MCP_TOOL_NAMES = [
   "machines_notifications_add",
   "machines_notifications_list",
   "machines_notifications_test",
+  "machines_notifications_dispatch",
   "machines_notifications_remove",
   "machines_serve_info",
   "machines_serve_dashboard"
 ];
 function createMcpServer(version2) {
-  const server = new McpServer({
-    name: "machines",
-    version: version2
-  });
+  const server = new McpServer({ name: "machines", version: version2 });
   server.tool("machines_status", "Return local machine fleet status paths and machine identity.", {}, async () => ({
     content: [{ type: "text", text: JSON.stringify(getStatus(), null, 2) }]
   }));
-  server.tool("machines_apps_list", "List manifest-managed apps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(listApps(machine_id), null, 2) }]
-  }));
-  server.tool("machines_apps_plan", "Preview app install steps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildAppsPlan(machine_id), null, 2) }]
-  }));
-  server.tool("machines_apps_apply", "Install manifest-managed apps for a machine.", {
-    machine_id: exports_external2.string().optional().describe("Machine identifier"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ machine_id, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runAppsInstall(machine_id, { apply: true, yes }), null, 2) }]
+  server.tool("machines_doctor", "Run machine preflight checks.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(runDoctor(machine_id), null, 2) }] }));
+  server.tool("machines_self_test", "Run local package smoke checks.", {}, async () => ({
+    content: [{ type: "text", text: JSON.stringify(runSelfTest(), null, 2) }]
   }));
+  server.tool("machines_apps_list", "List manifest-managed apps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(listApps(machine_id), null, 2) }] }));
+  server.tool("machines_apps_status", "Check installed state for manifest-managed apps.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(getAppsStatus(machine_id), null, 2) }] }));
+  server.tool("machines_apps_diff", "Show missing and installed manifest-managed apps.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(diffApps(machine_id), null, 2) }] }));
+  server.tool("machines_apps_plan", "Preview app install steps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(buildAppsPlan(machine_id), null, 2) }] }));
+  server.tool("machines_apps_apply", "Install manifest-managed apps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runAppsInstall(machine_id, { apply: true, yes }), null, 2) }] }));
   server.tool("machines_manifest", "Read the current fleet manifest.", {}, async () => ({
     content: [{ type: "text", text: JSON.stringify(manifestList(), null, 2) }]
   }));
@@ -30301,45 +30834,33 @@ function createMcpServer(version2) {
   server.tool("machines_manifest_bootstrap", "Detect and upsert the current machine into the fleet manifest.", {}, async () => ({
     content: [{ type: "text", text: JSON.stringify(manifestBootstrapCurrentMachine(), null, 2) }]
   }));
-  server.tool("machines_manifest_get", "Read a single machine from the fleet manifest.", { machine_id: exports_external2.string().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(manifestGet(machine_id), null, 2) }]
-  }));
-  server.tool("machines_manifest_remove", "Remove a single machine from the fleet manifest.", { machine_id: exports_external2.string().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(manifestRemove(machine_id), null, 2) }]
-  }));
+  server.tool("machines_manifest_get", "Read a single machine from the fleet manifest.", { machine_id: exports_external2.string().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(manifestGet(machine_id), null, 2) }] }));
+  server.tool("machines_manifest_remove", "Remove a single machine from the fleet manifest.", { machine_id: exports_external2.string().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(manifestRemove(machine_id), null, 2) }] }));
   server.tool("machines_agent_status", "List current machine agent heartbeats.", {}, async () => ({
     content: [{ type: "text", text: JSON.stringify(getAgentStatus(), null, 2) }]
   }));
-  server.tool("machines_setup_preview", "Preview setup actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildSetupPlan(machine_id), null, 2) }]
-  }));
-  server.tool("machines_setup_apply", "Execute setup actions for a machine.", {
-    machine_id: exports_external2.string().optional().describe("Machine identifier"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ machine_id, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runSetup(machine_id, { apply: true, yes }), null, 2) }]
-  }));
-  server.tool("machines_sync_preview", "Preview sync actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildSyncPlan(machine_id), null, 2) }]
-  }));
-  server.tool("machines_sync_apply", "Execute sync actions for a machine.", {
-    machine_id: exports_external2.string().optional().describe("Machine identifier"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ machine_id, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runSync(machine_id, { apply: true, yes }), null, 2) }]
-  }));
+  server.tool("machines_setup_preview", "Preview setup actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(buildSetupPlan(machine_id), null, 2) }] }));
+  server.tool("machines_setup_apply", "Execute setup actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runSetup(machine_id, { apply: true, yes }), null, 2) }] }));
+  server.tool("machines_sync_preview", "Preview sync actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(buildSyncPlan(machine_id), null, 2) }] }));
+  server.tool("machines_sync_apply", "Execute sync actions for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runSync(machine_id, { apply: true, yes }), null, 2) }] }));
   server.tool("machines_diff", "Show manifest differences between two machines.", {
     left_machine_id: exports_external2.string().describe("Left machine identifier"),
     right_machine_id: exports_external2.string().optional().describe("Right machine identifier")
   }, async ({ left_machine_id, right_machine_id }) => ({
     content: [{ type: "text", text: JSON.stringify(diffMachines(left_machine_id, right_machine_id), null, 2) }]
   }));
+  server.tool("machines_install_claude_status", "Check installed state for Claude, Codex, and Gemini CLIs.", {
+    machine_id: exports_external2.string().optional().describe("Machine identifier"),
+    tools: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("AI CLIs to inspect")
+  }, async ({ machine_id, tools }) => ({ content: [{ type: "text", text: JSON.stringify(getClaudeCliStatus(machine_id, tools), null, 2) }] }));
+  server.tool("machines_install_claude_diff", "Show missing and installed Claude, Codex, and Gemini CLIs.", {
+    machine_id: exports_external2.string().optional().describe("Machine identifier"),
+    tools: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("AI CLIs to inspect")
+  }, async ({ machine_id, tools }) => ({ content: [{ type: "text", text: JSON.stringify(diffClaudeCli(machine_id, tools), null, 2) }] }));
   server.tool("machines_install_claude_preview", "Preview Claude, Codex, and Gemini CLI install steps for a machine.", {
     machine_id: exports_external2.string().optional().describe("Machine identifier"),
     tools: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("AI CLIs to install")
-  }, async ({ machine_id, tools }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildClaudeInstallPlan(machine_id, tools), null, 2) }]
-  }));
+  }, async ({ machine_id, tools }) => ({ content: [{ type: "text", text: JSON.stringify(buildClaudeInstallPlan(machine_id, tools), null, 2) }] }));
   server.tool("machines_install_claude_apply", "Execute Claude, Codex, and Gemini CLI install steps for a machine.", {
     machine_id: exports_external2.string().optional().describe("Machine identifier"),
     tools: exports_external2.array(exports_external2.enum(["claude", "codex", "gemini"])).optional().describe("AI CLIs to install"),
@@ -30347,73 +30868,21 @@ function createMcpServer(version2) {
   }, async ({ machine_id, tools, yes }) => ({
     content: [{ type: "text", text: JSON.stringify(runClaudeInstall(machine_id, tools, { apply: true, yes }), null, 2) }]
   }));
-  server.tool("machines_install_tailscale_preview", "Preview Tailscale install steps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildTailscaleInstallPlan(machine_id), null, 2) }]
-  }));
-  server.tool("machines_install_tailscale_apply", "Execute Tailscale install steps for a machine.", {
-    machine_id: exports_external2.string().optional().describe("Machine identifier"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ machine_id, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runTailscaleInstall(machine_id, { apply: true, yes }), null, 2) }]
-  }));
-  server.tool("machines_ssh_resolve", "Resolve the best SSH route for a machine.", {
-    machine_id: exports_external2.string().describe("Machine identifier"),
-    remote_command: exports_external2.string().optional().describe("Optional remote command")
-  }, async ({ machine_id, remote_command }) => ({
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          resolved: resolveSshTarget(machine_id),
-          command: buildSshCommand(machine_id, remote_command)
-        }, null, 2)
-      }
-    ]
+  server.tool("machines_install_tailscale_preview", "Preview Tailscale install steps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({ content: [{ type: "text", text: JSON.stringify(buildTailscaleInstallPlan(machine_id), null, 2) }] }));
+  server.tool("machines_install_tailscale_apply", "Execute Tailscale install steps for a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ machine_id, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runTailscaleInstall(machine_id, { apply: true, yes }), null, 2) }] }));
+  server.tool("machines_ssh_resolve", "Resolve the best SSH route for a machine.", { machine_id: exports_external2.string().describe("Machine identifier"), remote_command: exports_external2.string().optional().describe("Optional remote command") }, async ({ machine_id, remote_command }) => ({
+    content: [{ type: "text", text: JSON.stringify({ resolved: resolveSshTarget(machine_id), command: buildSshCommand(machine_id, remote_command) }, null, 2) }]
   }));
-  server.tool("machines_ports", "List listening ports on a machine.", {
-    machine_id: exports_external2.string().optional().describe("Machine identifier")
-  }, async ({ machine_id }) => ({
+  server.tool("machines_ports", "List listening ports on a machine.", { machine_id: exports_external2.string().optional().describe("Machine identifier") }, async ({ machine_id }) => ({
     content: [{ type: "text", text: JSON.stringify(listPorts(machine_id), null, 2) }]
   }));
-  server.tool("machines_backup_preview", "Preview backup steps for the current machine.", {
-    bucket: exports_external2.string().describe("S3 bucket name"),
-    prefix: exports_external2.string().optional().describe("S3 key prefix")
-  }, async ({ bucket, prefix }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildBackupPlan(bucket, prefix), null, 2) }]
-  }));
-  server.tool("machines_backup_apply", "Execute backup steps for the current machine.", {
-    bucket: exports_external2.string().describe("S3 bucket name"),
-    prefix: exports_external2.string().optional().describe("S3 key prefix"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ bucket, prefix, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runBackup(bucket, prefix, { apply: true, yes }), null, 2) }]
-  }));
-  server.tool("machines_cert_preview", "Preview mkcert steps for one or more domains.", {
-    domains: exports_external2.array(exports_external2.string()).describe("Domains to issue certificates for")
-  }, async ({ domains }) => ({
-    content: [{ type: "text", text: JSON.stringify(buildCertPlan(domains), null, 2) }]
-  }));
-  server.tool("machines_cert_apply", "Execute mkcert steps for one or more domains.", {
-    domains: exports_external2.array(exports_external2.string()).describe("Domains to issue certificates for"),
-    yes: exports_external2.boolean().describe("Confirmation flag for execution")
-  }, async ({ domains, yes }) => ({
-    content: [{ type: "text", text: JSON.stringify(runCertPlan(domains, { apply: true, yes }), null, 2) }]
-  }));
-  server.tool("machines_dns_add", "Add or replace a local domain mapping.", {
-    domain: exports_external2.string().describe("Domain name"),
-    port: exports_external2.number().describe("Target port"),
-    target_host: exports_external2.string().optional().describe("Target host")
-  }, async ({ domain, port, target_host }) => ({
-    content: [{ type: "text", text: JSON.stringify(addDomainMapping(domain, port, target_host), null, 2) }]
-  }));
-  server.tool("machines_dns_list", "List local domain mappings.", {}, async () => ({
-    content: [{ type: "text", text: JSON.stringify(listDomainMappings(), null, 2) }]
-  }));
-  server.tool("machines_dns_render", "Render hosts/proxy configuration for a domain.", {
-    domain: exports_external2.string().describe("Domain name")
-  }, async ({ domain }) => ({
-    content: [{ type: "text", text: JSON.stringify(renderDomainMapping(domain), null, 2) }]
-  }));
+  server.tool("machines_backup_preview", "Preview backup steps for the current machine.", { bucket: exports_external2.string().describe("S3 bucket name"), prefix: exports_external2.string().optional().describe("S3 key prefix") }, async ({ bucket, prefix }) => ({ content: [{ type: "text", text: JSON.stringify(buildBackupPlan(bucket, prefix), null, 2) }] }));
+  server.tool("machines_backup_apply", "Execute backup steps for the current machine.", { bucket: exports_external2.string().describe("S3 bucket name"), prefix: exports_external2.string().optional().describe("S3 key prefix"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ bucket, prefix, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runBackup(bucket, prefix, { apply: true, yes }), null, 2) }] }));
+  server.tool("machines_cert_preview", "Preview mkcert steps for one or more domains.", { domains: exports_external2.array(exports_external2.string()).describe("Domains to issue certificates for") }, async ({ domains }) => ({ content: [{ type: "text", text: JSON.stringify(buildCertPlan(domains), null, 2) }] }));
+  server.tool("machines_cert_apply", "Execute mkcert steps for one or more domains.", { domains: exports_external2.array(exports_external2.string()).describe("Domains to issue certificates for"), yes: exports_external2.boolean().describe("Confirmation flag for execution") }, async ({ domains, yes }) => ({ content: [{ type: "text", text: JSON.stringify(runCertPlan(domains, { apply: true, yes }), null, 2) }] }));
+  server.tool("machines_dns_add", "Add or replace a local domain mapping.", { domain: exports_external2.string().describe("Domain name"), port: exports_external2.number().describe("Target port"), target_host: exports_external2.string().optional().describe("Target host") }, async ({ domain, port, target_host }) => ({ content: [{ type: "text", text: JSON.stringify(addDomainMapping(domain, port, target_host), null, 2) }] }));
+  server.tool("machines_dns_list", "List local domain mappings.", {}, async () => ({ content: [{ type: "text", text: JSON.stringify(listDomainMappings(), null, 2) }] }));
+  server.tool("machines_dns_render", "Render hosts/proxy configuration for a domain.", { domain: exports_external2.string().describe("Domain name") }, async ({ domain }) => ({ content: [{ type: "text", text: JSON.stringify(renderDomainMapping(domain), null, 2) }] }));
   server.tool("machines_notifications_add", "Add or replace a notification channel.", {
     channel_id: exports_external2.string().describe("Channel identifier"),
     type: exports_external2.enum(["email", "webhook", "command"]).describe("Notification transport"),
@@ -30421,68 +30890,22 @@ function createMcpServer(version2) {
     events: exports_external2.array(exports_external2.string()).describe("Events routed to this channel"),
     enabled: exports_external2.boolean().optional().describe("Whether the channel is enabled")
   }, async ({ channel_id, type, target, events, enabled }) => ({
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(addNotificationChannel({
-          id: channel_id,
-          type,
-          target,
-          events,
-          enabled: enabled ?? true
-        }), null, 2)
-      }
-    ]
+    content: [{ type: "text", text: JSON.stringify(addNotificationChannel({ id: channel_id, type, target, events, enabled: enabled ?? true }), null, 2) }]
   }));
   server.tool("machines_notifications_list", "List notification channels.", {}, async () => ({
     content: [{ type: "text", text: JSON.stringify(listNotificationChannels(), null, 2) }]
   }));
-  server.tool("machines_notifications_test", "Preview or execute a notification test.", {
-    channel_id: exports_external2.string().describe("Channel identifier"),
-    event: exports_external2.string().optional().describe("Event name"),
-    message: exports_external2.string().optional().describe("Message body"),
-    yes: exports_external2.boolean().optional().describe("Execute the test when true")
-  }, async ({ channel_id, event, message, yes }) => ({
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(testNotificationChannel(channel_id, event, message, { apply: Boolean(yes), yes }), null, 2)
-      }
-    ]
-  }));
-  server.tool("machines_notifications_remove", "Remove a notification channel.", {
-    channel_id: exports_external2.string().describe("Channel identifier")
-  }, async ({ channel_id }) => ({
-    content: [{ type: "text", text: JSON.stringify(removeNotificationChannel(channel_id), null, 2) }]
-  }));
-  server.tool("machines_serve_info", "Preview the dashboard server bind address and routes.", {
-    host: exports_external2.string().optional().describe("Host interface"),
-    port: exports_external2.number().optional().describe("Port number")
-  }, async ({ host, port }) => ({
-    content: [{ type: "text", text: JSON.stringify(getServeInfo({ host, port }), null, 2) }]
+  server.tool("machines_notifications_test", "Preview or execute a notification test.", { channel_id: exports_external2.string().describe("Channel identifier"), event: exports_external2.string().optional().describe("Event name"), message: exports_external2.string().optional().describe("Message body"), yes: exports_external2.boolean().optional().describe("Execute the test when true") }, async ({ channel_id, event, message, yes }) => ({
+    content: [{ type: "text", text: JSON.stringify(await testNotificationChannel(channel_id, event, message, { apply: Boolean(yes), yes }), null, 2) }]
   }));
+  server.tool("machines_notifications_dispatch", "Dispatch an event to matching notification channels.", { event: exports_external2.string().describe("Event name"), message: exports_external2.string().describe("Message body"), channel_id: exports_external2.string().optional().describe("Limit delivery to one channel") }, async ({ event, message, channel_id }) => ({ content: [{ type: "text", text: JSON.stringify(await dispatchNotificationEvent(event, message, { channelId: channel_id }), null, 2) }] }));
+  server.tool("machines_notifications_remove", "Remove a notification channel.", { channel_id: exports_external2.string().describe("Channel identifier") }, async ({ channel_id }) => ({ content: [{ type: "text", text: JSON.stringify(removeNotificationChannel(channel_id), null, 2) }] }));
+  server.tool("machines_serve_info", "Preview the dashboard server bind address and routes.", { host: exports_external2.string().optional().describe("Host interface"), port: exports_external2.number().optional().describe("Port number") }, async ({ host, port }) => ({ content: [{ type: "text", text: JSON.stringify(getServeInfo({ host, port }), null, 2) }] }));
   server.tool("machines_serve_dashboard", "Render the current dashboard HTML.", {}, async () => ({
     content: [{ type: "text", text: renderDashboardHtml() }]
   }));
   return server;
 }
-// src/version.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, join as join9 } from "path";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const here = dirname4(fileURLToPath(import.meta.url));
-    const candidates = [join9(here, "..", "package.json"), join9(here, "..", "..", "package.json")];
-    const pkgPath = candidates.find((candidate) => existsSync9(candidate));
-    if (!pkgPath) {
-      return "0.0.0";
-    }
-    return JSON.parse(readFileSync6(pkgPath, "utf8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
 export {
   writeNotificationConfig,
   writeManifest,
@@ -30495,6 +30918,8 @@ export {
   runTailscaleInstall,
   runSync,
   runSetup,
+  runSelfTest,
+  runDoctor,
   runClaudeInstall,
   runCertPlan,
   runBackup,
@@ -30534,12 +30959,19 @@ export {
   getDbPath,
   getDb,
   getDataDir,
+  getClipboardKeyPath,
+  getClipboardHistoryPath,
+  getClaudeCliStatus,
+  getAppsStatus,
   getAgentStatus,
   getAdapter,
   fleetSchema,
   ensureParentDir,
   ensureDataDir,
+  dispatchNotificationEvent,
   diffMachines,
+  diffClaudeCli,
+  diffApps,
   detectCurrentMachineManifest,
   createMcpServer,
   countRuns,
@@ -30553,5 +30985,6 @@ export {
   buildAppsPlan,
   addNotificationChannel,
   addDomainMapping,
-  MACHINE_MCP_TOOL_NAMES
+  MACHINE_MCP_TOOL_NAMES,
+  CROSSREFS_KEY
 };