md4ai 0.9.4 → 0.9.6

package/dist/index.bundled.js

@@ -89,6 +89,13 @@ async function loadCredentials() {
     return null;
   }
 }
+async function mergeCredentials(partial) {
+  await ensureConfigDir();
+  const existing = await loadCredentials();
+  const merged = { ...existing, ...partial };
+  await writeFile(credentialsPath, JSON.stringify(merged, null, 2), "utf-8");
+  await chmod(credentialsPath, 384);
+}
 async function clearCredentials() {
   try {
     await writeFile(credentialsPath, "{}", "utf-8");
@@ -226,6 +233,7 @@ import { resolve as resolve2, dirname, join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 async function parseFileReferences(filePath, projectRoot) {
   const refs = [];
+  const brokenRefs = [];
   const content = await readFile2(filePath, "utf-8");
   const relPath = filePath.startsWith(projectRoot) ? filePath.slice(projectRoot.length + 1) : filePath;
   const markdownLinkPattern = /\[.*?\]\(([^)]+)\)/g;
@@ -247,20 +255,34 @@ async function parseFileReferences(filePath, projectRoot) {
       const resolved = resolveTarget(target, filePath, projectRoot);
       if (resolved && existsSync2(resolved)) {
         addRef(refs, relPath, resolved, projectRoot);
+      } else if (resolved) {
+        const targetRel = resolved.startsWith(projectRoot) ? resolved.slice(projectRoot.length + 1) : resolved;
+        if (targetRel !== relPath) {
+          brokenRefs.push({ from: relPath, to: targetRel, rawRef: target });
+        }
       }
     }
   }
   if (filePath.endsWith(".json")) {
-    parseJsonPathReferences(content, relPath, projectRoot, refs);
+    parseJsonPathReferences(content, relPath, projectRoot, refs, brokenRefs);
   }
   const seen = /* @__PURE__ */ new Set();
-  return refs.filter((r) => {
+  const dedupedRefs = refs.filter((r) => {
     const key = `${r.from}->${r.to}`;
     if (seen.has(key))
       return false;
     seen.add(key);
     return true;
   });
+  const brokenSeen = /* @__PURE__ */ new Set();
+  const dedupedBroken = brokenRefs.filter((r) => {
+    const key = `${r.from}->${r.to}`;
+    if (brokenSeen.has(key))
+      return false;
+    brokenSeen.add(key);
+    return true;
+  });
+  return { refs: dedupedRefs, brokenRefs: dedupedBroken };
 }
 function resolveTarget(target, sourceFilePath, projectRoot) {
   if (target.startsWith("~")) {
@@ -280,7 +302,7 @@ function addRef(refs, fromRel, resolvedAbsolute, projectRoot) {
     refs.push({ from: fromRel, to: targetRel });
   }
 }
-function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
+function parseJsonPathReferences(content, fromRel, projectRoot, refs, brokenRefs) {
   let parsed;
   try {
     parsed = JSON.parse(content);
@@ -297,6 +319,8 @@ function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
         const resolved = join2(projectRoot, relTarget);
         if (existsSync2(resolved)) {
           addRef(refs, fromRel, resolved, projectRoot);
+        } else {
+          brokenRefs.push({ from: fromRel, to: relTarget, rawRef: relTarget });
         }
       }
     }
@@ -309,6 +333,8 @@ function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
       const resolved = join2(projectRoot, target);
       if (existsSync2(resolved)) {
         addRef(refs, fromRel, resolved, projectRoot);
+      } else {
+        brokenRefs.push({ from: fromRel, to: target, rawRef: target });
       }
     }
   });
@@ -812,9 +838,9 @@ async function detectFromMcpSettings(projectRoot) {
           continue;
         seen.add(serverName);
         let version = null;
-        const config = mcpServers[serverName];
-        if (config?.command && typeof config.command === "string") {
-          const args = config.args ?? [];
+        const config2 = mcpServers[serverName];
+        if (config2?.command && typeof config2.command === "string") {
+          const args = config2.args ?? [];
           for (const arg of args) {
             const versionMatch = arg.match(/@(\d+\.\d+[^\s]*?)$/);
             if (versionMatch) {
@@ -849,16 +875,110 @@ var init_tooling_detector = __esm({
   }
 });
 
+// dist/vercel/auth.js
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+async function resolveVercelToken() {
+  const creds = await loadCredentials();
+  if (creds?.vercelToken)
+    return creds.vercelToken;
+  const possiblePaths = [
+    join7(homedir5(), ".config", "com.vercel.cli", "auth.json"),
+    join7(homedir5(), ".local", "share", "com.vercel.cli", "auth.json")
+  ];
+  for (const authPath of possiblePaths) {
+    try {
+      const data = await readFile5(authPath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (parsed.token)
+        return parsed.token;
+    } catch {
+    }
+  }
+  return null;
+}
+var init_auth2 = __esm({
+  "dist/vercel/auth.js"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// dist/vercel/discover-projects.js
+import { readFile as readFile6, glob } from "node:fs/promises";
+import { join as join8, dirname as dirname2, relative } from "node:path";
+async function discoverVercelProjects(projectRoot) {
+  const found = /* @__PURE__ */ new Map();
+  for await (const filePath of glob(join8(projectRoot, "**/.vercel/project.json"))) {
+    try {
+      const data = await readFile6(filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      if (!parsed.projectId || !parsed.orgId)
+        continue;
+      const vercelDir = dirname2(filePath);
+      const parentDir = dirname2(vercelDir);
+      const relDir = relative(projectRoot, parentDir);
+      const label = parsed.projectName || (relDir === "" ? "root" : relDir.split("/").pop() || "unknown");
+      const existing = found.get(parsed.projectId);
+      if (!existing || relDir.length > 0) {
+        found.set(parsed.projectId, {
+          projectId: parsed.projectId,
+          orgId: parsed.orgId,
+          projectName: label
+        });
+      }
+    } catch {
+    }
+  }
+  return [...found.values()].sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+var init_discover_projects = __esm({
+  "dist/vercel/discover-projects.js"() {
+    "use strict";
+  }
+});
+
+// dist/vercel/fetch-env-vars.js
+async function fetchVercelEnvVars(projectId, orgId, token) {
+  const url = new URL(`https://api.vercel.com/v9/projects/${projectId}/env`);
+  url.searchParams.set("teamId", orgId);
+  const res = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Vercel API ${res.status}: ${body.slice(0, 200)}`);
+  }
+  const data = await res.json();
+  const envs = data.envs ?? [];
+  return envs.map((e) => ({
+    key: e.key,
+    targets: e.target ?? ["production", "preview", "development"],
+    type: e.type ?? "plain",
+    inManifest: false
+    // populated later by the scanner
+  }));
+}
+var init_fetch_env_vars = __esm({
+  "dist/vercel/fetch-env-vars.js"() {
+    "use strict";
+  }
+});
+
 // dist/scanner/env-manifest-scanner.js
-import { readFile as readFile5, glob } from "node:fs/promises";
-import { join as join7, relative } from "node:path";
+import { readFile as readFile7, glob as glob2 } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join as join9, relative as relative2 } from "node:path";
 import { existsSync as existsSync5 } from "node:fs";
+import chalk8 from "chalk";
 async function scanEnvManifest(projectRoot) {
-  const manifestFullPath = join7(projectRoot, MANIFEST_PATH);
+  const manifestFullPath = join9(projectRoot, MANIFEST_PATH);
   if (!existsSync5(manifestFullPath)) {
     return null;
   }
-  const manifestContent = await readFile5(manifestFullPath, "utf-8");
+  const manifestContent = await readFile7(manifestFullPath, "utf-8");
   const apps = parseApps(manifestContent);
   const variables = parseVariables(manifestContent);
   const localPresence = await checkLocalEnvFiles(projectRoot, apps);
@@ -870,6 +990,8 @@ async function scanEnvManifest(projectRoot) {
   }
   const workflowRefs = await parseWorkflowSecrets(projectRoot);
   const drift = computeDrift(variables, apps, localPresence, workflowRefs);
+  const vercelDiscovered = await checkVercelEnvVars(projectRoot, variables);
+  const githubRepoSlug = await checkGitHubSecrets(projectRoot, variables);
   return {
     manifestFound: true,
     manifestPath: MANIFEST_PATH,
@@ -877,9 +999,98 @@ async function scanEnvManifest(projectRoot) {
     variables,
     drift,
     workflowRefs,
+    vercelDiscovered: vercelDiscovered ?? void 0,
+    githubRepoSlug: githubRepoSlug ?? void 0,
     checkedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+async function checkVercelEnvVars(projectRoot, variables) {
+  const token = await resolveVercelToken();
+  if (!token) {
+    console.log(chalk8.dim("  Vercel checks skipped (no token configured)"));
+    return null;
+  }
+  const projects = await discoverVercelProjects(projectRoot);
+  if (projects.length === 0)
+    return null;
+  console.log(chalk8.dim(`  Checking ${projects.length} Vercel project(s)...`));
+  const discovered = [];
+  const manifestVarNames = new Set(variables.map((v) => v.name));
+  for (const proj of projects) {
+    try {
+      const vars = await fetchVercelEnvVars(proj.projectId, proj.orgId, token);
+      for (const v of vars) {
+        v.inManifest = manifestVarNames.has(v.key);
+      }
+      discovered.push({
+        projectId: proj.projectId,
+        projectName: proj.projectName,
+        orgId: proj.orgId,
+        vars
+      });
+      const vercelKeySet = new Set(vars.map((v) => v.key));
+      for (const mv of variables) {
+        if (!mv.vercelStatus)
+          mv.vercelStatus = {};
+        mv.vercelStatus[proj.projectName] = vercelKeySet.has(mv.name) ? "present" : "missing";
+      }
+      console.log(chalk8.dim(`    ${proj.projectName}: ${vars.length} var(s)`));
+    } catch (err) {
+      console.log(chalk8.yellow(`    ${proj.projectName}: ${err instanceof Error ? err.message : "API error"}`));
+    }
+  }
+  return discovered.length > 0 ? discovered : null;
+}
+async function detectGitHubRepoSlug(projectRoot) {
+  try {
+    const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], { cwd: projectRoot });
+    const url = stdout.trim();
+    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+      return sshMatch[1];
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function listGitHubSecretNames(repoSlug) {
+  try {
+    const { stdout } = await execFileAsync("gh", [
+      "secret",
+      "list",
+      "--repo",
+      repoSlug,
+      "--json",
+      "name",
+      "-q",
+      ".[].name"
+    ], { timeout: 15e3 });
+    const names = stdout.trim().split("\n").filter(Boolean);
+    return names;
+  } catch {
+    return null;
+  }
+}
+async function checkGitHubSecrets(projectRoot, variables) {
+  const slug = await detectGitHubRepoSlug(projectRoot);
+  if (!slug) {
+    console.log(chalk8.dim("  GitHub checks skipped (no GitHub remote detected)"));
+    return null;
+  }
+  const secretNames = await listGitHubSecretNames(slug);
+  if (!secretNames) {
+    console.log(chalk8.dim("  GitHub checks skipped (gh CLI not available or not authenticated)"));
+    return slug;
+  }
+  const secretSet = new Set(secretNames);
+  console.log(chalk8.dim(`  GitHub secrets: ${secretNames.length} found in ${slug}`));
+  for (const v of variables) {
+    if (v.requiredIn.github) {
+      v.githubStatus = secretSet.has(v.name) ? "present" : "missing";
+    }
+  }
+  return slug;
+}
 function parseApps(content) {
   const apps = [];
   const appsSection = extractSection(content, "Apps");
@@ -959,10 +1170,10 @@ function extractSection(content, heading) {
 async function checkLocalEnvFiles(projectRoot, apps) {
   const result = /* @__PURE__ */ new Map();
   for (const app of apps) {
-    const envPath = join7(projectRoot, app.envFilePath);
+    const envPath = join9(projectRoot, app.envFilePath);
     const varNames = /* @__PURE__ */ new Set();
     if (existsSync5(envPath)) {
-      const content = await readFile5(envPath, "utf-8");
+      const content = await readFile7(envPath, "utf-8");
       for (const line of content.split("\n")) {
         const m = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
         if (m) {
@@ -975,14 +1186,14 @@ async function checkLocalEnvFiles(projectRoot, apps) {
   return result;
 }
 async function parseWorkflowSecrets(projectRoot) {
-  const workflowsDir = join7(projectRoot, ".github", "workflows");
+  const workflowsDir = join9(projectRoot, ".github", "workflows");
   if (!existsSync5(workflowsDir))
     return [];
   const refs = [];
   const secretRe = /\$\{\{\s*secrets\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
   for (const ext of ["*.yml", "*.yaml"]) {
-    for await (const filePath of glob(join7(workflowsDir, ext))) {
-      const content = await readFile5(filePath, "utf-8");
+    for await (const filePath of glob2(join9(workflowsDir, ext))) {
+      const content = await readFile7(filePath, "utf-8");
       const secrets = /* @__PURE__ */ new Set();
       let m;
       while ((m = secretRe.exec(content)) !== null) {
@@ -991,7 +1202,7 @@ async function parseWorkflowSecrets(projectRoot) {
       secretRe.lastIndex = 0;
       if (secrets.size > 0) {
         refs.push({
-          workflowFile: relative(projectRoot, filePath),
+          workflowFile: relative2(projectRoot, filePath),
           secretsUsed: [...secrets].sort()
         });
       }
@@ -1045,29 +1256,35 @@ function computeDrift(variables, apps, localPresence, workflowRefs) {
     workflowBrokenRefs: workflowBrokenRefs.sort()
   };
 }
-var MANIFEST_PATH;
+var execFileAsync, MANIFEST_PATH;
 var init_env_manifest_scanner = __esm({
   "dist/scanner/env-manifest-scanner.js"() {
     "use strict";
+    init_auth2();
+    init_discover_projects();
+    init_fetch_env_vars();
+    execFileAsync = promisify(execFile);
     MANIFEST_PATH = "docs/reference/env-manifest.md";
   }
 });
 
 // dist/scanner/index.js
 import { readdir as readdir2 } from "node:fs/promises";
-import { join as join8, relative as relative2 } from "node:path";
+import { join as join10, relative as relative3 } from "node:path";
 import { existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { createHash } from "node:crypto";
 async function scanProject(projectRoot) {
   const allFiles = await discoverFiles(projectRoot);
   const rootFiles = identifyRoots(allFiles, projectRoot);
   const allRefs = [];
+  const allBrokenRefs = [];
   for (const file of allFiles) {
-    const fullPath = file.startsWith("/") ? file : join8(projectRoot, file);
+    const fullPath = file.startsWith("/") ? file : join10(projectRoot, file);
     try {
-      const refs = await parseFileReferences(fullPath, projectRoot);
+      const { refs, brokenRefs: brokenRefs2 } = await parseFileReferences(fullPath, projectRoot);
       allRefs.push(...refs);
+      allBrokenRefs.push(...brokenRefs2);
     } catch {
     }
   }
@@ -1077,11 +1294,31 @@ async function scanProject(projectRoot) {
   const skills = await parseSkills(projectRoot);
   const toolings = await detectToolings(projectRoot);
   const envManifest = await scanEnvManifest(projectRoot);
-  const scanData = JSON.stringify({ graph, orphans, skills, staleFiles, toolings, envManifest });
+  const depthMap = /* @__PURE__ */ new Map();
+  const queue = [...rootFiles];
+  for (const r of queue)
+    depthMap.set(r, 0);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const currentDepth = depthMap.get(current);
+    for (const ref of allRefs) {
+      if (ref.from === current && !depthMap.has(ref.to)) {
+        depthMap.set(ref.to, currentDepth + 1);
+        queue.push(ref.to);
+      }
+    }
+  }
+  const brokenRefs = allBrokenRefs.map((br) => ({
+    ...br,
+    depth: depthMap.get(br.from) ?? 999
+  }));
+  brokenRefs.sort((a, b) => a.depth - b.depth || a.from.localeCompare(b.from));
+  const scanData = JSON.stringify({ graph, orphans, brokenRefs, skills, staleFiles, toolings, envManifest });
   const dataHash = createHash("sha256").update(scanData).digest("hex");
   return {
     graph,
     orphans,
+    brokenRefs,
     skills,
     staleFiles,
     toolings,
@@ -1092,17 +1329,17 @@ async function scanProject(projectRoot) {
 }
 async function discoverFiles(projectRoot) {
   const files = [];
-  const claudeDir = join8(projectRoot, ".claude");
+  const claudeDir = join10(projectRoot, ".claude");
   if (existsSync6(claudeDir)) {
     await walkDir(claudeDir, projectRoot, files);
   }
-  if (existsSync6(join8(projectRoot, "CLAUDE.md"))) {
+  if (existsSync6(join10(projectRoot, "CLAUDE.md"))) {
     files.push("CLAUDE.md");
   }
-  if (existsSync6(join8(projectRoot, "skills.md"))) {
+  if (existsSync6(join10(projectRoot, "skills.md"))) {
     files.push("skills.md");
   }
-  const plansDir = join8(projectRoot, "docs", "plans");
+  const plansDir = join10(projectRoot, "docs", "plans");
   if (existsSync6(plansDir)) {
     await walkDir(plansDir, projectRoot, files);
   }
@@ -1111,13 +1348,13 @@ async function discoverFiles(projectRoot) {
 async function walkDir(dir, projectRoot, files) {
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join10(dir, entry.name);
     if (entry.isDirectory()) {
       if (["node_modules", ".git", ".turbo", "cache", "session-env"].includes(entry.name))
         continue;
       await walkDir(fullPath, projectRoot, files);
     } else {
-      const relPath = relative2(projectRoot, fullPath);
+      const relPath = relative3(projectRoot, fullPath);
       files.push(relPath);
     }
   }
@@ -1130,7 +1367,7 @@ function identifyRoots(allFiles, projectRoot) {
     }
   }
   for (const globalFile of GLOBAL_ROOT_FILES) {
-    const expanded = globalFile.replace("~", homedir5());
+    const expanded = globalFile.replace("~", homedir6());
     if (existsSync6(expanded)) {
       roots.push(globalFile);
     }
@@ -1138,8 +1375,8 @@ function identifyRoots(allFiles, projectRoot) {
   return roots;
 }
 async function readClaudeConfigFiles(projectRoot) {
-  const { readFile: readFile10, stat, glob: glob2 } = await import("node:fs/promises");
-  const { join: join14, relative: relative4 } = await import("node:path");
+  const { readFile: readFile12, stat, glob: glob3 } = await import("node:fs/promises");
+  const { join: join16, relative: relative5 } = await import("node:path");
   const { existsSync: existsSync13 } = await import("node:fs");
   const configPatterns = [
     "CLAUDE.md",
@@ -1151,12 +1388,12 @@ async function readClaudeConfigFiles(projectRoot) {
   const files = [];
   const seen = /* @__PURE__ */ new Set();
   async function addFile(fullPath) {
-    const relPath = relative4(projectRoot, fullPath);
+    const relPath = relative5(projectRoot, fullPath);
     if (seen.has(relPath))
       return;
     seen.add(relPath);
     try {
-      const content = await readFile10(fullPath, "utf-8");
+      const content = await readFile12(fullPath, "utf-8");
       const fileStat = await stat(fullPath);
       const lastMod = getGitLastModified(fullPath, projectRoot);
       files.push({ filePath: relPath, content, sizeBytes: fileStat.size, lastModified: lastMod });
@@ -1164,22 +1401,22 @@ async function readClaudeConfigFiles(projectRoot) {
     }
   }
   for (const pattern of configPatterns) {
-    for await (const fullPath of glob2(join14(projectRoot, pattern))) {
+    for await (const fullPath of glob3(join16(projectRoot, pattern))) {
       if (!existsSync13(fullPath))
         continue;
       await addFile(fullPath);
     }
   }
-  const pkgPath = join14(projectRoot, "package.json");
+  const pkgPath = join16(projectRoot, "package.json");
   if (existsSync13(pkgPath)) {
     try {
-      const pkgContent = await readFile10(pkgPath, "utf-8");
+      const pkgContent = await readFile12(pkgPath, "utf-8");
       const pkg = JSON.parse(pkgContent);
       const preflightCmd = pkg.scripts?.preflight;
       if (preflightCmd) {
         const match = preflightCmd.match(/(?:bash\s+|sh\s+|\.\/)?(\S+\.(?:sh|bash|ts|js|mjs))/);
         if (match) {
-          const scriptPath = join14(projectRoot, match[1]);
+          const scriptPath = join16(projectRoot, match[1]);
           if (existsSync13(scriptPath)) {
             await addFile(scriptPath);
           }
@@ -1194,7 +1431,7 @@ function detectStaleFiles(allFiles, projectRoot) {
   const stale = [];
   const now = Date.now();
   for (const file of allFiles) {
-    const fullPath = join8(projectRoot, file);
+    const fullPath = join10(projectRoot, file);
     const lastMod = getGitLastModified(fullPath, projectRoot);
     if (lastMod) {
       const days = Math.floor((now - new Date(lastMod).getTime()) / (1e3 * 60 * 60 * 24));
@@ -1336,7 +1573,7 @@ var init_html_generator = __esm({
 });
 
 // dist/check-update.js
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 async function fetchLatest() {
   try {
     const controller = new AbortController();
@@ -1355,12 +1592,12 @@ async function fetchLatest() {
 }
 function printUpdateBanner(latest) {
   console.log("");
-  console.log(chalk8.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
-  console.log(chalk8.yellow("\u2502") + chalk8.bold("  Update available! ") + chalk8.dim(`${CURRENT_VERSION}`) + chalk8.white(" \u2192 ") + chalk8.green.bold(`${latest}`) + "              " + chalk8.yellow("\u2502"));
-  console.log(chalk8.yellow("\u2502") + "                                              " + chalk8.yellow("\u2502"));
-  console.log(chalk8.yellow("\u2502") + "  Run: " + chalk8.cyan("md4ai update") + "                          " + chalk8.yellow("\u2502"));
-  console.log(chalk8.yellow("\u2502") + "                                              " + chalk8.yellow("\u2502"));
-  console.log(chalk8.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  console.log(chalk9.yellow("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk9.yellow("\u2502") + chalk9.bold("  Update available! ") + chalk9.dim(`${CURRENT_VERSION}`) + chalk9.white(" \u2192 ") + chalk9.green.bold(`${latest}`) + "              " + chalk9.yellow("\u2502"));
+  console.log(chalk9.yellow("\u2502") + "                                              " + chalk9.yellow("\u2502"));
+  console.log(chalk9.yellow("\u2502") + "  Run: " + chalk9.cyan("md4ai update") + "                          " + chalk9.yellow("\u2502"));
+  console.log(chalk9.yellow("\u2502") + "                                              " + chalk9.yellow("\u2502"));
+  console.log(chalk9.yellow("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
   console.log("");
 }
 async function checkForUpdate() {
@@ -1370,7 +1607,7 @@ async function checkForUpdate() {
   if (latest !== CURRENT_VERSION && isNewer(latest, CURRENT_VERSION)) {
     printUpdateBanner(latest);
   } else {
-    console.log(chalk8.green(`md4ai v${CURRENT_VERSION} \u2014 you're on the latest version.`));
+    console.log(chalk9.green(`md4ai v${CURRENT_VERSION} \u2014 you're on the latest version.`));
   }
 }
 async function autoCheckForUpdate() {
@@ -1399,7 +1636,7 @@ var CURRENT_VERSION;
 var init_check_update = __esm({
   "dist/check-update.js"() {
     "use strict";
-    CURRENT_VERSION = true ? "0.9.4" : "0.0.0-dev";
+    CURRENT_VERSION = true ? "0.9.6" : "0.0.0-dev";
   }
 });
 
@@ -1427,6 +1664,87 @@ var init_push_toolings = __esm({
   }
 });
 
+// dist/commands/push-health-results.js
+import chalk10 from "chalk";
+async function pushHealthResults(supabase, folderId, manifest) {
+  const { data: checks } = await supabase.from("env_health_checks").select("id, check_type, check_config").eq("folder_id", folderId).eq("enabled", true);
+  if (!checks?.length)
+    return;
+  const results = [];
+  const ranAt = manifest.checkedAt;
+  for (const chk of checks) {
+    const config2 = chk.check_config;
+    if (chk.check_type === "env_var_set") {
+      const app = config2.app;
+      const variable = config2.variable;
+      const v = manifest.variables.find((mv) => mv.name === variable);
+      if (v) {
+        const localStatus = v.localStatus[app];
+        results.push({
+          check_id: chk.id,
+          status: localStatus === "present" ? "pass" : "fail",
+          message: localStatus === "present" ? "Set" : "Missing",
+          ran_at: ranAt
+        });
+      }
+    } else if (chk.check_type === "file_exists") {
+      results.push({
+        check_id: chk.id,
+        status: "pass",
+        message: "Found",
+        ran_at: ranAt
+      });
+    } else if (chk.check_type === "gh_secret") {
+      const variable = config2.secret;
+      const v = manifest.variables.find((mv) => mv.name === variable);
+      const ghStatus = v?.githubStatus;
+      results.push({
+        check_id: chk.id,
+        status: ghStatus === "present" ? "pass" : ghStatus === "missing" ? "fail" : "warn",
+        message: ghStatus === "present" ? "Exists" : ghStatus === "missing" ? "Missing" : "Unknown",
+        ran_at: ranAt
+      });
+    } else if (chk.check_type === "vercel_env") {
+      const variable = config2.variable;
+      const projectName = config2.projectName;
+      const target = config2.target;
+      const proj = manifest.vercelDiscovered?.find((p) => p.projectName === projectName);
+      if (proj) {
+        const vercelVar = proj.vars.find((v) => v.key === variable);
+        if (vercelVar) {
+          const hasTarget = vercelVar.targets.includes(target);
+          results.push({
+            check_id: chk.id,
+            status: hasTarget ? "pass" : "warn",
+            message: hasTarget ? `Present (${target})` : `Present but not in ${target}`,
+            ran_at: ranAt
+          });
+        } else {
+          results.push({
+            check_id: chk.id,
+            status: "fail",
+            message: `Not found in ${projectName}`,
+            ran_at: ranAt
+          });
+        }
+      }
+    }
+  }
+  if (results.length > 0) {
+    const { error } = await supabase.from("env_health_results").insert(results);
+    if (error) {
+      console.error(chalk10.yellow(`Health results warning: ${error.message}`));
+    } else {
+      console.log(chalk10.green(`  Updated ${results.length} health check result(s).`));
+    }
+  }
+}
+var init_push_health_results = __esm({
+  "dist/commands/push-health-results.js"() {
+    "use strict";
+  }
+});
+
 // dist/device-utils.js
 import { hostname as hostname2, platform as platform2 } from "node:os";
 function detectOs2() {
@@ -1473,26 +1791,37 @@ __export(map_exports, {
 import { resolve as resolve3, basename } from "node:path";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 import { select as select3, input as input5, confirm as confirm2 } from "@inquirer/prompts";
 async function mapCommand(path, options) {
   await checkForUpdate();
   const projectRoot = resolve3(path ?? process.cwd());
   if (!existsSync7(projectRoot)) {
-    console.error(chalk9.red(`Path not found: ${projectRoot}`));
+    console.error(chalk11.red(`Path not found: ${projectRoot}`));
     process.exit(1);
   }
-  console.log(chalk9.blue(`Scanning: ${projectRoot}
+  console.log(chalk11.blue(`Scanning: ${projectRoot}
 `));
   const result = await scanProject(projectRoot);
   console.log(`  Files found:   ${result.graph.nodes.length}`);
   console.log(`  References:    ${result.graph.edges.length}`);
+  console.log(`  Broken refs:   ${result.brokenRefs.length}`);
   console.log(`  Orphans:       ${result.orphans.length}`);
   console.log(`  Stale files:   ${result.staleFiles.length}`);
   console.log(`  Skills:        ${result.skills.length}`);
   console.log(`  Toolings:      ${result.toolings.length}`);
   console.log(`  Env Vars:      ${result.envManifest?.variables.length ?? 0} (${result.envManifest ? "manifest found" : "no manifest"})`);
   console.log(`  Data hash:     ${result.dataHash.slice(0, 12)}...`);
+  if (result.brokenRefs.length > 0) {
+    console.log(chalk11.red(`
+  Warning: ${result.brokenRefs.length} broken reference(s) found:`));
+    for (const br of result.brokenRefs.slice(0, 5)) {
+      console.log(chalk11.red(`    ${br.from} -> ${br.to}`));
+    }
+    if (result.brokenRefs.length > 5) {
+      console.log(chalk11.red(`    ... and ${result.brokenRefs.length - 5} more`));
+    }
+  }
   const outputDir = resolve3(projectRoot, "output");
   if (!existsSync7(outputDir)) {
     await mkdir2(outputDir, { recursive: true });
@@ -1500,7 +1829,7 @@ async function mapCommand(path, options) {
   const htmlPath = resolve3(outputDir, "index.html");
   const html = generateOfflineHtml(result, projectRoot);
   await writeFile2(htmlPath, html, "utf-8");
-  console.log(chalk9.green(`
+  console.log(chalk11.green(`
 Local preview: ${htmlPath}`));
   if (!options.offline) {
     try {
@@ -1509,9 +1838,9 @@ Local preview: ${htmlPath}`));
       if (devicePaths?.length) {
         const { folder_id, device_name } = devicePaths[0];
         const { data: proposedFiles } = await supabase.from("folder_files").select("id, file_path, proposed_at").eq("folder_id", folder_id).eq("proposed_for_deletion", true);
-        if (proposedFiles?.length) {
+        if (proposedFiles?.length && process.stdin.isTTY) {
           const { checkbox } = await import("@inquirer/prompts");
-          console.log(chalk9.yellow(`
+          console.log(chalk11.yellow(`
 ${proposedFiles.length} file(s) proposed for deletion:
 `));
           const toDelete = await checkbox({
@@ -1527,9 +1856,9 @@ ${proposedFiles.length} file(s) proposed for deletion:
               const { unlink } = await import("node:fs/promises");
               await unlink(fullPath);
               await supabase.from("folder_files").delete().eq("id", file.id);
-              console.log(chalk9.green(`  Deleted: ${file.file_path}`));
+              console.log(chalk11.green(`  Deleted: ${file.file_path}`));
             } catch (err) {
-              console.error(chalk9.red(`  Failed to delete ${file.file_path}: ${err}`));
+              console.error(chalk11.red(`  Failed to delete ${file.file_path}: ${err}`));
             }
           }
           const keptIds = proposedFiles.filter((f) => !toDelete.some((d) => d.id === f.id)).map((f) => f.id);
@@ -1537,13 +1866,16 @@ ${proposedFiles.length} file(s) proposed for deletion:
             for (const id of keptIds) {
               await supabase.from("folder_files").update({ proposed_for_deletion: false, proposed_at: null, proposed_by: null }).eq("id", id);
             }
-            console.log(chalk9.cyan(`  Kept ${keptIds.length} file(s) \u2014 proposals cleared.`));
+            console.log(chalk11.cyan(`  Kept ${keptIds.length} file(s) \u2014 proposals cleared.`));
           }
           console.log("");
+        } else if (proposedFiles?.length) {
+          console.log(chalk11.dim(`  ${proposedFiles.length} file(s) proposed for deletion \u2014 skipped (non-interactive mode).`));
         }
         const { error } = await supabase.from("claude_folders").update({
           graph_json: result.graph,
           orphans_json: result.orphans,
+          broken_refs_json: result.brokenRefs,
           skills_table_json: result.skills,
           stale_files_json: result.staleFiles,
           env_manifest_json: result.envManifest,
@@ -1551,17 +1883,20 @@ ${proposedFiles.length} file(s) proposed for deletion:
           data_hash: result.dataHash
         }).eq("id", folder_id);
         if (error) {
-          console.error(chalk9.yellow(`Sync warning: ${error.message}`));
+          console.error(chalk11.yellow(`Sync warning: ${error.message}`));
         } else {
           await pushToolings(supabase, folder_id, result.toolings);
+          if (result.envManifest) {
+            await pushHealthResults(supabase, folder_id, result.envManifest);
+          }
           await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder_id).eq("device_name", device_name);
           await saveState({
             lastFolderId: folder_id,
             lastDeviceName: device_name,
             lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
           });
-          console.log(chalk9.green("Synced to Supabase."));
-          console.log(chalk9.cyan(`
+          console.log(chalk11.green("Synced to Supabase."));
+          console.log(chalk11.cyan(`
   https://www.md4ai.com/project/${folder_id}
 `));
           const configFiles = await readClaudeConfigFiles(projectRoot);
@@ -1575,14 +1910,18 @@ ${proposedFiles.length} file(s) proposed for deletion:
                 last_modified: file.lastModified
               }, { onConflict: "folder_id,file_path" });
             }
-            console.log(chalk9.green(`  Uploaded ${configFiles.length} config file(s).`));
+            console.log(chalk11.green(`  Uploaded ${configFiles.length} config file(s).`));
           }
         }
       } else {
-        console.log(chalk9.yellow("\nThis folder is not linked to a project on your dashboard."));
+        console.log(chalk11.yellow("\nThis folder is not linked to a project on your dashboard."));
+        if (!process.stdin.isTTY) {
+          console.log(chalk11.dim("Non-interactive mode \u2014 skipping link prompt."));
+          return;
+        }
         const shouldLink = await confirm2({ message: "Would you like to link it now?" });
         if (!shouldLink) {
-          console.log(chalk9.dim("Skipped \u2014 local preview still generated."));
+          console.log(chalk11.dim("Skipped \u2014 local preview still generated."));
         } else {
           const { supabase: sb, userId } = await getAuthenticatedClient();
           const { data: folders } = await sb.from("claude_folders").select("id, name").order("name");
@@ -1602,11 +1941,11 @@ ${proposedFiles.length} file(s) proposed for deletion:
             });
             const { data: newFolder, error: createErr } = await sb.from("claude_folders").insert({ user_id: userId, name: projectName }).select("id").single();
             if (createErr || !newFolder) {
-              console.error(chalk9.red(`Failed to create project: ${createErr?.message}`));
+              console.error(chalk11.red(`Failed to create project: ${createErr?.message}`));
               return;
             }
             folderId = newFolder.id;
-            console.log(chalk9.green(`Created project "${projectName}".`));
+            console.log(chalk11.green(`Created project "${projectName}".`));
           } else {
             folderId = chosen;
           }
@@ -1628,6 +1967,7 @@ ${proposedFiles.length} file(s) proposed for deletion:
           await sb.from("claude_folders").update({
             graph_json: result.graph,
             orphans_json: result.orphans,
+            broken_refs_json: result.brokenRefs,
             skills_table_json: result.skills,
             stale_files_json: result.staleFiles,
             env_manifest_json: result.envManifest,
@@ -1635,6 +1975,9 @@ ${proposedFiles.length} file(s) proposed for deletion:
             data_hash: result.dataHash
           }).eq("id", folderId);
           await pushToolings(sb, folderId, result.toolings);
+          if (result.envManifest) {
+            await pushHealthResults(sb, folderId, result.envManifest);
+          }
           const configFiles = await readClaudeConfigFiles(projectRoot);
           for (const file of configFiles) {
             await sb.from("folder_files").upsert({
@@ -1650,14 +1993,14 @@ ${proposedFiles.length} file(s) proposed for deletion:
             lastDeviceName: deviceName,
             lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
           });
-          console.log(chalk9.green("\nLinked and synced."));
-          console.log(chalk9.cyan(`
+          console.log(chalk11.green("\nLinked and synced."));
+          console.log(chalk11.cyan(`
   https://www.md4ai.com/project/${folderId}
 `));
         }
       }
     } catch {
-      console.log(chalk9.yellow("Not logged in \u2014 local preview only."));
+      console.log(chalk11.yellow("Not logged in \u2014 local preview only."));
     }
   }
 }
@@ -1670,6 +2013,7 @@ var init_map = __esm({
     init_html_generator();
     init_check_update();
     init_push_toolings();
+    init_push_health_results();
     init_device_utils();
   }
 });
@@ -1679,26 +2023,27 @@ var sync_exports = {};
 __export(sync_exports, {
   syncCommand: () => syncCommand
 });
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 async function syncCommand(options) {
   const { supabase } = await getAuthenticatedClient();
   if (options.all) {
     const { data: devices, error } = await supabase.from("device_paths").select("folder_id, device_name, path");
     if (error || !devices?.length) {
-      console.error(chalk12.red("No devices found."));
+      console.error(chalk14.red("No devices found."));
       process.exit(1);
     }
     for (const device of devices) {
-      console.log(chalk12.blue(`Syncing: ${device.path}`));
+      console.log(chalk14.blue(`Syncing: ${device.path}`));
       const { data: proposedAll } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
       if (proposedAll?.length) {
-        console.log(chalk12.yellow(`  ${proposedAll.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
+        console.log(chalk14.yellow(`  ${proposedAll.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
       }
       try {
         const result = await scanProject(device.path);
         await supabase.from("claude_folders").update({
           graph_json: result.graph,
           orphans_json: result.orphans,
+          broken_refs_json: result.brokenRefs,
           skills_table_json: result.skills,
           stale_files_json: result.staleFiles,
           env_manifest_json: result.envManifest,
@@ -1707,33 +2052,34 @@ async function syncCommand(options) {
         }).eq("id", device.folder_id);
         await pushToolings(supabase, device.folder_id, result.toolings);
         await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
-        console.log(chalk12.green(`  Done: ${device.device_name}`));
+        console.log(chalk14.green(`  Done: ${device.device_name}`));
       } catch (err) {
-        console.error(chalk12.red(`  Failed: ${device.path}: ${err}`));
+        console.error(chalk14.red(`  Failed: ${device.path}: ${err}`));
       }
     }
     await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(chalk12.green("\nAll devices synced."));
+    console.log(chalk14.green("\nAll devices synced."));
   } else {
     const state = await loadState();
     if (!state.lastFolderId) {
-      console.error(chalk12.yellow("No recent sync. Use: md4ai sync --all, or md4ai scan <path> first."));
+      console.error(chalk14.yellow("No recent sync. Use: md4ai sync --all, or md4ai scan <path> first."));
       process.exit(1);
     }
     const { data: device } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("folder_id", state.lastFolderId).eq("device_name", state.lastDeviceName).single();
     if (!device) {
-      console.error(chalk12.red("Could not find last synced device/folder."));
+      console.error(chalk14.red("Could not find last synced device/folder."));
       process.exit(1);
     }
-    console.log(chalk12.blue(`Syncing: ${device.path}`));
+    console.log(chalk14.blue(`Syncing: ${device.path}`));
     const { data: proposedSingle } = await supabase.from("folder_files").select("file_path").eq("folder_id", device.folder_id).eq("proposed_for_deletion", true);
     if (proposedSingle?.length) {
-      console.log(chalk12.yellow(`  ${proposedSingle.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
+      console.log(chalk14.yellow(`  ${proposedSingle.length} file(s) proposed for deletion \u2014 run \`md4ai scan\` to review.`));
     }
     const result = await scanProject(device.path);
     await supabase.from("claude_folders").update({
       graph_json: result.graph,
       orphans_json: result.orphans,
+      broken_refs_json: result.brokenRefs,
       skills_table_json: result.skills,
       stale_files_json: result.staleFiles,
       last_scanned: result.scannedAt,
@@ -1742,7 +2088,7 @@ async function syncCommand(options) {
     await pushToolings(supabase, device.folder_id, result.toolings);
     await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
     await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log(chalk12.green("Synced."));
+    console.log(chalk14.green("Synced."));
   }
 }
 var init_sync = __esm({
@@ -1756,16 +2102,16 @@ var init_sync = __esm({
 });
 
 // dist/mcp/read-configs.js
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { readFile as readFile10 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import { existsSync as existsSync11 } from "node:fs";
 import { readdir as readdir3 } from "node:fs/promises";
 async function readJsonSafe(path) {
   try {
     if (!existsSync11(path))
       return null;
-    const raw = await readFile8(path, "utf-8");
+    const raw = await readFile10(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1825,52 +2171,52 @@ function parseFlatConfig(data, source) {
   return entries;
 }
 async function readAllMcpConfigs() {
-  const home = homedir7();
+  const home = homedir8();
   const entries = [];
-  const userConfig = await readJsonSafe(join12(home, ".claude.json"));
+  const userConfig = await readJsonSafe(join14(home, ".claude.json"));
   entries.push(...parseServers(userConfig, "global"));
-  const globalMcp = await readJsonSafe(join12(home, ".claude", "mcp.json"));
+  const globalMcp = await readJsonSafe(join14(home, ".claude", "mcp.json"));
   entries.push(...parseServers(globalMcp, "global"));
-  const cwdMcp = await readJsonSafe(join12(process.cwd(), ".mcp.json"));
+  const cwdMcp = await readJsonSafe(join14(process.cwd(), ".mcp.json"));
   entries.push(...parseServers(cwdMcp, "project"));
-  const pluginsBase = join12(home, ".claude", "plugins", "marketplaces");
+  const pluginsBase = join14(home, ".claude", "plugins", "marketplaces");
   if (existsSync11(pluginsBase)) {
     try {
       const marketplaces = await readdir3(pluginsBase, { withFileTypes: true });
       for (const mp of marketplaces) {
         if (!mp.isDirectory())
           continue;
-        const extDir = join12(pluginsBase, mp.name, "external_plugins");
+        const extDir = join14(pluginsBase, mp.name, "external_plugins");
         if (!existsSync11(extDir))
           continue;
         const plugins = await readdir3(extDir, { withFileTypes: true });
         for (const plugin of plugins) {
           if (!plugin.isDirectory())
             continue;
-          const pluginMcp = await readJsonSafe(join12(extDir, plugin.name, ".mcp.json"));
+          const pluginMcp = await readJsonSafe(join14(extDir, plugin.name, ".mcp.json"));
           entries.push(...parseServers(pluginMcp, "plugin"));
         }
       }
     } catch {
     }
   }
-  const cacheBase = join12(home, ".claude", "plugins", "cache");
+  const cacheBase = join14(home, ".claude", "plugins", "cache");
   if (existsSync11(cacheBase)) {
     try {
       const registries = await readdir3(cacheBase, { withFileTypes: true });
       for (const reg of registries) {
         if (!reg.isDirectory())
           continue;
-        const regDir = join12(cacheBase, reg.name);
+        const regDir = join14(cacheBase, reg.name);
         const plugins = await readdir3(regDir, { withFileTypes: true });
         for (const plugin of plugins) {
           if (!plugin.isDirectory())
             continue;
-          const versionDirs = await readdir3(join12(regDir, plugin.name), { withFileTypes: true });
+          const versionDirs = await readdir3(join14(regDir, plugin.name), { withFileTypes: true });
           for (const ver of versionDirs) {
             if (!ver.isDirectory())
               continue;
-            const mcpPath = join12(regDir, plugin.name, ver.name, ".mcp.json");
+            const mcpPath = join14(regDir, plugin.name, ver.name, ".mcp.json");
             const flatData = await readJsonSafe(mcpPath);
             if (flatData) {
               entries.push(...parseFlatConfig(flatData, "plugin"));
@@ -1934,23 +2280,23 @@ function parseEtime(etime) {
   }
   return days * 86400 + (parts[0] ?? 0);
 }
-function findProcessesForConfig(config, processes) {
-  if (config.type === "http")
+function findProcessesForConfig(config2, processes) {
+  if (config2.type === "http")
     return [];
-  const packageName = config.args ? extractPackageName(config.args) : null;
+  const packageName = config2.args ? extractPackageName(config2.args) : null;
   const matches = [];
   const searchTerms = [];
   if (packageName)
     searchTerms.push(packageName);
-  if (config.command === "node" && config.args?.[0]) {
-    searchTerms.push(config.args[0]);
+  if (config2.command === "node" && config2.args?.[0]) {
+    searchTerms.push(config2.args[0]);
   }
-  if (config.name) {
-    searchTerms.push(`mcp-server-${config.name}`);
-    searchTerms.push(`${config.name}-mcp`);
+  if (config2.name) {
+    searchTerms.push(`mcp-server-${config2.name}`);
+    searchTerms.push(`${config2.name}-mcp`);
   }
-  if ((config.command === "uvx" || config.command === "pipx") && config.args) {
-    for (const arg of config.args) {
+  if ((config2.command === "uvx" || config2.command === "pipx") && config2.args) {
+    for (const arg of config2.args) {
       if (!arg.startsWith("-") && arg !== "run")
         searchTerms.push(arg);
     }
@@ -2000,7 +2346,7 @@ var mcp_watch_exports = {};
 __export(mcp_watch_exports, {
   mcpWatchCommand: () => mcpWatchCommand
 });
-import chalk18 from "chalk";
+import chalk20 from "chalk";
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 function detectTty() {
@@ -2014,10 +2360,10 @@ function detectTty() {
     return null;
   }
 }
-function checkEnvVars(config) {
-  const required = config.env ? Object.keys(config.env) : [];
+function checkEnvVars(config2) {
+  const required = config2.env ? Object.keys(config2.env) : [];
   const missing = required.filter((key) => {
-    const configValue = config.env?.[key];
+    const configValue = config2.env?.[key];
     const hasConfigValue = configValue && !configValue.startsWith("${");
     return !hasConfigValue && !process.env[key];
   });
@@ -2052,20 +2398,20 @@ async function checkChromeCdp() {
 function buildRows(configs, httpResults, cdpStatus) {
   const processes = getProcessTable();
   const rows = [];
-  for (const config of configs) {
-    const { required, missing } = checkEnvVars(config);
-    const packageName = config.args ? extractPackageName(config.args) : null;
-    if (config.type === "http") {
-      const reachability = httpResults.get(config.name) ?? "unknown";
+  for (const config2 of configs) {
+    const { required, missing } = checkEnvVars(config2);
+    const packageName = config2.args ? extractPackageName(config2.args) : null;
+    if (config2.type === "http") {
+      const reachability = httpResults.get(config2.name) ?? "unknown";
       const status = reachability === "reachable" ? "running" : "stopped";
       const detail = reachability === "reachable" ? "HTTP \u2014 remote service reachable" : reachability === "unreachable" ? "HTTP \u2014 remote service unreachable" : "HTTP \u2014 could not verify";
       rows.push({
-        server_name: config.name,
-        config_source: config.source,
+        server_name: config2.name,
+        config_source: config2.source,
         server_type: "http",
         command: null,
         package_name: null,
-        http_url: config.url ?? null,
+        http_url: config2.url ?? null,
         status,
         pid: null,
         session_tty: null,
@@ -2079,10 +2425,10 @@ function buildRows(configs, httpResults, cdpStatus) {
     }
     if (missing.length > 0) {
       rows.push({
-        server_name: config.name,
-        config_source: config.source,
+        server_name: config2.name,
+        config_source: config2.source,
         server_type: "stdio",
-        command: config.command ?? null,
+        command: config2.command ?? null,
         package_name: packageName,
         http_url: null,
         status: "error",
@@ -2096,15 +2442,15 @@ function buildRows(configs, httpResults, cdpStatus) {
       });
       continue;
     }
-    const isChromeDevtools = config.name === "chrome-devtools" || (config.args ?? []).some((a) => a.includes("chrome-devtools"));
+    const isChromeDevtools = config2.name === "chrome-devtools" || (config2.args ?? []).some((a) => a.includes("chrome-devtools"));
     const cdpDetail = isChromeDevtools && cdpStatus ? cdpStatus.status === "reachable" ? "Chrome CDP reachable" : "Chrome not reachable on port 9222" : null;
-    const matches = findProcessesForConfig(config, processes);
+    const matches = findProcessesForConfig(config2, processes);
     if (matches.length === 0) {
       rows.push({
-        server_name: config.name,
-        config_source: config.source,
+        server_name: config2.name,
+        config_source: config2.source,
         server_type: "stdio",
-        command: config.command ?? null,
+        command: config2.command ?? null,
         package_name: packageName,
         http_url: null,
         status: "stopped",
@@ -2127,10 +2473,10 @@ function buildRows(configs, httpResults, cdpStatus) {
       }
       for (const match of byTty.values()) {
         rows.push({
-          server_name: config.name,
-          config_source: config.source,
+          server_name: config2.name,
+          config_source: config2.source,
           server_type: "stdio",
-          command: config.command ?? null,
+          command: config2.command ?? null,
           package_name: packageName,
           http_url: null,
           status: "running",
@@ -2149,20 +2495,20 @@ function buildRows(configs, httpResults, cdpStatus) {
 }
 function printTable(rows, deviceName, watcherPid, cdpResult) {
   process.stdout.write("\x1B[3J\x1B[2J\x1B[H");
-  console.log(chalk18.bold.cyan(`
-  MCP Monitor v${CURRENT_VERSION} \u2014 ${deviceName}`) + chalk18.dim(`  (PID ${watcherPid})`));
-  console.log(chalk18.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 refreshes every 30s \xB7 Ctrl+C to stop
+  console.log(chalk20.bold.cyan(`
+  MCP Monitor v${CURRENT_VERSION} \u2014 ${deviceName}`) + chalk20.dim(`  (PID ${watcherPid})`));
+  console.log(chalk20.dim(`  ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 refreshes every 30s \xB7 Ctrl+C to stop
 `));
   if (cdpResult) {
     if (cdpResult.status === "reachable") {
       const browserInfo = cdpResult.browser ? ` (${cdpResult.browser})` : "";
-      console.log(chalk18.green("  \u2714 Chrome browser connected") + chalk18.dim(browserInfo));
-      console.log(chalk18.dim("    Claude Code can control Chrome via DevTools Protocol on localhost:9222"));
+      console.log(chalk20.green("  \u2714 Chrome browser connected") + chalk20.dim(browserInfo));
+      console.log(chalk20.dim("    Claude Code can control Chrome via DevTools Protocol on localhost:9222"));
     } else {
-      console.log(chalk18.red("  \u2717 Chrome browser not connected"));
-      console.log(chalk18.dim("    Claude Code cannot reach Chrome. To fix:"));
-      console.log(chalk18.dim("    1. Open Chrome with: google-chrome --remote-debugging-port=9222"));
-      console.log(chalk18.dim("    2. Or add --remote-debugging-port=9222 to your Chrome shortcut"));
+      console.log(chalk20.red("  \u2717 Chrome browser not connected"));
+      console.log(chalk20.dim("    Claude Code cannot reach Chrome. To fix:"));
+      console.log(chalk20.dim("    1. Open Chrome with: google-chrome --remote-debugging-port=9222"));
+      console.log(chalk20.dim("    2. Or add --remote-debugging-port=9222 to your Chrome shortcut"));
     }
     console.log("");
   }
@@ -2183,41 +2529,41 @@ function printTable(rows, deviceName, watcherPid, cdpResult) {
       sessionNum++;
       const totalMem = servers.reduce((sum, s) => sum + (s.memory_mb ?? 0), 0);
       const label = byTty.size === 1 ? "Claude Code session" : `Claude Code session ${sessionNum}`;
-      console.log(chalk18.green(`  ${label}`) + chalk18.dim(` \u2014 ${servers.length} server${servers.length !== 1 ? "s" : ""} \xB7 ${totalMem} MB \xB7 terminal ${tty}`));
+      console.log(chalk20.green(`  ${label}`) + chalk20.dim(` \u2014 ${servers.length} server${servers.length !== 1 ? "s" : ""} \xB7 ${totalMem} MB \xB7 terminal ${tty}`));
       for (const s of servers) {
         const uptime = formatUptime(s.uptime_seconds ?? 0);
-        const source = chalk18.dim(`[${s.config_source}]`);
-        console.log(`    ${chalk18.green("\u25CF")} ${s.server_name.padEnd(20)} ${source} ${chalk18.dim((s.package_name ?? "").padEnd(25))} ${String(s.memory_mb ?? 0).padStart(4)} MB  ${uptime}`);
+        const source = chalk20.dim(`[${s.config_source}]`);
+        console.log(`    ${chalk20.green("\u25CF")} ${s.server_name.padEnd(20)} ${source} ${chalk20.dim((s.package_name ?? "").padEnd(25))} ${String(s.memory_mb ?? 0).padStart(4)} MB  ${uptime}`);
       }
       console.log("");
     }
     if (byTty.size > 1) {
-      console.log(chalk18.dim("  Each open Claude Code window runs its own set of MCP servers.\n"));
+      console.log(chalk20.dim("  Each open Claude Code window runs its own set of MCP servers.\n"));
     }
   }
   if (runningHttp.length > 0) {
-    console.log(chalk18.blue(`  Remote Services (${runningHttp.length})`) + chalk18.dim(" \u2014 HTTP endpoints reachable"));
+    console.log(chalk20.blue(`  Remote Services (${runningHttp.length})`) + chalk20.dim(" \u2014 HTTP endpoints reachable"));
     for (const s of runningHttp) {
-      console.log(`    ${chalk18.blue("\u25CF")} ${s.server_name.padEnd(20)} ${chalk18.dim((s.http_url ?? "").padEnd(30))}`);
+      console.log(`    ${chalk20.blue("\u25CF")} ${s.server_name.padEnd(20)} ${chalk20.dim((s.http_url ?? "").padEnd(30))}`);
     }
     console.log("");
   }
   if (stopped.length > 0 || errored.length > 0) {
     const notRunning = [...stopped, ...errored];
-    console.log(chalk18.yellow(`  Not Running (${notRunning.length})`) + chalk18.dim(" \u2014 configured but no process detected"));
+    console.log(chalk20.yellow(`  Not Running (${notRunning.length})`) + chalk20.dim(" \u2014 configured but no process detected"));
     for (const s of notRunning) {
-      const icon = s.status === "error" ? chalk18.red("\u2717") : chalk18.yellow("\u25CB");
-      const source = chalk18.dim(`[${s.config_source}]`);
-      const detail = s.error_detail ? chalk18.dim(` \u2014 ${s.error_detail}`) : "";
+      const icon = s.status === "error" ? chalk20.red("\u2717") : chalk20.yellow("\u25CB");
+      const source = chalk20.dim(`[${s.config_source}]`);
+      const detail = s.error_detail ? chalk20.dim(` \u2014 ${s.error_detail}`) : "";
       console.log(`    ${icon} ${s.server_name.padEnd(20)} ${source}${detail}`);
     }
     console.log("");
   }
   if (rows.length === 0) {
-    console.log(chalk18.yellow("  No MCP servers configured."));
-    console.log(chalk18.dim("  Configure servers in ~/.claude/mcp.json or .mcp.json\n"));
+    console.log(chalk20.yellow("  No MCP servers configured."));
+    console.log(chalk20.dim("  Configure servers in ~/.claude/mcp.json or .mcp.json\n"));
   }
-  console.log(chalk18.bgYellow.black.bold("  \u26A0  DO NOT CLOSE THIS WINDOW \u2014 it feeds live data to the dashboard  \u26A0  "));
+  console.log(chalk20.bgYellow.black.bold("  \u26A0  DO NOT CLOSE THIS WINDOW \u2014 it feeds live data to the dashboard  \u26A0  "));
   console.log("");
 }
 function formatUptime(seconds) {
@@ -2240,7 +2586,7 @@ async function mcpWatchCommand() {
   const { data: existingWatchers } = await supabase.from("mcp_watchers").select("pid, tty, cli_version, started_at").eq("device_id", deviceId);
   if (existingWatchers && existingWatchers.length > 0) {
     console.log("");
-    console.log(chalk18.yellow(`  Replacing ${existingWatchers.length} existing watcher${existingWatchers.length !== 1 ? "s" : ""} on this device...`));
+    console.log(chalk20.yellow(`  Replacing ${existingWatchers.length} existing watcher${existingWatchers.length !== 1 ? "s" : ""} on this device...`));
     for (const w of existingWatchers) {
       try {
         process.kill(w.pid, "SIGTERM");
@@ -2249,15 +2595,15 @@ async function mcpWatchCommand() {
     }
     await supabase.from("mcp_watchers").delete().eq("device_id", deviceId);
     await new Promise((r) => setTimeout(r, 1e3));
-    console.log(chalk18.dim("  Previous watcher stopped.\n"));
+    console.log(chalk20.dim("  Previous watcher stopped.\n"));
   }
   process.stdout.write(`\x1B]0;MCP mon\x07`);
-  console.log(chalk18.blue(`Starting MCP monitor for ${deviceName}...`));
+  console.log(chalk20.blue(`Starting MCP monitor for ${deviceName}...`));
   console.log("");
-  console.log(chalk18.dim("  View this in the online dashboard at:"));
-  console.log(chalk18.cyan(`  https://www.md4ai.com/device/${deviceId}`));
+  console.log(chalk20.dim("  View this in the online dashboard at:"));
+  console.log(chalk20.cyan(`  https://www.md4ai.com/device/${deviceId}`));
   console.log("");
-  console.log(chalk18.yellow("  Please note, closing this window will stop ALL watch reports."));
+  console.log(chalk20.yellow("  Please note, closing this window will stop ALL watch reports."));
   console.log("");
   await supabase.from("mcp_watchers").upsert({
     device_id: deviceId,
@@ -2283,7 +2629,7 @@ async function mcpWatchCommand() {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const { error: deleteError } = await supabase.from("mcp_server_status").delete().eq("device_id", deviceId);
     if (deleteError) {
-      console.error(chalk18.red(`  [debug] Failed to delete old status: ${deleteError.message}`));
+      console.error(chalk20.red(`  [debug] Failed to delete old status: ${deleteError.message}`));
     }
     if (rows.length > 0) {
       const { error: insertError } = await supabase.from("mcp_server_status").insert(rows.map((row) => ({
@@ -2292,7 +2638,7 @@ async function mcpWatchCommand() {
         checked_at: now
       })));
       if (insertError) {
-        console.error(chalk18.red(`  [debug] Failed to write MCP status: ${insertError.message}`));
+        console.error(chalk20.red(`  [debug] Failed to write MCP status: ${insertError.message}`));
       }
     }
     await supabase.from("mcp_watchers").update({ last_heartbeat: now }).eq("device_id", deviceId).eq("pid", myPid);
@@ -2330,7 +2676,7 @@ async function mcpWatchCommand() {
     clearInterval(interval);
     clearInterval(envInterval);
     await supabase.from("mcp_watchers").delete().eq("device_id", deviceId).eq("pid", myPid);
-    console.log(chalk18.dim("\nMCP monitor stopped."));
+    console.log(chalk20.dim("\nMCP monitor stopped."));
     process.exit(0);
   };
   process.on("SIGINT", () => {
@@ -2361,6 +2707,7 @@ async function checkPendingRescans(supabase, deviceId, deviceName) {
       await supabase.from("claude_folders").update({
         graph_json: result.graph,
         orphans_json: result.orphans,
+        broken_refs_json: result.brokenRefs,
         skills_table_json: result.skills,
         stale_files_json: result.staleFiles,
         env_manifest_json: result.envManifest,
@@ -2594,71 +2941,71 @@ init_map();
 
 // dist/commands/simulate.js
 init_dist();
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 import { existsSync as existsSync8 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import chalk10 from "chalk";
+import { homedir as homedir7 } from "node:os";
+import chalk12 from "chalk";
 async function simulateCommand(prompt) {
   const projectRoot = process.cwd();
-  console.log(chalk10.blue(`Simulating prompt: "${prompt}"
+  console.log(chalk12.blue(`Simulating prompt: "${prompt}"
 `));
-  console.log(chalk10.dim("Files Claude would load:\n"));
-  const globalClaude = join9(homedir6(), ".claude", "CLAUDE.md");
+  console.log(chalk12.dim("Files Claude would load:\n"));
+  const globalClaude = join11(homedir7(), ".claude", "CLAUDE.md");
   if (existsSync8(globalClaude)) {
-    console.log(chalk10.green("  \u2713 ~/.claude/CLAUDE.md (global)"));
+    console.log(chalk12.green("  \u2713 ~/.claude/CLAUDE.md (global)"));
   }
   for (const rootFile of ROOT_FILES) {
-    const fullPath = join9(projectRoot, rootFile);
+    const fullPath = join11(projectRoot, rootFile);
     if (existsSync8(fullPath)) {
-      console.log(chalk10.green(`  \u2713 ${rootFile} (project root)`));
+      console.log(chalk12.green(`  \u2713 ${rootFile} (project root)`));
     }
   }
   const settingsFiles = [
-    join9(homedir6(), ".claude", "settings.json"),
-    join9(homedir6(), ".claude", "settings.local.json"),
-    join9(projectRoot, ".claude", "settings.json"),
-    join9(projectRoot, ".claude", "settings.local.json")
+    join11(homedir7(), ".claude", "settings.json"),
+    join11(homedir7(), ".claude", "settings.local.json"),
+    join11(projectRoot, ".claude", "settings.json"),
+    join11(projectRoot, ".claude", "settings.local.json")
   ];
   for (const sf of settingsFiles) {
     if (existsSync8(sf)) {
-      const display = sf.startsWith(homedir6()) ? sf.replace(homedir6(), "~") : sf.replace(projectRoot + "/", "");
-      console.log(chalk10.green(`  \u2713 ${display} (settings)`));
+      const display = sf.startsWith(homedir7()) ? sf.replace(homedir7(), "~") : sf.replace(projectRoot + "/", "");
+      console.log(chalk12.green(`  \u2713 ${display} (settings)`));
     }
   }
   const words = prompt.split(/\s+/);
   for (const word of words) {
     const cleaned = word.replace(/['"]/g, "");
-    const candidatePath = join9(projectRoot, cleaned);
+    const candidatePath = join11(projectRoot, cleaned);
     if (existsSync8(candidatePath) && cleaned.includes("/")) {
-      console.log(chalk10.cyan(`  \u2192 ${cleaned} (referenced in prompt)`));
+      console.log(chalk12.cyan(`  \u2192 ${cleaned} (referenced in prompt)`));
     }
   }
-  console.log(chalk10.dim("\nNote: This is an approximation. Actual file loading depends on Claude Code internals."));
+  console.log(chalk12.dim("\nNote: This is an approximation. Actual file loading depends on Claude Code internals."));
 }
 
 // dist/commands/print.js
-import { join as join10 } from "node:path";
-import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+import { readFile as readFile8, writeFile as writeFile3 } from "node:fs/promises";
 import { existsSync as existsSync9 } from "node:fs";
-import chalk11 from "chalk";
+import chalk13 from "chalk";
 async function printCommand(title) {
   const projectRoot = process.cwd();
-  const scanDataPath = join10(projectRoot, "output", "index.html");
+  const scanDataPath = join12(projectRoot, "output", "index.html");
   if (!existsSync9(scanDataPath)) {
-    console.error(chalk11.red("No scan data found. Run: md4ai scan"));
+    console.error(chalk13.red("No scan data found. Run: md4ai scan"));
     process.exit(1);
   }
-  const html = await readFile6(scanDataPath, "utf-8");
+  const html = await readFile8(scanDataPath, "utf-8");
   const match = html.match(/<script type="application\/json" id="scan-data">([\s\S]*?)<\/script>/);
   if (!match) {
-    console.error(chalk11.red("Could not extract scan data from output/index.html"));
+    console.error(chalk13.red("Could not extract scan data from output/index.html"));
     process.exit(1);
   }
   const result = JSON.parse(match[1]);
   const printHtml = generatePrintHtml(result, title);
-  const outputPath = join10(projectRoot, "output", `print-${Date.now()}.html`);
+  const outputPath = join12(projectRoot, "output", `print-${Date.now()}.html`);
   await writeFile3(outputPath, printHtml, "utf-8");
-  console.log(chalk11.green(`Print-ready wall sheet: ${outputPath}`));
+  console.log(chalk13.green(`Print-ready wall sheet: ${outputPath}`));
 }
 function escapeHtml2(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -2724,7 +3071,7 @@ init_scanner();
 init_push_toolings();
 init_device_utils();
 import { resolve as resolve4 } from "node:path";
-import chalk13 from "chalk";
+import chalk15 from "chalk";
 async function linkCommand(projectId) {
   const { supabase, userId } = await getAuthenticatedClient();
   const cwd = resolve4(process.cwd());
@@ -2732,11 +3079,11 @@ async function linkCommand(projectId) {
   const osType = detectOs2();
   const { data: folder, error: folderErr } = await supabase.from("claude_folders").select("id, name").eq("id", projectId).single();
   if (folderErr || !folder) {
-    console.error(chalk13.red("Project not found, or you do not have access."));
-    console.error(chalk13.yellow("Check the project ID in the MD4AI web dashboard."));
+    console.error(chalk15.red("Project not found, or you do not have access."));
+    console.error(chalk15.yellow("Check the project ID in the MD4AI web dashboard."));
     process.exit(1);
   }
-  console.log(chalk13.blue(`
+  console.log(chalk15.blue(`
 Linking "${folder.name}" to this device...
 `));
   console.log(`  Project:  ${folder.name}`);
@@ -2760,12 +3107,12 @@ Linking "${folder.name}" to this device...
       path: cwd
     });
     if (pathErr) {
-      console.error(chalk13.red(`Failed to link: ${pathErr.message}`));
+      console.error(chalk15.red(`Failed to link: ${pathErr.message}`));
       process.exit(1);
     }
   }
-  console.log(chalk13.green("\nLinked successfully."));
-  console.log(chalk13.blue("\nRunning initial scan...\n"));
+  console.log(chalk15.green("\nLinked successfully."));
+  console.log(chalk15.blue("\nRunning initial scan...\n"));
   const result = await scanProject(cwd);
   console.log(`  Files:     ${result.graph.nodes.length}`);
   console.log(`  References:${result.graph.edges.length}`);
@@ -2776,6 +3123,7 @@ Linking "${folder.name}" to this device...
   const { error: scanErr } = await supabase.from("claude_folders").update({
     graph_json: result.graph,
     orphans_json: result.orphans,
+    broken_refs_json: result.brokenRefs,
     skills_table_json: result.skills,
     stale_files_json: result.staleFiles,
     env_manifest_json: result.envManifest,
@@ -2783,7 +3131,7 @@ Linking "${folder.name}" to this device...
     data_hash: result.dataHash
   }).eq("id", folder.id);
   if (scanErr) {
-    console.error(chalk13.yellow(`Scan upload warning: ${scanErr.message}`));
+    console.error(chalk15.yellow(`Scan upload warning: ${scanErr.message}`));
   }
   await pushToolings(supabase, folder.id, result.toolings);
   const configFiles = await readClaudeConfigFiles(cwd);
@@ -2797,7 +3145,7 @@ Linking "${folder.name}" to this device...
         last_modified: file.lastModified
       }, { onConflict: "folder_id,file_path" });
     }
-    console.log(chalk13.green(`  Uploaded ${configFiles.length} config file(s).`));
+    console.log(chalk15.green(`  Uploaded ${configFiles.length} config file(s).`));
   }
   await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder.id).eq("device_name", deviceName);
   await saveState({
@@ -2806,34 +3154,34 @@ Linking "${folder.name}" to this device...
     lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const projectUrl = `https://www.md4ai.com/project/${folder.id}`;
-  console.log(chalk13.green("\nDone! Project linked and scanned."));
-  console.log(chalk13.cyan(`
+  console.log(chalk15.green("\nDone! Project linked and scanned."));
+  console.log(chalk15.cyan(`
   ${projectUrl}
 `));
-  console.log(chalk13.grey('Run "md4ai scan" to rescan at any time.'));
+  console.log(chalk15.grey('Run "md4ai scan" to rescan at any time.'));
 }
 
 // dist/commands/import-bundle.js
-import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
-import { join as join11, dirname as dirname2 } from "node:path";
+import { readFile as readFile9, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
+import { join as join13, dirname as dirname3 } from "node:path";
 import { existsSync as existsSync10 } from "node:fs";
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 import { confirm as confirm3, input as input6 } from "@inquirer/prompts";
 async function importBundleCommand(zipPath) {
   if (!existsSync10(zipPath)) {
-    console.error(chalk14.red(`File not found: ${zipPath}`));
+    console.error(chalk16.red(`File not found: ${zipPath}`));
     process.exit(1);
   }
   const JSZip = (await import("jszip")).default;
-  const zipData = await readFile7(zipPath);
+  const zipData = await readFile9(zipPath);
   const zip = await JSZip.loadAsync(zipData);
   const manifestFile = zip.file("manifest.json");
   if (!manifestFile) {
-    console.error(chalk14.red("Invalid bundle: missing manifest.json"));
+    console.error(chalk16.red("Invalid bundle: missing manifest.json"));
     process.exit(1);
   }
   const manifest = JSON.parse(await manifestFile.async("string"));
-  console.log(chalk14.blue(`
+  console.log(chalk16.blue(`
 Bundle: ${manifest.folderName}`));
   console.log(`  Exported by: ${manifest.ownerEmail}`);
   console.log(`  Exported at: ${manifest.exportedAt}`);
@@ -2847,10 +3195,10 @@ Bundle: ${manifest.folderName}`));
     }
   }
   if (files.length === 0) {
-    console.log(chalk14.yellow("No Claude config files found in bundle."));
+    console.log(chalk16.yellow("No Claude config files found in bundle."));
     return;
   }
-  console.log(chalk14.blue(`
+  console.log(chalk16.blue(`
 Files to extract:`));
   for (const f of files) {
     console.log(`  ${f.filePath}`);
@@ -2863,34 +3211,34 @@ Files to extract:`));
     message: `Extract ${files.length} file(s) to ${targetDir}?`
   });
   if (!proceed) {
-    console.log(chalk14.yellow("Cancelled."));
+    console.log(chalk16.yellow("Cancelled."));
     return;
   }
   for (const file of files) {
-    const fullPath = join11(targetDir, file.filePath);
-    const dir = dirname2(fullPath);
+    const fullPath = join13(targetDir, file.filePath);
+    const dir = dirname3(fullPath);
     if (!existsSync10(dir)) {
       await mkdir3(dir, { recursive: true });
     }
     await writeFile4(fullPath, file.content, "utf-8");
-    console.log(chalk14.green(`  \u2713 ${file.filePath}`));
+    console.log(chalk16.green(`  \u2713 ${file.filePath}`));
   }
-  console.log(chalk14.green(`
+  console.log(chalk16.green(`
 Done! ${files.length} file(s) extracted to ${targetDir}`));
 }
 
 // dist/commands/admin-update-tool.js
 init_auth();
-import chalk15 from "chalk";
+import chalk17 from "chalk";
 var VALID_CATEGORIES = ["framework", "runtime", "cli", "mcp", "package", "database", "other"];
 async function adminUpdateToolCommand(options) {
   const { supabase } = await getAuthenticatedClient();
   if (!options.name) {
-    console.error(chalk15.red("--name is required."));
+    console.error(chalk17.red("--name is required."));
     process.exit(1);
   }
   if (options.category && !VALID_CATEGORIES.includes(options.category)) {
-    console.error(chalk15.red(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`));
+    console.error(chalk17.red(`Invalid category. Must be one of: ${VALID_CATEGORIES.join(", ")}`));
     process.exit(1);
   }
   const { data: existing } = await supabase.from("tools_registry").select("id, name, display_name, category").eq("name", options.name).maybeSingle();
@@ -2912,13 +3260,13 @@ async function adminUpdateToolCommand(options) {
       updates.notes = options.notes;
     const { error } = await supabase.from("tools_registry").update(updates).eq("id", existing.id);
     if (error) {
-      console.error(chalk15.red(`Failed to update: ${error.message}`));
+      console.error(chalk17.red(`Failed to update: ${error.message}`));
       process.exit(1);
     }
-    console.log(chalk15.green(`Updated "${existing.display_name}" in the registry.`));
+    console.log(chalk17.green(`Updated "${existing.display_name}" in the registry.`));
   } else {
     if (!options.display || !options.category) {
-      console.error(chalk15.red("New tools require --display and --category."));
+      console.error(chalk17.red("New tools require --display and --category."));
       process.exit(1);
     }
     const { error } = await supabase.from("tools_registry").insert({
@@ -2932,25 +3280,25 @@ async function adminUpdateToolCommand(options) {
       notes: options.notes ?? null
     });
     if (error) {
-      console.error(chalk15.red(`Failed to create: ${error.message}`));
+      console.error(chalk17.red(`Failed to create: ${error.message}`));
       process.exit(1);
     }
-    console.log(chalk15.green(`Added "${options.display}" to the registry.`));
+    console.log(chalk17.green(`Added "${options.display}" to the registry.`));
   }
 }
 
 // dist/commands/admin-list-tools.js
 init_auth();
-import chalk16 from "chalk";
+import chalk18 from "chalk";
 async function adminListToolsCommand() {
   const { supabase } = await getAuthenticatedClient();
   const { data: tools, error } = await supabase.from("tools_registry").select("*").order("category").order("display_name");
   if (error) {
-    console.error(chalk16.red(`Failed to fetch tools: ${error.message}`));
+    console.error(chalk18.red(`Failed to fetch tools: ${error.message}`));
     process.exit(1);
   }
   if (!tools?.length) {
-    console.log(chalk16.yellow("No tools in the registry."));
+    console.log(chalk18.yellow("No tools in the registry."));
     return;
   }
   const nameW = Math.max(16, ...tools.map((t) => t.display_name.length));
@@ -2964,7 +3312,7 @@ async function adminListToolsCommand() {
     "Beta".padEnd(betaW),
     "Last Checked"
   ].join("  ");
-  console.log(chalk16.bold(header));
+  console.log(chalk18.bold(header));
   console.log("\u2500".repeat(header.length));
   for (const tool of tools) {
     const lastChecked = tool.updated_at ? formatRelative(new Date(tool.updated_at)) : "\u2014";
@@ -2977,7 +3325,7 @@ async function adminListToolsCommand() {
     ].join("  ");
     console.log(row);
   }
-  console.log(chalk16.grey(`
+  console.log(chalk18.grey(`
 ${tools.length} tool(s) in registry.`));
 }
 function formatRelative(date) {
@@ -2995,7 +3343,7 @@ function formatRelative(date) {
 
 // dist/commands/admin-fetch-versions.js
 init_auth();
-import chalk17 from "chalk";
+import chalk19 from "chalk";
 
 // dist/commands/version-sources.js
 var VERSION_SOURCES = {
@@ -3024,11 +3372,11 @@ async function adminFetchVersionsCommand() {
   const { supabase } = await getAuthenticatedClient();
   const { data: tools, error } = await supabase.from("tools_registry").select("*").order("display_name");
   if (error) {
-    console.error(chalk17.red(`Failed to fetch tools: ${error.message}`));
+    console.error(chalk19.red(`Failed to fetch tools: ${error.message}`));
     process.exit(1);
   }
   if (!tools?.length) {
-    console.log(chalk17.yellow("No tools in the registry."));
+    console.log(chalk19.yellow("No tools in the registry."));
   }
   const { data: allProjectToolings } = await supabase.from("project_toolings").select("tool_name, detection_source").is("tool_id", null);
   const registeredNames = new Set((tools ?? []).map((t) => t.name));
@@ -3039,7 +3387,7 @@ async function adminFetchVersionsCommand() {
     }
   }
   if (unregisteredNames.size > 0) {
-    console.log(chalk17.blue(`Auto-registering ${unregisteredNames.size} unverified package(s)...
+    console.log(chalk19.blue(`Auto-registering ${unregisteredNames.size} unverified package(s)...
 `));
     for (const name of unregisteredNames) {
       const displayName = name;
@@ -3057,10 +3405,10 @@ async function adminFetchVersionsCommand() {
     }
   }
   if (!tools?.length) {
-    console.log(chalk17.yellow("No tools to fetch."));
+    console.log(chalk19.yellow("No tools to fetch."));
     return;
   }
-  console.log(chalk17.bold(`Fetching versions for ${tools.length} tool(s)...
+  console.log(chalk19.bold(`Fetching versions for ${tools.length} tool(s)...
 `));
   const results = await Promise.all(tools.map(async (tool) => {
     const source = VERSION_SOURCES[tool.name] ?? { type: "npm", package: tool.name };
@@ -3099,10 +3447,10 @@ async function adminFetchVersionsCommand() {
     "Beta".padEnd(betaW),
     "Status".padEnd(statusW)
   ].join("  ");
-  console.log(chalk17.bold(header));
+  console.log(chalk19.bold(header));
   console.log("\u2500".repeat(header.length));
   for (const result of results) {
-    const statusColour = result.status === "updated" ? chalk17.green : result.status === "unchanged" ? chalk17.grey : result.status === "failed" ? chalk17.red : chalk17.yellow;
+    const statusColour = result.status === "updated" ? chalk19.green : result.status === "unchanged" ? chalk19.grey : result.status === "failed" ? chalk19.red : chalk19.yellow;
     const row = [
       result.displayName.padEnd(nameW),
       (result.stable ?? "\u2014").padEnd(stableW),
@@ -3115,8 +3463,8 @@ async function adminFetchVersionsCommand() {
   const unchanged = results.filter((r) => r.status === "unchanged").length;
   const failed = results.filter((r) => r.status === "failed").length;
   const noSource = results.filter((r) => r.status === "no source").length;
-  console.log(chalk17.grey(`
-${results.length} tool(s): `) + chalk17.green(`${updated} updated`) + ", " + chalk17.grey(`${unchanged} unchanged`) + ", " + chalk17.red(`${failed} failed`) + ", " + chalk17.yellow(`${noSource} no source`));
+  console.log(chalk19.grey(`
+${results.length} tool(s): `) + chalk19.green(`${updated} updated`) + ", " + chalk19.grey(`${unchanged} unchanged`) + ", " + chalk19.red(`${failed} failed`) + ", " + chalk19.yellow(`${noSource} no source`));
 }
 async function fetchVersions(source) {
   const controller = new AbortController();
@@ -3174,10 +3522,10 @@ async function fetchGitHubVersions(repo, signal) {
 init_mcp_watch();
 
 // dist/commands/init-manifest.js
-import { resolve as resolve5, join as join13, relative as relative3, dirname as dirname3 } from "node:path";
-import { readFile as readFile9, writeFile as writeFile5, mkdir as mkdir4 } from "node:fs/promises";
+import { resolve as resolve5, join as join15, relative as relative4, dirname as dirname4 } from "node:path";
+import { readFile as readFile11, writeFile as writeFile5, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync12 } from "node:fs";
-import chalk19 from "chalk";
+import chalk21 from "chalk";
 var SECRET_PATTERNS = [
   /_KEY$/i,
   /_SECRET$/i,
@@ -3193,7 +3541,7 @@ function isLikelySecret(name) {
 async function discoverEnvFiles(projectRoot) {
   const apps = [];
   for (const envName of [".env", ".env.local", ".env.example"]) {
-    const envPath = join13(projectRoot, envName);
+    const envPath = join15(projectRoot, envName);
     if (existsSync12(envPath)) {
       const vars = await extractVarNames(envPath);
       if (vars.length > 0) {
@@ -3204,11 +3552,11 @@ async function discoverEnvFiles(projectRoot) {
   }
   const subdirs = ["web", "cli", "api", "app", "server", "packages"];
   for (const sub of subdirs) {
-    const subDir = join13(projectRoot, sub);
+    const subDir = join15(projectRoot, sub);
     if (!existsSync12(subDir))
       continue;
     for (const envName of [".env.local", ".env", ".env.example"]) {
-      const envPath = join13(subDir, envName);
+      const envPath = join15(subDir, envName);
       if (existsSync12(envPath)) {
         const vars = await extractVarNames(envPath);
         if (vars.length > 0) {
@@ -3225,7 +3573,7 @@ async function discoverEnvFiles(projectRoot) {
   return apps;
 }
 async function extractVarNames(envPath) {
-  const content = await readFile9(envPath, "utf-8");
+  const content = await readFile11(envPath, "utf-8");
   const vars = [];
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -3270,38 +3618,38 @@ function generateManifest(apps) {
 }
 async function initManifestCommand() {
   const projectRoot = resolve5(process.cwd());
-  const manifestPath = join13(projectRoot, "docs", "reference", "env-manifest.md");
+  const manifestPath = join15(projectRoot, "docs", "reference", "env-manifest.md");
   if (existsSync12(manifestPath)) {
-    console.log(chalk19.yellow(`Manifest already exists: ${relative3(projectRoot, manifestPath)}`));
-    console.log(chalk19.dim("Edit it directly to make changes."));
+    console.log(chalk21.yellow(`Manifest already exists: ${relative4(projectRoot, manifestPath)}`));
+    console.log(chalk21.dim("Edit it directly to make changes."));
     return;
   }
-  console.log(chalk19.blue("Scanning for .env files...\n"));
+  console.log(chalk21.blue("Scanning for .env files...\n"));
   const apps = await discoverEnvFiles(projectRoot);
   if (apps.length === 0) {
-    console.log(chalk19.yellow("No .env files found. Create a manifest manually at:"));
-    console.log(chalk19.cyan(`  docs/reference/env-manifest.md`));
+    console.log(chalk21.yellow("No .env files found. Create a manifest manually at:"));
+    console.log(chalk21.cyan(`  docs/reference/env-manifest.md`));
     return;
   }
   for (const app of apps) {
-    console.log(`  ${chalk19.green(app.name)}: ${app.envFilePath} (${app.vars.length} vars)`);
+    console.log(`  ${chalk21.green(app.name)}: ${app.envFilePath} (${app.vars.length} vars)`);
   }
   const content = generateManifest(apps);
-  const dir = dirname3(manifestPath);
+  const dir = dirname4(manifestPath);
   if (!existsSync12(dir)) {
     await mkdir4(dir, { recursive: true });
   }
   await writeFile5(manifestPath, content, "utf-8");
-  console.log(chalk19.green(`
-Manifest created: ${relative3(projectRoot, manifestPath)}`));
-  console.log(chalk19.dim("Review and edit the file \u2014 it is your source of truth."));
-  console.log(chalk19.dim("Then run `md4ai scan` to verify against your environments."));
+  console.log(chalk21.green(`
+Manifest created: ${relative4(projectRoot, manifestPath)}`));
+  console.log(chalk21.dim("Review and edit the file \u2014 it is your source of truth."));
+  console.log(chalk21.dim("Then run `md4ai scan` to verify against your environments."));
 }
 
 // dist/commands/update.js
 init_check_update();
 init_config();
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 import { execFileSync as execFileSync6, spawn } from "node:child_process";
 async function fetchLatestVersion() {
   try {
@@ -3350,13 +3698,13 @@ function spawnPostUpdate() {
 }
 async function postUpdateFlow() {
   const { confirm: confirm4 } = await import("@inquirer/prompts");
-  console.log(chalk20.green(`
+  console.log(chalk22.green(`
   md4ai v${CURRENT_VERSION} \u2014 you're on the latest version.
 `));
   const creds = await loadCredentials();
   const isLoggedIn = !!creds?.accessToken && Date.now() < creds.expiresAt;
   if (!isLoggedIn) {
-    console.log(chalk20.yellow("  You are not logged in.\n"));
+    console.log(chalk22.yellow("  You are not logged in.\n"));
     const wantLogin = await confirm4({
       message: "Log in now?",
       default: true
@@ -3367,7 +3715,7 @@ async function postUpdateFlow() {
       await loginCommand2();
       console.log("");
     } else {
-      console.log(chalk20.dim("\nRun md4ai login when you're ready.\n"));
+      console.log(chalk22.dim("\nRun md4ai login when you're ready.\n"));
       return;
     }
   }
@@ -3401,7 +3749,7 @@ async function postUpdateFlow() {
     const { mcpWatchCommand: mcpWatchCommand2 } = await Promise.resolve().then(() => (init_mcp_watch(), mcp_watch_exports));
     await mcpWatchCommand2();
   } else {
-    console.log(chalk20.dim("\nYou can start monitoring later with: md4ai mcp-watch\n"));
+    console.log(chalk22.dim("\nYou can start monitoring later with: md4ai mcp-watch\n"));
   }
 }
 async function updateCommand(options) {
@@ -3409,19 +3757,19 @@ async function updateCommand(options) {
     await postUpdateFlow();
     return;
   }
-  console.log(chalk20.blue(`
+  console.log(chalk22.blue(`
   Current version: v${CURRENT_VERSION}`));
-  console.log(chalk20.dim("  Checking for updates...\n"));
+  console.log(chalk22.dim("  Checking for updates...\n"));
   const latest = await fetchLatestVersion();
   if (!latest) {
-    console.log(chalk20.yellow("  Could not reach the npm registry. Check your internet connection."));
+    console.log(chalk22.yellow("  Could not reach the npm registry. Check your internet connection."));
     process.exit(1);
   }
   if (!isNewer2(latest, CURRENT_VERSION)) {
     await postUpdateFlow();
     return;
   }
-  console.log(chalk20.white("  Update available: ") + chalk20.dim(`v${CURRENT_VERSION}`) + chalk20.white(" \u2192 ") + chalk20.green.bold(`v${latest}
+  console.log(chalk22.white("  Update available: ") + chalk22.dim(`v${CURRENT_VERSION}`) + chalk22.white(" \u2192 ") + chalk22.green.bold(`v${latest}
 `));
   const { confirm: confirm4 } = await import("@inquirer/prompts");
   const wantUpdate = await confirm4({
@@ -3429,20 +3777,38 @@ async function updateCommand(options) {
     default: true
   });
   if (!wantUpdate) {
-    console.log(chalk20.dim("\nUpdate skipped.\n"));
+    console.log(chalk22.dim("\nUpdate skipped.\n"));
     return;
   }
-  console.log(chalk20.blue("\n  Installing...\n"));
+  console.log(chalk22.blue("\n  Installing...\n"));
   const ok = runNpmInstall();
   if (!ok) {
-    console.log(chalk20.red("\n  npm install failed. Try running manually:"));
-    console.log(chalk20.cyan("    npm install -g md4ai\n"));
+    console.log(chalk22.red("\n  npm install failed. Try running manually:"));
+    console.log(chalk22.cyan("    npm install -g md4ai\n"));
     process.exit(1);
   }
-  console.log(chalk20.green("\n  Updated successfully.\n"));
+  console.log(chalk22.green("\n  Updated successfully.\n"));
   spawnPostUpdate();
 }
 
+// dist/commands/config.js
+init_config();
+import chalk23 from "chalk";
+var ALLOWED_KEYS = ["vercel-token"];
+var KEY_MAP = {
+  "vercel-token": "vercelToken"
+};
+async function configSetCommand(key, value) {
+  if (!ALLOWED_KEYS.includes(key)) {
+    console.error(chalk23.red(`Unknown config key: ${key}`));
+    console.log(`  Allowed keys: ${ALLOWED_KEYS.join(", ")}`);
+    process.exit(1);
+  }
+  const credKey = KEY_MAP[key];
+  await mergeCredentials({ [credKey]: value });
+  console.log(chalk23.green(`Saved ${key}.`));
+}
+
 // dist/index.js
 init_check_update();
 var program = new Command();
@@ -3465,6 +3831,8 @@ program.command("update").description("Check for updates, install, and optionall
 program.command("check-update").description("Check if a newer version of md4ai is available").action(checkForUpdate);
 program.command("mcp-watch").description("Monitor MCP server status on this device (runs until Ctrl+C)").action(mcpWatchCommand);
 program.command("init-manifest").description("Scaffold a starter env-manifest.md from detected .env files").action(initManifestCommand);
+var config = program.command("config").description("Manage CLI configuration");
+config.command("set <key> <value>").description("Set a configuration value (e.g. vercel-token)").action(configSetCommand);
 var admin = program.command("admin").description("Admin commands for managing the tools registry");
 admin.command("update-tool").description("Add or update a tool in the master registry").requiredOption("--name <name>", "Canonical tool name (e.g. next, playwright)").option("--display <display>", 'Human-friendly display name (e.g. "Next.js")').option("--category <category>", "Tool category (framework|runtime|cli|mcp|package|database|other)").option("--stable <version>", "Latest stable version").option("--beta <version>", "Latest beta/RC version").option("--source <url>", "Source of truth URL for checking versions").option("--install <url>", "Download/install link").option("--notes <text>", "Compatibility notes or warnings").action(adminUpdateToolCommand);
 admin.command("list-tools").description("List all tools in the master registry").action(adminListToolsCommand);