helixevo 0.2.40 → 0.2.41

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to HelixEvo are documented here.
 
+## [0.2.41] - 2026-03-23
+
+### Added
+- `helixevo dashboard` now checks npm for a newer HelixEvo release before launch and automatically updates itself before opening the dashboard
+- New `helixevo dashboard --no-auto-update` flag for users who want to skip the automatic update check
+
+### Changed
+- Dashboard launch messages now use the resolved current version more consistently after updates or relaunches
+- Commands and Guide reference pages now document the dashboard auto-update behavior and opt-out flag
+
 ## [0.2.40] - 2026-03-23
 
 ### Added

package/dashboard/app/commands/page.tsx

@@ -225,14 +225,21 @@ const COMMANDS: CommandInfo[] = [
   },
   {
     name: 'dashboard',
-    description: 'Launch the web dashboard at http://localhost:3847. Provides a visual interface for monitoring skills, evolution, frontier, and network health.',
-    usage: 'helixevo dashboard',
+    description: 'Launch the web dashboard at http://localhost:3847. When a newer npm version is available, HelixEvo now auto-updates itself before opening the dashboard unless you opt out.',
+    usage: 'helixevo dashboard [options]',
     examples: [
-      { cmd: 'helixevo dashboard', desc: 'Open the dashboard in your browser' },
+      { cmd: 'helixevo dashboard', desc: 'Auto-update to the latest version if needed, then open the dashboard' },
+      { cmd: 'helixevo dashboard --background', desc: 'Run the dashboard in the background after the same update check' },
+      { cmd: 'helixevo dashboard --no-auto-update', desc: 'Open the dashboard immediately without checking npm for updates' },
+    ],
+    options: [
+      { flag: '--background', desc: 'Run the dashboard detached from the terminal' },
+      { flag: '--stop', desc: 'Stop a background dashboard process' },
+      { flag: '--no-auto-update', desc: 'Skip the automatic update check before launch' },
     ],
     category: 'system',
     needsLLM: false,
-    note: 'You are currently using the dashboard!',
+    note: 'You are currently using the dashboard. By default it now upgrades itself first when a newer release is available.',
   },
 ]
 

package/dashboard/app/guide/page.tsx

@@ -450,8 +450,8 @@ helixevo status`}</Code>
               },
               {
                 cmd: 'helixevo dashboard',
-                desc: 'Open the interactive web dashboard at localhost:3847. Shows overview, skill network, evolution timeline, research, and frontier.',
-                flags: [],
+                desc: 'Open the interactive web dashboard at localhost:3847. Before launch, HelixEvo checks npm for a newer version and auto-updates itself unless you opt out.',
+                flags: ['--background', '--stop', '--no-auto-update'],
               },
               {
                 cmd: 'helixevo status',

package/dist/cli.js

@@ -12443,15 +12443,126 @@ ${replay.slice(0, 800)}`
 
 // src/commands/dashboard.ts
 import { execSync as execSync2, spawn as spawn2 } from "node:child_process";
-import { join as join15, dirname as dirname3 } from "node:path";
-import { existsSync as existsSync10, cpSync as cpSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join16, dirname as dirname3 } from "node:path";
+import { existsSync as existsSync11, cpSync as cpSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 init_skills();
 init_data();
+
+// src/utils/update-check.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join15 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var HELIX_DIR2 = join15(homedir3(), ".helix");
+var CACHE_PATH = join15(HELIX_DIR2, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+var REGISTRY_URL = "https://registry.npmjs.org/helixevo/latest";
+function readCache() {
+  try {
+    if (!existsSync10(CACHE_PATH))
+      return null;
+    return JSON.parse(readFileSync8(CACHE_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    if (!existsSync10(HELIX_DIR2))
+      mkdirSync4(HELIX_DIR2, { recursive: true });
+    writeFileSync9(CACHE_PATH, JSON.stringify(cache));
+  } catch {}
+}
+function hasNewerVersion(current, latest) {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0))
+      return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0))
+      return false;
+  }
+  return false;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getUpdateInfo(currentVersion = VERSION, forceRefresh = false) {
+  const cache = forceRefresh ? null : readCache();
+  if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      hasUpdate: hasNewerVersion(currentVersion, cache.latestVersion),
+      source: "cache"
+    };
+  }
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    return {
+      currentVersion,
+      latestVersion: cache?.latestVersion ?? null,
+      hasUpdate: cache ? hasNewerVersion(currentVersion, cache.latestVersion) : false,
+      source: cache ? "cache" : "none"
+    };
+  }
+  writeCache({ lastCheck: Date.now(), latestVersion: latest });
+  return {
+    currentVersion,
+    latestVersion: latest,
+    hasUpdate: hasNewerVersion(currentVersion, latest),
+    source: "network"
+  };
+}
+async function checkForUpdates() {
+  try {
+    const update = await getUpdateInfo(VERSION);
+    if (update.hasUpdate && update.latestVersion) {
+      printUpdateBanner(update.currentVersion, update.latestVersion);
+    }
+  } catch {}
+}
+function printUpdateBanner(currentVersion, latestVersion) {
+  const yellow = "\x1B[33m";
+  const green = "\x1B[32m";
+  const cyan = "\x1B[36m";
+  const bold = "\x1B[1m";
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  console.log();
+  console.log(`${yellow}  ╭──────────────────────────────────────────────╮${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  │  ${bold}Update available!${reset}${yellow}  ${dim}v${currentVersion}${reset}${yellow} → ${green}${bold}v${latestVersion}${reset}${yellow}          │${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  │  ${reset}Run ${cyan}npm install -g helixevo@latest${reset}${yellow}        │${reset}`);
+  console.log(`${yellow}  │  ${reset}to update${yellow}                                   │${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  ╰──────────────────────────────────────────────╯${reset}`);
+  console.log();
+}
+
+// src/commands/dashboard.ts
 var __filename = "/Users/tianchichen/Documents/GitHub/helixevo/src/commands/dashboard.ts";
-var HELIX_DASHBOARD_DIR = join15(homedir3(), ".helix", "dashboard");
+var HELIX_DASHBOARD_DIR = join16(homedir4(), ".helix", "dashboard");
+var DASHBOARD_SKIP_AUTO_UPDATE_ENV = "HELIXEVO_DASHBOARD_SKIP_AUTO_UPDATE";
 async function dashboardCommand(options) {
+  if (options.autoUpdate !== false && process.env[DASHBOARD_SKIP_AUTO_UPDATE_ENV] !== "1" && !findDevDashboard()) {
+    const didRelaunch = await maybeAutoUpdateAndRelaunch(options);
+    if (didRelaunch)
+      return;
+  }
   const dir = prepareDashboard();
   if (!dir) {
     console.error(`  Dashboard not found.
@@ -12461,7 +12572,7 @@ async function dashboardCommand(options) {
     console.error("    cd helixevo/dashboard && npm install && npx next dev --port 3847");
     process.exit(1);
   }
-  if (!existsSync10(join15(dir, "node_modules"))) {
+  if (!existsSync11(join16(dir, "node_modules"))) {
     console.log("  Installing dashboard dependencies...");
     try {
       execSync2("npm install --no-audit --no-fund", { cwd: dir, stdio: "inherit" });
@@ -12474,22 +12585,22 @@ async function dashboardCommand(options) {
   }
   ensureSkillGraph();
   if (options.background) {
-    const logFile = join15(homedir3(), ".helix", "dashboard.log");
+    const logFile = join16(homedir4(), ".helix", "dashboard.log");
     const out = __require("fs").openSync(logFile, "a");
     const err = __require("fs").openSync(logFile, "a");
-    let currentVersion = VERSION;
+    let currentVersion2 = VERSION;
     try {
-      currentVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
+      currentVersion2 = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
     } catch {}
     const child = spawn2("npx", ["next", "dev", "--port", "3847"], {
       cwd: dir,
       stdio: ["ignore", out, err],
-      env: { ...process.env, HELIXEVO_VERSION: currentVersion },
+      env: { ...process.env, HELIXEVO_VERSION: currentVersion2 },
       detached: true
     });
     child.unref();
-    writeFileSync9(join15(homedir3(), ".helix", "dashboard.pid"), String(child.pid));
-    console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${VERSION} running in background`);
+    writeFileSync10(join16(homedir4(), ".helix", "dashboard.pid"), String(child.pid));
+    console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${currentVersion2} running in background`);
     console.log(`     http://localhost:3847`);
     console.log(`     Logs: ${logFile}`);
     console.log(`     Stop: helixevo dashboard --stop
@@ -12503,10 +12614,54 @@ async function dashboardCommand(options) {
     }, 2000);
     process.exit(0);
   }
-  console.log(`  \uD83C\uDF10 Starting HelixEvo Dashboard v${VERSION} at http://localhost:3847
+  let currentVersion = VERSION;
+  try {
+    currentVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
+  } catch {}
+  console.log(`  \uD83C\uDF10 Starting HelixEvo Dashboard v${currentVersion} at http://localhost:3847
 `);
   launchDashboard(dir, true);
 }
+async function maybeAutoUpdateAndRelaunch(options) {
+  const update = await getUpdateInfo(VERSION);
+  if (!update.hasUpdate || !update.latestVersion)
+    return false;
+  console.log(`  ⟳ New HelixEvo version detected: v${VERSION} → v${update.latestVersion}`);
+  console.log(`  Updating before launching dashboard...
+`);
+  try {
+    execSync2("npm install -g helixevo@latest", {
+      stdio: "inherit",
+      timeout: 120000,
+      env: { ...process.env }
+    });
+  } catch {
+    console.warn(`
+  Auto-update failed. Continuing with the current installed version.
+`);
+    return false;
+  }
+  console.log(`
+  ✓ Updated to v${update.latestVersion}. Relaunching dashboard...
+`);
+  const executable = process.platform === "win32" ? "helixevo.cmd" : "helixevo";
+  const args = ["dashboard"];
+  if (options.background)
+    args.push("--background");
+  if (options.autoUpdate === false)
+    args.push("--no-auto-update");
+  await new Promise((resolve, reject) => {
+    const child = spawn2(executable, args, {
+      stdio: "inherit",
+      env: { ...process.env, [DASHBOARD_SKIP_AUTO_UPDATE_ENV]: "1" }
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return true;
+}
 var RESTART_EXIT_CODE = 75;
 function launchDashboard(dir, openBrowser) {
   let currentVersion = VERSION;
@@ -12533,8 +12688,8 @@ function launchDashboard(dir, openBrowser) {
   \uD83D\uDD04 Restarting dashboard after update...
 `);
       setTimeout(() => {
-        const nextCache = join15(dir, ".next");
-        if (existsSync10(nextCache)) {
+        const nextCache = join16(dir, ".next");
+        if (existsSync11(nextCache)) {
           try {
             rmSync2(nextCache, { recursive: true });
           } catch {}
@@ -12560,20 +12715,20 @@ function prepareDashboard() {
   const npmSource = findNpmDashboard();
   if (npmSource)
     return copyToHelix(npmSource);
-  if (existsSync10(join15(HELIX_DASHBOARD_DIR, "package.json"))) {
+  if (existsSync11(join16(HELIX_DASHBOARD_DIR, "package.json"))) {
     return HELIX_DASHBOARD_DIR;
   }
   return null;
 }
 function findDevDashboard() {
   const candidates = [
-    join15(process.cwd(), "dashboard")
+    join16(process.cwd(), "dashboard")
   ];
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  candidates.push(join15(home, "Documents", "GitHub", "helixevo", "dashboard"));
-  candidates.push(join15(home, "Documents", "GitHub", "skillgraph", "dashboard"));
+  candidates.push(join16(home, "Documents", "GitHub", "helixevo", "dashboard"));
+  candidates.push(join16(home, "Documents", "GitHub", "skillgraph", "dashboard"));
   for (const dir of candidates) {
-    if (existsSync10(join15(dir, "package.json")) && !dir.includes("node_modules")) {
+    if (existsSync11(join16(dir, "package.json")) && !dir.includes("node_modules")) {
       return dir;
     }
   }
@@ -12584,15 +12739,15 @@ function findNpmDashboard() {
   try {
     const thisFile = typeof __filename !== "undefined" ? __filename : fileURLToPath2(import.meta.url);
     const pkgRoot = dirname3(dirname3(thisFile));
-    candidates.push(join15(pkgRoot, "dashboard"));
+    candidates.push(join16(pkgRoot, "dashboard"));
   } catch {}
   try {
     const globalPrefix = execSync2("npm prefix -g", { encoding: "utf-8" }).trim();
-    candidates.push(join15(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
-    candidates.push(join15(globalPrefix, "node_modules", "helixevo", "dashboard"));
+    candidates.push(join16(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
+    candidates.push(join16(globalPrefix, "node_modules", "helixevo", "dashboard"));
   } catch {}
   for (const dir of candidates) {
-    if (existsSync10(join15(dir, "package.json"))) {
+    if (existsSync11(join16(dir, "package.json"))) {
       return dir;
     }
   }
@@ -12600,10 +12755,10 @@ function findNpmDashboard() {
 }
 function getInstalledDashboardVersion() {
   try {
-    const versionFile = join15(HELIX_DASHBOARD_DIR, ".helixevo-version");
-    if (!existsSync10(versionFile))
+    const versionFile = join16(HELIX_DASHBOARD_DIR, ".helixevo-version");
+    if (!existsSync11(versionFile))
       return null;
-    return readFileSync8(versionFile, "utf-8").trim();
+    return readFileSync9(versionFile, "utf-8").trim();
   } catch {
     return null;
   }
@@ -12611,8 +12766,8 @@ function getInstalledDashboardVersion() {
 function copyToHelix(sourceDir) {
   let sourceVersion = VERSION;
   try {
-    const srcRoot = join15(sourceDir, "..", "package.json");
-    const pkg2 = JSON.parse(readFileSync8(srcRoot, "utf-8"));
+    const srcRoot = join16(sourceDir, "..", "package.json");
+    const pkg2 = JSON.parse(readFileSync9(srcRoot, "utf-8"));
     if (pkg2.name === "helixevo" && pkg2.version)
       sourceVersion = pkg2.version;
   } catch {}
@@ -12625,11 +12780,11 @@ function copyToHelix(sourceDir) {
   } else {
     console.log("  Setting up dashboard at ~/.helix/dashboard...");
   }
-  mkdirSync4(HELIX_DASHBOARD_DIR, { recursive: true });
+  mkdirSync5(HELIX_DASHBOARD_DIR, { recursive: true });
   let depsChanged = true;
   try {
-    const srcDeps = readFileSync8(join15(sourceDir, "package.json"), "utf-8");
-    const dstDeps = readFileSync8(join15(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
+    const srcDeps = readFileSync9(join16(sourceDir, "package.json"), "utf-8");
+    const dstDeps = readFileSync9(join16(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
     const srcPkg = JSON.parse(srcDeps);
     const dstPkg = JSON.parse(dstDeps);
     depsChanged = JSON.stringify(srcPkg.dependencies) !== JSON.stringify(dstPkg.dependencies) || JSON.stringify(srcPkg.devDependencies) !== JSON.stringify(dstPkg.devDependencies);
@@ -12640,22 +12795,22 @@ function copyToHelix(sourceDir) {
   for (const item of items) {
     if (item.name === "node_modules" || item.name === ".next" || item.name === "package-lock.json" || item.name === ".env.local")
       continue;
-    const src = join15(sourceDir, item.name);
-    const dest = join15(HELIX_DASHBOARD_DIR, item.name);
+    const src = join16(sourceDir, item.name);
+    const dest = join16(HELIX_DASHBOARD_DIR, item.name);
     cpSync3(src, dest, { recursive: true });
   }
   if (depsChanged) {
-    const oldModules = join15(HELIX_DASHBOARD_DIR, "node_modules");
-    if (existsSync10(oldModules))
+    const oldModules = join16(HELIX_DASHBOARD_DIR, "node_modules");
+    if (existsSync11(oldModules))
       rmSync2(oldModules, { recursive: true });
-    const oldLock = join15(HELIX_DASHBOARD_DIR, "package-lock.json");
-    if (existsSync10(oldLock))
+    const oldLock = join16(HELIX_DASHBOARD_DIR, "package-lock.json");
+    if (existsSync11(oldLock))
       rmSync2(oldLock);
   }
-  const nextCache = join15(HELIX_DASHBOARD_DIR, ".next");
-  if (existsSync10(nextCache))
+  const nextCache = join16(HELIX_DASHBOARD_DIR, ".next");
+  if (existsSync11(nextCache))
     rmSync2(nextCache, { recursive: true });
-  writeFileSync9(join15(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
+  writeFileSync10(join16(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
   return HELIX_DASHBOARD_DIR;
 }
 function ensureSkillGraph() {
@@ -12697,13 +12852,13 @@ function ensureSkillGraph() {
 }
 
 // src/commands/watch.ts
-import { join as join17 } from "node:path";
-import { existsSync as existsSync13 } from "node:fs";
+import { join as join18 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
 
 // src/core/auto-capture.ts
 init_data();
 init_llm();
-import { readFileSync as readFileSync9, existsSync as existsSync11, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync10, existsSync as existsSync12, statSync as statSync2 } from "node:fs";
 var CORRECTION_SIGNALS = [
   /\bno[, ]+(?:that's|thats|that is)\s+(?:wrong|incorrect|not right)/i,
   /\bdon'?t\s+do\s+(?:that|it\s+like\s+that)/i,
@@ -12791,17 +12946,17 @@ If no corrections found, return: { "corrections": [] }`
 }
 function watchEvents(options) {
   const { eventsPath, project, onCapture, onError, pollIntervalMs = 5000 } = options;
-  let lastSize = existsSync11(eventsPath) ? statSync2(eventsPath).size : 0;
+  let lastSize = existsSync12(eventsPath) ? statSync2(eventsPath).size : 0;
   let messageBuffer = [];
   let pendingExtraction = false;
   const interval = setInterval(async () => {
     try {
-      if (!existsSync11(eventsPath))
+      if (!existsSync12(eventsPath))
         return;
       const currentSize = statSync2(eventsPath).size;
       if (currentSize <= lastSize)
         return;
-      const content = readFileSync9(eventsPath, "utf-8");
+      const content = readFileSync10(eventsPath, "utf-8");
       const lines = content.trim().split(`
 `).filter(Boolean);
       const newLines = lines.slice(messageBuffer.length);
@@ -12843,22 +12998,22 @@ init_data();
 // src/core/metrics.ts
 init_config();
 init_data();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync12 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
+import { join as join17 } from "node:path";
 function getMetricsPath() {
-  return join16(getHelixDir(), "metrics.json");
+  return join17(getHelixDir(), "metrics.json");
 }
 function loadMetrics() {
   const path = getMetricsPath();
-  if (!existsSync12(path)) {
+  if (!existsSync13(path)) {
     return { updated: new Date().toISOString(), skills: [], globalCorrectionRate: [], evolutionImpact: [] };
   }
-  return JSON.parse(readFileSync10(path, "utf-8"));
+  return JSON.parse(readFileSync11(path, "utf-8"));
 }
 function saveMetrics(store) {
   ensureDir(getHelixDir());
   store.updated = new Date().toISOString();
-  writeFileSync10(getMetricsPath(), JSON.stringify(store, null, 2));
+  writeFileSync11(getMetricsPath(), JSON.stringify(store, null, 2));
 }
 function updateMetrics() {
   const failures = loadFailures();
@@ -13033,14 +13188,14 @@ async function watchCommand(options) {
   const verbose = options.verbose ?? false;
   const autoEvolve = options.evolve !== false;
   const project = options.project ?? null;
-  const eventsPath = options.events ?? join17(process.cwd(), "events.jsonl");
+  const eventsPath = options.events ?? join18(process.cwd(), "events.jsonl");
   console.log(`\uD83E\uDDEC HelixEvo Watch Mode — Always-On Learning
 `);
   console.log(`  Events:      ${eventsPath}`);
   console.log(`  Project:     ${project ?? "(auto-detect)"}`);
   console.log(`  Auto-evolve: ${autoEvolve ? "ON" : "OFF"}`);
   console.log();
-  if (!existsSync13(eventsPath)) {
+  if (!existsSync14(eventsPath)) {
     console.log(`  ⚠ Events file not found yet. Will start watching when it appears.`);
     console.log(`  Expected at: ${eventsPath}
 `);
@@ -13190,8 +13345,8 @@ async function metricsCommand(options) {
 // src/commands/project-setup.ts
 init_skills();
 init_llm();
-import { join as join18 } from "node:path";
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "node:fs";
+import { join as join19 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "node:fs";
 
 // src/prompts/project-analysis.ts
 function buildProjectAnalysisPrompt(projectContext, skills) {
@@ -13272,10 +13427,10 @@ function readProjectContext(projectPath) {
     "Dockerfile"
   ];
   for (const f of filesToRead) {
-    const p = join18(projectPath, f);
-    if (existsSync14(p)) {
+    const p = join19(projectPath, f);
+    if (existsSync15(p)) {
       try {
-        const content = readFileSync11(p, "utf-8");
+        const content = readFileSync12(p, "utf-8");
         contextFiles.push({ name: f, content: content.slice(0, 2000) });
       } catch {}
     }
@@ -13287,8 +13442,8 @@ function readProjectContext(projectPath) {
 `);
   } catch {}
   let srcStructure = "";
-  const srcDir = join18(projectPath, "src");
-  if (existsSync14(srcDir)) {
+  const srcDir = join19(projectPath, "src");
+  if (existsSync15(srcDir)) {
     try {
       const scanDir = (dir, prefix, depth) => {
         if (depth > 2)
@@ -13298,7 +13453,7 @@ function readProjectContext(projectPath) {
         for (const item of items) {
           lines.push(`${prefix}${item.isDirectory() ? "\uD83D\uDCC1" : "\uD83D\uDCC4"} ${item.name}`);
           if (item.isDirectory()) {
-            lines.push(...scanDir(join18(dir, item.name), prefix + "  ", depth + 1));
+            lines.push(...scanDir(join19(dir, item.name), prefix + "  ", depth + 1));
           }
         }
         return lines;
@@ -13332,18 +13487,18 @@ ${f.content}
   return context;
 }
 function getProjectsDir() {
-  return join18(getHelixDir(), "projects");
+  return join19(getHelixDir(), "projects");
 }
 function saveProjectProfile(profile) {
-  const dir = join18(getProjectsDir(), profile.name);
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync11(join18(dir, "profile.json"), JSON.stringify(profile, null, 2));
+  const dir = join19(getProjectsDir(), profile.name);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync12(join19(dir, "profile.json"), JSON.stringify(profile, null, 2));
 }
 async function projectSetupCommand(projectPath, options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
-  const resolvedPath = join18(process.cwd(), projectPath).replace(/\/$/, "");
-  if (!existsSync14(resolvedPath)) {
+  const resolvedPath = join19(process.cwd(), projectPath).replace(/\/$/, "");
+  if (!existsSync15(resolvedPath)) {
     console.error(`  ✗ Path not found: ${resolvedPath}`);
     process.exit(1);
   }
@@ -13428,92 +13583,6 @@ async function projectSetupCommand(projectPath, options) {
   console.log();
 }
 
-// src/utils/update-check.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join19 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-var HELIX_DIR2 = join19(homedir4(), ".helix");
-var CACHE_PATH = join19(HELIX_DIR2, "update-check.json");
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-var REGISTRY_URL = "https://registry.npmjs.org/helixevo/latest";
-function readCache() {
-  try {
-    if (!existsSync15(CACHE_PATH))
-      return null;
-    return JSON.parse(readFileSync12(CACHE_PATH, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeCache(cache) {
-  try {
-    if (!existsSync15(HELIX_DIR2))
-      mkdirSync6(HELIX_DIR2, { recursive: true });
-    writeFileSync12(CACHE_PATH, JSON.stringify(cache));
-  } catch {}
-}
-function compareVersions(current, latest) {
-  const c = current.split(".").map(Number);
-  const l = latest.split(".").map(Number);
-  for (let i = 0;i < 3; i++) {
-    if ((l[i] ?? 0) > (c[i] ?? 0))
-      return true;
-    if ((l[i] ?? 0) < (c[i] ?? 0))
-      return false;
-  }
-  return false;
-}
-async function fetchLatestVersion() {
-  try {
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (!res.ok)
-      return null;
-    const data = await res.json();
-    return data.version ?? null;
-  } catch {
-    return null;
-  }
-}
-async function checkForUpdates() {
-  try {
-    const cache = readCache();
-    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
-      if (compareVersions(VERSION, cache.latestVersion)) {
-        printUpdateBanner(cache.latestVersion);
-      }
-      return;
-    }
-    const latest = await fetchLatestVersion();
-    if (!latest)
-      return;
-    writeCache({ lastCheck: Date.now(), latestVersion: latest });
-    if (compareVersions(VERSION, latest)) {
-      printUpdateBanner(latest);
-    }
-  } catch {}
-}
-function printUpdateBanner(latestVersion) {
-  const yellow = "\x1B[33m";
-  const green = "\x1B[32m";
-  const cyan = "\x1B[36m";
-  const bold = "\x1B[1m";
-  const dim = "\x1B[2m";
-  const reset = "\x1B[0m";
-  console.log();
-  console.log(`${yellow}  ╭──────────────────────────────────────────────╮${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  │  ${bold}Update available!${reset}${yellow}  ${dim}v${VERSION}${reset}${yellow} → ${green}${bold}v${latestVersion}${reset}${yellow}          │${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  │  ${reset}Run ${cyan}npm install -g helixevo@latest${reset}${yellow}        │${reset}`);
-  console.log(`${yellow}  │  ${reset}to update${yellow}                                   │${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  ╰──────────────────────────────────────────────╯${reset}`);
-  console.log();
-}
-
 // src/cli.ts
 import { join as join20 } from "node:path";
 import { homedir as homedir5 } from "node:os";
@@ -13545,7 +13614,7 @@ program2.command("generalize").description("Promote cross-skill patterns to high
 program2.command("specialize").description("Create project-specific skills ↓ --project <name> [--dry-run] [--verbose]").requiredOption("--project <name>", "Project name").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(specializeCommand);
 program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
 program2.command("research").description("Proactive research via web [--project <path>] [--dry-run] [--verbose]").option("--project <path>", "Project path for goal extraction").option("--dry-run", "Show discoveries without creating skills").option("--verbose", "Show detailed research steps").option("--max-hypotheses <n>", "Max hypotheses to test", "3").action(researchCommand);
-program2.command("dashboard").description("Open web dashboard at http://localhost:3847").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").action(async (options) => {
+program2.command("dashboard").description("Open web dashboard at http://localhost:3847").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").option("--no-auto-update", "Skip automatic update check before launching the dashboard").action(async (options) => {
   if (options.stop) {
     const pidFile = join20(homedir5(), ".helix", "dashboard.pid");
     if (existsSync16(pidFile)) {
@@ -13560,7 +13629,7 @@ program2.command("dashboard").description("Open web dashboard at http://localhos
     }
     return;
   }
-  dashboardCommand(options);
+  await dashboardCommand(options);
 });
 program2.command("status").description("Show frontier, skills, failures, and network health").action(statusCommand);
 program2.command("report").description("Evolution report [--days <n>] [--output <path>]").option("--days <n>", "Report period in days", "1").option("--output <path>", "Output path for report").action(reportCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixevo",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "Self-evolving skill ecosystem for AI agents. Skills and projects co-evolve through multi-judge evaluation and a Pareto frontier.",
   "type": "module",
   "bin": {