@deeplake/hivemind 0.7.41 → 0.7.45

package/bundle/cli.js

@@ -144,23 +144,23 @@ function warn(msg) {
 function confirm(message, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(`${message} ${hint} `, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
       if (a === "")
-        resolve2(defaultYes);
+        resolve3(defaultYes);
       else
-        resolve2(a === "y" || a === "yes");
+        resolve3(a === "y" || a === "yes");
     });
   });
 }
 function promptLine(message) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(message, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve3(answer.trim());
     });
   });
 }
@@ -4745,7 +4745,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -4775,7 +4775,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve2) => this.waiting.push(resolve2));
+    await new Promise((resolve3) => this.waiting.push(resolve3));
   }
   release() {
     this.active--;
@@ -5417,25 +5417,202 @@ if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
   });
 }
 
-// dist/src/commands/skillify.js
-import { readdirSync as readdirSync5, existsSync as existsSync26, readFileSync as readFileSync22, mkdirSync as mkdirSync13, renameSync as renameSync7 } from "node:fs";
-import { homedir as homedir19 } from "node:os";
-import { dirname as dirname8, join as join32 } from "node:path";
+// dist/src/commands/dashboard.js
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync13 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname6, join as join27, resolve as resolve2 } from "node:path";
 
-// dist/src/skillify/scope-config.js
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join22 } from "node:path";
+// dist/src/dashboard/data.js
+import { existsSync as existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { homedir as homedir13 } from "node:os";
+import { join as join25 } from "node:path";
+
+// dist/src/notifications/sources/org-stats.js
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname3, join as join20 } from "node:path";
+var log5 = (msg) => log2("notifications-org-stats", msg);
+var FETCH_TIMEOUT_MS = 1500;
+var DEFAULT_API_URL3 = "https://api.deeplake.ai";
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function cacheFilePath() {
+  return join20(homedir10(), ".deeplake", "hivemind-stats-cache.json");
+}
+function cacheScopeKey(creds) {
+  return JSON.stringify({
+    apiUrl: creds.apiUrl ?? DEFAULT_API_URL3,
+    orgId: creds.orgId ?? "",
+    userName: creds.userName ?? ""
+  });
+}
+function scopeFromServer(s) {
+  const n = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+  return {
+    sessionsCount: n(s?.sessions_count),
+    memoryRecallCount: n(s?.memory_recall_count),
+    memorySearchBytes: n(s?.memory_search_bytes)
+  };
+}
+function readCache(scopeKey) {
+  if (!existsSync15(cacheFilePath()))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync15(cacheFilePath(), "utf-8"));
+    if (!parsed || typeof parsed !== "object")
+      return {};
+    if (parsed.scopeKey !== scopeKey)
+      return {};
+    if (typeof parsed.fetchedAt !== "number")
+      return {};
+    const age = Date.now() - parsed.fetchedAt;
+    const data = parsed.data;
+    if (!data || typeof data !== "object" || !data.org || !data.user)
+      return {};
+    if (age >= 0 && age < CACHE_TTL_MS)
+      return { fresh: data };
+    return { stale: data };
+  } catch (e) {
+    log5(`cache read failed: ${e?.message ?? String(e)}`);
+    return {};
+  }
+}
+function writeCache(scopeKey, data) {
+  try {
+    mkdirSync7(dirname3(cacheFilePath()), { recursive: true });
+    const body = { fetchedAt: Date.now(), scopeKey, data };
+    writeFileSync11(cacheFilePath(), JSON.stringify(body), "utf-8");
+  } catch (e) {
+    log5(`cache write failed: ${e?.message ?? String(e)}`);
+  }
+}
+async function fetchOrgStats(creds) {
+  if (!creds?.token)
+    return null;
+  const apiUrl = creds.apiUrl ?? DEFAULT_API_URL3;
+  const scopeKey = cacheScopeKey(creds);
+  const { fresh, stale } = readCache(scopeKey);
+  if (fresh) {
+    log5("cache hit \u2014 returning fresh org stats");
+    return fresh;
+  }
+  const url = `${apiUrl}/me/hivemind-stats`;
+  const ctrl = new AbortController();
+  const timeoutHandle = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${creds.token}`,
+        ...creds.orgId ? { "X-Activeloop-Org-Id": creds.orgId } : {}
+      },
+      signal: ctrl.signal
+    });
+    if (!resp.ok) {
+      log5(`fetch ${url} returned ${resp.status}`);
+      return stale ?? null;
+    }
+    const body = await resp.json();
+    if (!body || typeof body !== "object") {
+      log5(`fetch ${url} returned malformed body`);
+      return stale ?? null;
+    }
+    const data = {
+      org: scopeFromServer(body.org),
+      user: scopeFromServer(body.user)
+    };
+    writeCache(scopeKey, data);
+    log5(`fetched org stats from ${apiUrl}`);
+    return data;
+  } catch (e) {
+    log5(`fetch ${url} failed: ${e?.message ?? String(e)}`);
+    return stale ?? null;
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// dist/src/notifications/usage-tracker.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync2 } from "node:fs";
+import { dirname as dirname4, join as join21 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+var log6 = (msg) => log2("usage-tracker", msg);
+function statsFilePath() {
+  return join21(homedir11(), ".deeplake", "usage-stats.jsonl");
+}
+function readUsageRecords() {
+  try {
+    if (!existsSync16(statsFilePath()))
+      return [];
+    const raw = readFileSync16(statsFilePath(), "utf-8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      try {
+        const rec = JSON.parse(trimmed);
+        if (typeof rec.endedAt === "string" && typeof rec.sessionId === "string") {
+          out.push({
+            endedAt: rec.endedAt,
+            sessionId: rec.sessionId,
+            memorySearchBytes: typeof rec.memorySearchBytes === "number" ? rec.memorySearchBytes : 0,
+            memorySearchCount: typeof rec.memorySearchCount === "number" ? rec.memorySearchCount : 0
+          });
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch (e) {
+    log6(`readUsageRecords failed: ${e?.message ?? String(e)}`);
+    return [];
+  }
+}
+function sumMetric(records, key) {
+  let total = 0;
+  for (const r of records) {
+    const v = r[key];
+    if (typeof v === "number" && Number.isFinite(v))
+      total += v;
+  }
+  return total;
+}
+function countUserGeneratedSkills(userName) {
+  if (!userName)
+    return 0;
+  const dir = join21(homedir11(), ".claude", "skills");
+  if (!existsSync16(dir))
+    return 0;
+  const suffix = `--${userName}`;
+  try {
+    let count = 0;
+    for (const name of readdirSync2(dir)) {
+      const idx = name.lastIndexOf(suffix);
+      if (idx > 0 && idx + suffix.length === name.length)
+        count += 1;
+    }
+    return count;
+  } catch (e) {
+    log6(`countUserGeneratedSkills readdir failed: ${e?.message ?? String(e)}`);
+    return 0;
+  }
+}
+
+// dist/src/skillify/state.js
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync12, writeSync, mkdirSync as mkdirSync9, renameSync as renameSync5, rmdirSync, existsSync as existsSync18, lstatSync as lstatSync3, unlinkSync as unlinkSync8, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { execSync as execSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join as join24, basename } from "node:path";
 
 // dist/src/skillify/legacy-migration.js
-import { existsSync as existsSync15, renameSync as renameSync4 } from "node:fs";
-import { dirname as dirname3, join as join21 } from "node:path";
+import { existsSync as existsSync17, renameSync as renameSync4 } from "node:fs";
+import { dirname as dirname5, join as join23 } from "node:path";
 
 // dist/src/skillify/state-dir.js
-import { homedir as homedir10 } from "node:os";
-import { join as join20 } from "node:path";
+import { homedir as homedir12 } from "node:os";
+import { join as join22 } from "node:path";
 function getStateDir() {
   const override = process.env.HIVEMIND_STATE_DIR?.trim();
-  return override && override.length > 0 ? override : join20(homedir10(), ".deeplake", "state", "skillify");
+  return override && override.length > 0 ? override : join22(homedir12(), ".deeplake", "state", "skillify");
 }
 
 // dist/src/skillify/legacy-migration.js
@@ -5448,10 +5625,10 @@ function migrateLegacyStateDir() {
     return;
   attempted = true;
   const current = getStateDir();
-  const legacy = join21(dirname3(current), "skilify");
-  if (!existsSync15(legacy))
+  const legacy = join23(dirname5(current), "skilify");
+  if (!existsSync17(legacy))
     return;
-  if (existsSync15(current))
+  if (existsSync17(current))
     return;
   try {
     renameSync4(legacy, current);
@@ -5466,18 +5643,859 @@ function migrateLegacyStateDir() {
   }
 }
 
+// dist/src/skillify/state.js
+var YIELD_BUF = new Int32Array(new SharedArrayBuffer(4));
+var TRIGGER_THRESHOLD = (() => {
+  const n = Number(process.env.HIVEMIND_SKILLIFY_EVERY_N_TURNS ?? "");
+  return Number.isInteger(n) && n > 0 ? n : 20;
+})();
+var DEFAULT_PORTS = {
+  http: "80",
+  https: "443",
+  ssh: "22",
+  git: "9418"
+};
+function normalizeGitRemoteUrl(url) {
+  let s = url.trim();
+  const schemeMatch = s.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
+  if (schemeMatch)
+    s = s.slice(schemeMatch[0].length);
+  if (!scheme) {
+    const scp = s.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      s = `${scp[1]}/${scp[2]}`;
+  }
+  s = s.replace(/^[^@/]+@/, "");
+  if (scheme && DEFAULT_PORTS[scheme]) {
+    s = s.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
+  }
+  s = s.replace(/\.git\/?$/i, "");
+  s = s.replace(/\/+$/, "");
+  return s.toLowerCase();
+}
+function deriveProjectKey(cwd) {
+  const project = basename(cwd) || "unknown";
+  let signature = null;
+  try {
+    const raw = execSync2("git config --get remote.origin.url", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? cwd;
+  const key = createHash("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/dashboard/data.js
+var log7 = (msg) => log2("dashboard-data", msg);
+var BYTES_PER_TOKEN = 4;
+var SAVINGS_MULTIPLIER = 1.7;
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join25(homedir13(), ".hivemind", "graphs");
+}
+function bytesToSavedTokens(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0)
+    return 0;
+  const delivered = bytes / BYTES_PER_TOKEN;
+  return (SAVINGS_MULTIPLIER - 1) * delivered;
+}
+function resolveSnapshot(repoDir) {
+  const snapshotsDir = join25(repoDir, "snapshots");
+  if (!existsSync19(snapshotsDir))
+    return null;
+  let snapshotPath = null;
+  const pointer = join25(repoDir, "latest-commit.txt");
+  if (existsSync19(pointer)) {
+    try {
+      const sha = readFileSync18(pointer, "utf-8").trim();
+      if (sha) {
+        const candidate = join25(snapshotsDir, `${sha}.json`);
+        if (existsSync19(candidate))
+          snapshotPath = candidate;
+        else
+          log7(`latest-commit.txt points at missing ${sha}.json \u2014 scanning snapshots/`);
+      }
+    } catch (e) {
+      log7(`latest-commit.txt read failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (!snapshotPath) {
+    try {
+      const candidates = readdirSync3(snapshotsDir).filter((name) => name.endsWith(".json")).map((name) => {
+        const full = join25(snapshotsDir, name);
+        return { full, mtime: statSync3(full).mtimeMs };
+      }).sort((a, b) => b.mtime - a.mtime);
+      if (candidates.length > 0)
+        snapshotPath = candidates[0].full;
+    } catch (e) {
+      log7(`snapshots/ scan failed: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (!snapshotPath)
+    return null;
+  let raw;
+  try {
+    raw = readFileSync18(snapshotPath, "utf-8");
+  } catch (e) {
+    log7(`snapshot read failed: ${e?.message ?? String(e)}`);
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    log7(`snapshot parse failed: ${e?.message ?? String(e)}`);
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.nodes) || !Array.isArray(parsed.links)) {
+    log7("snapshot shape invalid (missing nodes/links arrays)");
+    return null;
+  }
+  return {
+    commitSha: parsed.graph?.commit_sha ?? null,
+    snapshotPath,
+    nodeCount: parsed.nodes.length,
+    edgeCount: parsed.links.length,
+    snapshot: parsed
+  };
+}
+async function loadKpis(creds) {
+  const userName = creds?.userName;
+  const skillsCreated = countUserGeneratedSkills(userName);
+  const records = readUsageRecords();
+  const localBytes = sumMetric(records, "memorySearchBytes");
+  const localCount = sumMetric(records, "memorySearchCount");
+  let orgStats = null;
+  if (creds?.token) {
+    try {
+      orgStats = await fetchOrgStats(creds);
+    } catch (e) {
+      log7(`fetchOrgStats threw: ${e?.message ?? String(e)}`);
+    }
+  }
+  if (orgStats) {
+    return {
+      tokensSaved: bytesToSavedTokens(orgStats.org.memorySearchBytes),
+      tokensSource: "org",
+      skillsCreated,
+      memorySearches: orgStats.org.memoryRecallCount,
+      sessionsCount: orgStats.org.sessionsCount,
+      userTokensSaved: bytesToSavedTokens(orgStats.user.memorySearchBytes)
+    };
+  }
+  if (records.length > 0) {
+    return {
+      tokensSaved: bytesToSavedTokens(localBytes),
+      tokensSource: "local",
+      skillsCreated,
+      memorySearches: localCount,
+      sessionsCount: records.length,
+      userTokensSaved: bytesToSavedTokens(localBytes)
+    };
+  }
+  return {
+    tokensSaved: null,
+    tokensSource: "none",
+    skillsCreated,
+    memorySearches: 0,
+    sessionsCount: null,
+    userTokensSaved: null
+  };
+}
+async function loadDashboardData(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const { key: repoKey, project: repoProject } = deriveProjectKey(cwd);
+  const repoDir = join25(opts.graphsHome ?? graphsRoot(), repoKey);
+  const graph = resolveSnapshot(repoDir);
+  const creds = opts.creds === void 0 ? loadCredentials() : opts.creds;
+  const kpis = await loadKpis(creds);
+  return {
+    repoKey,
+    repoProject,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    kpis,
+    graph
+  };
+}
+
+// dist/src/dashboard/open.js
+import { spawn } from "node:child_process";
+import { accessSync, constants as fsConstants, statSync as statSync4 } from "node:fs";
+import { platform as nodePlatform } from "node:os";
+import { delimiter, join as join26 } from "node:path";
+function resolveOpenPlatform() {
+  const p = nodePlatform();
+  if (p === "linux" || p === "darwin" || p === "win32")
+    return p;
+  return null;
+}
+function openCommandFor(p, path) {
+  switch (p) {
+    case "linux":
+      return { command: "xdg-open", args: [path] };
+    case "darwin":
+      return { command: "open", args: [path] };
+    case "win32":
+      return { command: "cmd", args: ["/c", "start", "", path] };
+  }
+}
+function findBinaryOnPath(name) {
+  const PATH = process.env.PATH ?? "";
+  if (!PATH)
+    return null;
+  const isWin = nodePlatform() === "win32";
+  const exts = isWin ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean) : [""];
+  for (const dir of PATH.split(delimiter)) {
+    if (!dir)
+      continue;
+    for (const ext of exts) {
+      const candidate = join26(dir, name + ext);
+      try {
+        const st = statSync4(candidate);
+        if (!st.isFile())
+          continue;
+        if (isWin)
+          return candidate;
+        try {
+          accessSync(candidate, fsConstants.X_OK);
+          return candidate;
+        } catch {
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function openInBrowser(path, opts = {}) {
+  const p = opts.platformOverride === void 0 ? resolveOpenPlatform() : opts.platformOverride;
+  if (!p)
+    return { attempted: false };
+  const { command, args } = openCommandFor(p, path);
+  const exists = opts.binaryExists ?? ((cmd) => findBinaryOnPath(cmd) !== null);
+  if (!exists(command))
+    return { attempted: false };
+  const useSpawn = opts.spawner ?? spawn;
+  try {
+    const child = useSpawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    if (typeof child.unref === "function") {
+      child.unref();
+    }
+    return { attempted: true, command };
+  } catch {
+    return { attempted: false };
+  }
+}
+
+// dist/src/dashboard/render.js
+var VIS_NETWORK_CDN = "https://unpkg.com/vis-network@9.1.9/standalone/umd/vis-network.min.js";
+var KIND_COLORS = {
+  function: "#7aa2f7",
+  // soft blue
+  class: "#bb9af7",
+  // purple
+  method: "#9ece6a",
+  // green
+  interface: "#e0af68",
+  // amber
+  type_alias: "#7dcfff",
+  // cyan
+  enum: "#f7768e",
+  // pink
+  const: "#9d7cd8",
+  // muted purple
+  module: "#565f89"
+  // slate
+};
+var DEFAULT_NODE_COLOR = "#565f89";
+function isObject2(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function transformSnapshotToVis(snapshot) {
+  if (!isObject2(snapshot))
+    return { nodes: [], edges: [] };
+  const raw = snapshot;
+  const visNodes = [];
+  const ids = /* @__PURE__ */ new Set();
+  if (Array.isArray(raw.nodes)) {
+    for (const n of raw.nodes) {
+      if (!isObject2(n))
+        continue;
+      const node = n;
+      const id = asString(node.id);
+      if (!id)
+        continue;
+      if (ids.has(id))
+        continue;
+      ids.add(id);
+      const label = asString(node.label) ?? id;
+      const kind = asString(node.kind);
+      const sourceFile = asString(node.source_file);
+      const sourceLoc = asString(node.source_location);
+      const titleParts = [];
+      if (kind)
+        titleParts.push(kind);
+      if (sourceFile) {
+        const loc = sourceLoc ? `${sourceFile}:${sourceLoc}` : sourceFile;
+        titleParts.push(loc);
+      }
+      const color = kind && KIND_COLORS[kind] ? KIND_COLORS[kind] : DEFAULT_NODE_COLOR;
+      visNodes.push({
+        id,
+        label,
+        title: titleParts.length > 0 ? titleParts.map(escHtml).join(" \xB7 ") : escHtml(id),
+        group: kind ?? void 0,
+        color: { background: color, border: color }
+      });
+    }
+  }
+  const visEdges = [];
+  if (Array.isArray(raw.links)) {
+    for (const l of raw.links) {
+      if (!isObject2(l))
+        continue;
+      const edge = l;
+      const from = asString(edge.source);
+      const to = asString(edge.target);
+      if (!from || !to)
+        continue;
+      const relation = asString(edge.relation);
+      const confidence = asString(edge.confidence);
+      const titleParts = [];
+      if (relation)
+        titleParts.push(relation);
+      if (confidence)
+        titleParts.push(`[${confidence}]`);
+      visEdges.push({
+        from,
+        to,
+        title: titleParts.length > 0 ? titleParts.map(escHtml).join(" ") : `${escHtml(from)} \u2192 ${escHtml(to)}`
+      });
+    }
+  }
+  return { nodes: visNodes, edges: visEdges };
+}
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function safeJsonForScript(value) {
+  return JSON.stringify(value).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\u0021--").replace(/-->/g, "--\\u003e");
+}
+function formatTokensCompact(n) {
+  if (!Number.isFinite(n) || n <= 0)
+    return "0";
+  if (n < 1e3)
+    return `${Math.round(n)}`;
+  if (n < 1e5)
+    return `${(n / 1e3).toFixed(1)}k`;
+  if (n < 1e6)
+    return `${Math.round(n / 1e3)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function formatInt(n) {
+  if (!Number.isFinite(n))
+    return "0";
+  return Math.round(n).toLocaleString("en-US");
+}
+function renderKpiCards(kpis) {
+  const tokensValue = kpis.tokensSaved == null ? "\u2014" : `~${formatTokensCompact(kpis.tokensSaved)}`;
+  const tokensSub = (() => {
+    if (kpis.tokensSource === "org") {
+      return kpis.userTokensSaved != null ? `Org-wide \xB7 you ~${formatTokensCompact(kpis.userTokensSaved)}` : "Org-wide";
+    }
+    if (kpis.tokensSource === "local")
+      return "Local (this machine)";
+    return "Run a session to start tracking";
+  })();
+  const memoryValue = kpis.memorySearches > 0 ? formatInt(kpis.memorySearches) : kpis.tokensSource === "none" ? "\u2014" : "0";
+  const sessionsValue = kpis.sessionsCount == null ? "\u2014" : formatInt(kpis.sessionsCount);
+  const cards = [
+    {
+      label: "Tokens saved",
+      value: tokensValue,
+      sub: tokensSub
+    },
+    {
+      label: "Skills created",
+      value: formatInt(kpis.skillsCreated),
+      sub: "~/.claude/skills/"
+    },
+    {
+      label: "Memory recalls",
+      value: memoryValue,
+      sub: kpis.tokensSource === "org" ? "Org-wide" : kpis.tokensSource === "local" ? "Local" : ""
+    },
+    {
+      label: "Sessions",
+      value: sessionsValue,
+      sub: kpis.tokensSource === "org" ? "Org-wide" : kpis.tokensSource === "local" ? "Local" : ""
+    }
+  ];
+  return cards.map((c) => `
+        <div class="kpi">
+          <div class="kpi-label">${escHtml(c.label)}</div>
+          <div class="kpi-value">${escHtml(c.value)}</div>
+          <div class="kpi-sub">${escHtml(c.sub)}</div>
+        </div>`).join("");
+}
+function renderGraphSection(data) {
+  if (data.graph == null) {
+    return `
+      <div class="graph-card">
+        <h2>Codebase graph</h2>
+        <div class="empty">
+          No graph snapshot yet for this repo.<br>
+          Run <code>hivemind graph build</code> to generate one.
+        </div>
+      </div>`;
+  }
+  const visPayload = transformSnapshotToVis(data.graph.snapshot);
+  const commitLabel = data.graph.commitSha ? `commit ${data.graph.commitSha.slice(0, 12)}` : "no commit (loose dir)";
+  const meta = `${formatInt(data.graph.nodeCount)} nodes \xB7 ${formatInt(data.graph.edgeCount)} edges \xB7 ${commitLabel}`;
+  return `
+      <div class="graph-card">
+        <h2>Codebase graph</h2>
+        <div class="graph-meta">${escHtml(meta)}</div>
+        <div id="graph"></div>
+      </div>
+      <script type="application/json" id="hm-graph-data">${safeJsonForScript(visPayload)}</script>
+      <script src="${VIS_NETWORK_CDN}"></script>
+      <script>
+        (function () {
+          var holder = document.getElementById('hm-graph-data');
+          var container = document.getElementById('graph');
+          if (!holder || !container || typeof vis === 'undefined') return;
+          var payload;
+          try { payload = JSON.parse(holder.textContent); }
+          catch (e) { container.textContent = 'graph payload parse failed'; return; }
+          if (!payload || !Array.isArray(payload.nodes) || payload.nodes.length === 0) {
+            container.textContent = 'snapshot has no nodes';
+            return;
+          }
+          new vis.Network(container, payload, {
+            nodes: {
+              shape: 'dot',
+              size: 9,
+              font: { color: '#e8eaed', size: 11, face: 'system-ui, sans-serif' },
+              borderWidth: 1,
+            },
+            edges: {
+              color: { color: 'rgba(120, 130, 150, 0.45)', highlight: '#f5b80a', hover: '#e8eaed' },
+              arrows: { to: { enabled: true, scaleFactor: 0.45 } },
+              smooth: { enabled: true, type: 'continuous', roundness: 0.2 },
+              width: 1,
+            },
+            physics: {
+              stabilization: { iterations: 120 },
+              barnesHut: { gravitationalConstant: -2200, springLength: 80, springConstant: 0.04 },
+            },
+            interaction: { hover: true, dragNodes: true, tooltipDelay: 120 },
+          });
+        }());
+      </script>`;
+}
+var STYLES = `
+        :root {
+          color-scheme: dark;
+          --bg: #0b0d10;
+          --fg: #e8eaed;
+          --muted: #8b9099;
+          --accent: #f5b80a;
+          --card: #15181d;
+          --border: #22272e;
+        }
+        * { box-sizing: border-box; }
+        html, body { margin: 0; padding: 0; }
+        body {
+          font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+          background: var(--bg);
+          color: var(--fg);
+          padding: 24px;
+        }
+        .header { display: flex; justify-content: space-between; align-items: baseline; margin-bottom: 24px; gap: 16px; flex-wrap: wrap; }
+        .brand { font-weight: 600; font-size: 18px; }
+        .brand .bee { color: var(--accent); margin-right: 4px; }
+        .brand .repo { color: var(--muted); font-weight: 400; margin-left: 8px; }
+        .header .ts { color: var(--muted); font-size: 12px; }
+        .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 16px; margin-bottom: 32px; }
+        .kpi { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px 20px; }
+        .kpi-label { color: var(--muted); font-size: 11px; text-transform: uppercase; letter-spacing: 0.06em; }
+        .kpi-value { font-size: 28px; font-weight: 600; margin-top: 6px; line-height: 1.1; }
+        .kpi-sub { color: var(--muted); font-size: 12px; margin-top: 4px; }
+        .graph-card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px; }
+        .graph-card h2 { margin: 0 0 8px; font-size: 15px; font-weight: 500; }
+        .graph-meta { color: var(--muted); font-size: 12px; margin-bottom: 12px; }
+        #graph { height: 70vh; border: 1px solid var(--border); border-radius: 4px; background: #0e1116; }
+        .empty { padding: 48px 16px; text-align: center; color: var(--muted); }
+        .empty code { background: #1c2128; padding: 2px 6px; border-radius: 3px; color: var(--fg); font-family: ui-monospace, "SFMono-Regular", monospace; }
+        .footer { color: var(--muted); font-size: 11px; margin-top: 24px; text-align: right; }
+`;
+function renderDashboardHtml(data) {
+  const title = `Hivemind Dashboard \xB7 ${data.repoProject}`;
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${escHtml(title)}</title>
+    <style>${STYLES}</style>
+  </head>
+  <body>
+    <div class="header">
+      <div class="brand">
+        <span class="bee">\u{1F41D}</span>hivemind dashboard
+        <span class="repo">/ ${escHtml(data.repoProject)}</span>
+      </div>
+      <div class="ts">${escHtml(data.generatedAt)}</div>
+    </div>
+    <div class="kpi-grid">${renderKpiCards(data.kpis)}
+    </div>
+    ${renderGraphSection(data)}
+    <div class="footer">repo_key ${escHtml(data.repoKey)}</div>
+  </body>
+</html>
+`;
+}
+
+// dist/src/dashboard/serve.js
+import { createServer } from "node:http";
+var DEFAULT_PORT = 8123;
+var DEFAULT_HOST = "127.0.0.1";
+function handleRequest(html) {
+  return (req, res) => {
+    const url = req.url ?? "/";
+    const path = url.split("?")[0];
+    if (req.method === "GET" && (path === "/" || path === "/index.html")) {
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.setHeader("Cache-Control", "no-store");
+      res.end(html);
+      return;
+    }
+    if (req.method === "GET" && path === "/health") {
+      res.statusCode = 204;
+      res.end();
+      return;
+    }
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+    res.end("Not found. The dashboard lives at /.\n");
+  };
+}
+function tryListen(server, host, port) {
+  return new Promise((resolve3, reject) => {
+    const onError = (err) => {
+      server.off("listening", onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("server bound to a non-IP address"));
+        return;
+      }
+      resolve3(addr.port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+async function serveDashboardHtml(opts) {
+  const host = opts.host ?? DEFAULT_HOST;
+  const requested = opts.port === void 0 || !Number.isFinite(opts.port) || opts.port < 0 ? DEFAULT_PORT : opts.port;
+  const server = createServer(handleRequest(opts.html));
+  let bound;
+  try {
+    bound = await tryListen(server, host, requested);
+  } catch (e) {
+    if (e?.code !== "EADDRINUSE")
+      throw e;
+    const fallback = createServer(handleRequest(opts.html));
+    bound = await tryListen(fallback, host, 0);
+    server.removeAllListeners();
+    return makeHandle(fallback, host, bound);
+  }
+  return makeHandle(server, host, bound);
+}
+function makeHandle(server, host, port) {
+  let resolveStopped;
+  const stopped = new Promise((resolve3) => {
+    resolveStopped = resolve3;
+  });
+  server.on("close", () => resolveStopped());
+  return {
+    host,
+    port,
+    stopped,
+    close: () => new Promise((resolve3, reject) => {
+      server.close((err) => err ? reject(err) : resolve3());
+    })
+  };
+}
+
+// dist/src/commands/dashboard.js
+var USAGE = `hivemind dashboard \u2014 codebase graph + KPI dashboard (HTML)
+
+Usage:
+  hivemind dashboard [--cwd <path>] [--out <path>] [--no-open]
+                     [--serve] [--port <n>]
+      Build a self-contained HTML dashboard for this repo, write it
+      to disk, and either open it in the default browser or serve
+      it over loopback HTTP for headless / SSH workflows.
+
+      --cwd <path>   Use a different project root (defaults to cwd).
+      --out <path>   Write to a custom path (defaults to
+                     ~/.hivemind/dashboards/<repo-key>/index.html).
+      --no-open      Don't open the browser. Combine with --serve
+                     to start the server without auto-launching.
+      --serve        Start a loopback HTTP server (127.0.0.1) so the
+                     dashboard is reachable at a URL. Stays alive
+                     until Ctrl+C. Ideal for VS Code / Cursor
+                     Remote-SSH (auto-forwards the port \u2192 click to
+                     open in the integrated browser tab).
+      --port <n>     Port for --serve (default 8123). Falls back to
+                     a kernel-assigned port if <n> is in use.
+
+  hivemind dashboard --help
+      Show this message.
+
+Data sources (all read-only):
+  - Graph snapshot at ~/.hivemind/graphs/<repo-key>/   (produced by
+    \`hivemind graph build\`; the dashboard works without it and shows
+    an empty-state until the producer has run)
+  - KPIs via the org stats endpoint (cached) with a local fallback
+    to ~/.deeplake/usage-stats.jsonl
+  - Skills created from ~/.claude/skills/<name>--<author>/ directories
+`;
+function parsePort(raw) {
+  if (raw === void 0 || raw === "")
+    return { error: "--port requires a value" };
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0 || n > 65535) {
+    return { error: `--port must be an integer in [0, 65535], got '${raw}'` };
+  }
+  return n;
+}
+function parseDashboardArgs(args) {
+  let cwd;
+  let outPath = "";
+  let open = true;
+  let serve = false;
+  let port;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--help" || a === "-h")
+      return { help: true };
+    if (a === "--no-open") {
+      open = false;
+      continue;
+    }
+    if (a === "--serve") {
+      serve = true;
+      continue;
+    }
+    if (a === "--cwd") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--cwd requires a value" };
+      }
+      cwd = v;
+      continue;
+    }
+    if (a.startsWith("--cwd=")) {
+      cwd = a.slice("--cwd=".length);
+      continue;
+    }
+    if (a === "--out") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--out requires a value" };
+      }
+      outPath = v;
+      continue;
+    }
+    if (a.startsWith("--out=")) {
+      outPath = a.slice("--out=".length);
+      continue;
+    }
+    if (a === "--port") {
+      const v = args[++i];
+      if (v === void 0 || v.startsWith("-")) {
+        return { error: "--port requires a value" };
+      }
+      const parsed = parsePort(v);
+      if (typeof parsed === "object")
+        return { error: parsed.error };
+      port = parsed;
+      continue;
+    }
+    if (a.startsWith("--port=")) {
+      const parsed = parsePort(a.slice("--port=".length));
+      if (typeof parsed === "object")
+        return { error: parsed.error };
+      port = parsed;
+      continue;
+    }
+    return { error: `unknown arg '${a}'` };
+  }
+  if (port !== void 0 && !serve) {
+    return { error: "--port requires --serve" };
+  }
+  return {
+    args: {
+      cwd: cwd ?? process.cwd(),
+      outPath,
+      open,
+      serve,
+      port
+    }
+  };
+}
+function defaultDashboardOutPath(repoKey) {
+  return join27(homedir14(), ".hivemind", "dashboards", repoKey, "index.html");
+}
+async function runDashboardCommand(rawArgs, runOpts = {}) {
+  const out = runOpts.out ?? ((s) => {
+    process.stdout.write(s);
+  });
+  const err = runOpts.err ?? ((s) => {
+    process.stderr.write(s);
+  });
+  const opener = runOpts.opener ?? openInBrowser;
+  const parsed = parseDashboardArgs(rawArgs);
+  if (parsed.help) {
+    out(USAGE);
+    return 0;
+  }
+  if (parsed.error || !parsed.args) {
+    err(`hivemind dashboard: ${parsed.error ?? "invalid arguments"}
+`);
+    err(USAGE);
+    return 2;
+  }
+  const { cwd, outPath, open } = parsed.args;
+  let data;
+  try {
+    data = await loadDashboardData({ cwd });
+  } catch (e) {
+    err(`hivemind dashboard: failed to load data: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  const html = renderDashboardHtml(data);
+  const finalOut = outPath || defaultDashboardOutPath(data.repoKey);
+  const absOut = resolve2(finalOut);
+  try {
+    mkdirSync10(dirname6(absOut), { recursive: true });
+    writeFileSync13(absOut, html, "utf-8");
+  } catch (e) {
+    err(`hivemind dashboard: failed to write ${absOut}: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  out(`Wrote ${absOut}
+`);
+  if (data.graph == null) {
+    out(`(no codebase graph yet \u2014 run 'hivemind graph build' to populate)
+`);
+  }
+  if (parsed.args.serve) {
+    return await runServeLoop(html, parsed.args, runOpts, out, err);
+  }
+  if (open) {
+    const result = opener(absOut);
+    if (result.attempted) {
+      out(`Opening via ${result.command}
+`);
+    } else {
+      out(`(no opener for this platform; open the file above manually)
+`);
+    }
+  }
+  return 0;
+}
+async function runServeLoop(html, args, runOpts, out, err) {
+  const server = runOpts.server ?? serveDashboardHtml;
+  const opener = runOpts.opener ?? openInBrowser;
+  const onSignal = runOpts.onSignal ?? defaultOnSignal;
+  let handle;
+  try {
+    handle = await server({ html, port: args.port });
+  } catch (e) {
+    err(`hivemind dashboard: failed to start server: ${e?.message ?? String(e)}
+`);
+    return 1;
+  }
+  const url = `http://${handle.host}:${handle.port}/`;
+  out(`Serving dashboard at ${url}  (Ctrl+C to stop)
+`);
+  if (args.open) {
+    const result = opener(url);
+    if (result.attempted) {
+      out(`Opening via ${result.command}
+`);
+    } else {
+      out(`(no opener for this platform; click the URL above or open it manually)
+`);
+    }
+  }
+  let resolveDone;
+  const done = new Promise((r) => {
+    resolveDone = r;
+  });
+  const shutdown = async () => {
+    try {
+      await handle.close();
+    } catch {
+    }
+    resolveDone(0);
+  };
+  const offInt = onSignal("SIGINT", shutdown);
+  const offTerm = onSignal("SIGTERM", shutdown);
+  handle.stopped.then(() => resolveDone(0));
+  try {
+    return await done;
+  } finally {
+    offInt();
+    offTerm();
+  }
+}
+function defaultOnSignal(signal, handler) {
+  process.on(signal, handler);
+  return () => process.off(signal, handler);
+}
+
+// dist/src/commands/skillify.js
+import { readdirSync as readdirSync7, existsSync as existsSync30, readFileSync as readFileSync26, mkdirSync as mkdirSync17, renameSync as renameSync8 } from "node:fs";
+import { homedir as homedir23 } from "node:os";
+import { dirname as dirname11, join as join38 } from "node:path";
+
 // dist/src/skillify/scope-config.js
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
+import { join as join28 } from "node:path";
 function configPath() {
-  return join22(getStateDir(), "config.json");
+  return join28(getStateDir(), "config.json");
 }
 var DEFAULT = { scope: "me", team: [], install: "project" };
 function loadScopeConfig() {
   migrateLegacyStateDir();
   const CONFIG_PATH2 = configPath();
-  if (!existsSync16(CONFIG_PATH2))
+  if (!existsSync20(CONFIG_PATH2))
     return DEFAULT;
   try {
-    const raw = JSON.parse(readFileSync15(CONFIG_PATH2, "utf-8"));
+    const raw = JSON.parse(readFileSync19(CONFIG_PATH2, "utf-8"));
     const scope = raw.scope === "team" ? "team" : raw.scope === "org" ? "team" : "me";
     const team = Array.isArray(raw.team) ? raw.team.filter((s) => typeof s === "string") : [];
     const install = raw.install === "global" ? "global" : "project";
@@ -5488,19 +6506,19 @@ function loadScopeConfig() {
 }
 function saveScopeConfig(cfg) {
   migrateLegacyStateDir();
-  mkdirSync7(getStateDir(), { recursive: true });
-  writeFileSync11(configPath(), JSON.stringify(cfg, null, 2));
+  mkdirSync11(getStateDir(), { recursive: true });
+  writeFileSync14(configPath(), JSON.stringify(cfg, null, 2));
 }
 
 // dist/src/skillify/pull.js
-import { existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, renameSync as renameSync6, lstatSync as lstatSync4, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync9 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname5, join as join26 } from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync17, mkdirSync as mkdirSync14, renameSync as renameSync7, lstatSync as lstatSync5, readlinkSync as readlinkSync2, symlinkSync as symlinkSync2, unlinkSync as unlinkSync10 } from "node:fs";
+import { homedir as homedir17 } from "node:os";
+import { dirname as dirname8, join as join32 } from "node:path";
 
 // dist/src/skillify/skill-writer.js
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync15 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join29 } from "node:path";
 function assertValidSkillName(name) {
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`invalid skill name: empty or non-string`);
@@ -5516,10 +6534,10 @@ function assertValidSkillName(name) {
   }
 }
 function skillDir(skillsRoot, name) {
-  return join23(skillsRoot, name);
+  return join29(skillsRoot, name);
 }
 function skillPath(skillsRoot, name) {
-  return join23(skillDir(skillsRoot, name), "SKILL.md");
+  return join29(skillDir(skillsRoot, name), "SKILL.md");
 }
 function renderFrontmatter(fm) {
   const lines = ["---"];
@@ -5597,10 +6615,10 @@ function writeNewSkill(args) {
   assertValidSkillName(args.name);
   const dir = skillDir(args.skillsRoot, args.name);
   const path = skillPath(args.skillsRoot, args.name);
-  if (existsSync17(path)) {
+  if (existsSync21(path)) {
     throw new Error(`skill already exists at ${path}; use mergeSkill`);
   }
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync12(dir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const author = args.author && args.author.length > 0 ? args.author : void 0;
   const contributors = author ? [author] : [];
@@ -5620,7 +6638,7 @@ function writeNewSkill(args) {
 
 ${args.body.trim()}
 `;
-  writeFileSync12(path, text);
+  writeFileSync15(path, text);
   return {
     path,
     action: "created",
@@ -5632,40 +6650,40 @@ ${args.body.trim()}
   };
 }
 function listSkills(skillsRoot) {
-  if (!existsSync17(skillsRoot))
+  if (!existsSync21(skillsRoot))
     return [];
   const out = [];
-  for (const name of readdirSync2(skillsRoot)) {
-    const skillFile = join23(skillsRoot, name, "SKILL.md");
-    if (existsSync17(skillFile) && statSync3(skillFile).isFile()) {
-      out.push({ name, body: readFileSync16(skillFile, "utf-8") });
+  for (const name of readdirSync4(skillsRoot)) {
+    const skillFile = join29(skillsRoot, name, "SKILL.md");
+    if (existsSync21(skillFile) && statSync5(skillFile).isFile()) {
+      out.push({ name, body: readFileSync20(skillFile, "utf-8") });
     }
   }
   return out;
 }
 function resolveSkillsRoot(install, cwd) {
   if (install === "global") {
-    return join23(homedir11(), ".claude", "skills");
+    return join29(homedir15(), ".claude", "skills");
   }
-  return join23(cwd, ".claude", "skills");
+  return join29(cwd, ".claude", "skills");
 }
 
 // dist/src/skillify/manifest.js
-import { existsSync as existsSync18, lstatSync as lstatSync3, mkdirSync as mkdirSync9, readFileSync as readFileSync17, renameSync as renameSync5, unlinkSync as unlinkSync8, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname4, join as join24 } from "node:path";
+import { existsSync as existsSync22, lstatSync as lstatSync4, mkdirSync as mkdirSync13, readFileSync as readFileSync21, renameSync as renameSync6, unlinkSync as unlinkSync9, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname7, join as join30 } from "node:path";
 function emptyManifest() {
   return { version: 1, entries: [] };
 }
 function manifestPath() {
-  return join24(getStateDir(), "pulled.json");
+  return join30(getStateDir(), "pulled.json");
 }
 function loadManifest(path = manifestPath()) {
   migrateLegacyStateDir();
-  if (!existsSync18(path))
+  if (!existsSync22(path))
     return emptyManifest();
   let raw;
   try {
-    raw = readFileSync17(path, "utf-8");
+    raw = readFileSync21(path, "utf-8");
   } catch {
     return emptyManifest();
   }
@@ -5712,10 +6730,10 @@ function loadManifest(path = manifestPath()) {
 }
 function saveManifest(m, path = manifestPath()) {
   migrateLegacyStateDir();
-  mkdirSync9(dirname4(path), { recursive: true });
+  mkdirSync13(dirname7(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  writeFileSync13(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
-  renameSync5(tmp, path);
+  writeFileSync16(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  renameSync6(tmp, path);
 }
 function recordPull(entry, path = manifestPath()) {
   const m = loadManifest(path);
@@ -5740,14 +6758,14 @@ function unlinkSymlinks(paths) {
   for (const path of paths) {
     let st;
     try {
-      st = lstatSync3(path);
+      st = lstatSync4(path);
     } catch {
       continue;
     }
     if (!st.isSymbolicLink())
       continue;
     try {
-      unlinkSync8(path);
+      unlinkSync9(path);
     } catch {
     }
   }
@@ -5757,7 +6775,7 @@ function pruneOrphanedEntries(path = manifestPath()) {
   const live = [];
   let pruned = 0;
   for (const e of m.entries) {
-    if (existsSync18(join24(e.installRoot, e.dirName))) {
+    if (existsSync22(join30(e.installRoot, e.dirName))) {
       live.push(e);
       continue;
     }
@@ -5770,26 +6788,26 @@ function pruneOrphanedEntries(path = manifestPath()) {
 }
 
 // dist/src/skillify/agent-roots.js
-import { existsSync as existsSync19 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { join as join31 } from "node:path";
 function resolveDetected(home) {
   const out = [];
-  const codexInstalled = existsSync19(join25(home, ".codex"));
-  const piInstalled = existsSync19(join25(home, ".pi", "agent"));
-  const hermesInstalled = existsSync19(join25(home, ".hermes"));
+  const codexInstalled = existsSync23(join31(home, ".codex"));
+  const piInstalled = existsSync23(join31(home, ".pi", "agent"));
+  const hermesInstalled = existsSync23(join31(home, ".hermes"));
   if (codexInstalled || piInstalled) {
-    out.push(join25(home, ".agents", "skills"));
+    out.push(join31(home, ".agents", "skills"));
   }
   if (hermesInstalled) {
-    out.push(join25(home, ".hermes", "skills"));
+    out.push(join31(home, ".hermes", "skills"));
   }
   if (piInstalled) {
-    out.push(join25(home, ".pi", "agent", "skills"));
+    out.push(join31(home, ".pi", "agent", "skills"));
   }
   return out;
 }
-function detectAgentSkillsRoots(canonicalRoot, home = homedir12()) {
+function detectAgentSkillsRoots(canonicalRoot, home = homedir16()) {
   return resolveDetected(home).filter((p) => p !== canonicalRoot);
 }
 
@@ -5833,18 +6851,18 @@ function isMissingTableError(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join26(homedir13(), ".claude", "skills");
+    return join32(homedir17(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join26(cwd, ".claude", "skills");
+  return join32(cwd, ".claude", "skills");
 }
 function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
   const out = [];
   for (const root of agentRoots) {
-    const link = join26(root, dirName);
+    const link = join32(root, dirName);
     let existing;
     try {
-      existing = lstatSync4(link);
+      existing = lstatSync5(link);
     } catch {
       existing = null;
     }
@@ -5863,13 +6881,13 @@ function fanOutSymlinks(canonicalDir, dirName, agentRoots) {
         continue;
       }
       try {
-        unlinkSync9(link);
+        unlinkSync10(link);
       } catch {
         continue;
       }
     }
     try {
-      mkdirSync10(dirname5(link), { recursive: true });
+      mkdirSync14(dirname8(link), { recursive: true });
       symlinkSync2(canonicalDir, link, "dir");
       out.push(link);
     } catch {
@@ -5884,8 +6902,8 @@ function backfillSymlinks(installRoot) {
     return;
   const detected = detectAgentSkillsRoots(installRoot);
   for (const entry of entries) {
-    const canonical = join26(entry.installRoot, entry.dirName);
-    if (!existsSync20(canonical))
+    const canonical = join32(entry.installRoot, entry.dirName);
+    if (!existsSync24(canonical))
       continue;
     const fresh = fanOutSymlinks(canonical, entry.dirName, detected);
     if (sameSorted(fresh, entry.symlinks))
@@ -5995,10 +7013,10 @@ function renderFrontmatter2(fm) {
   return lines.join("\n");
 }
 function readLocalVersion(path) {
-  if (!existsSync20(path))
+  if (!existsSync24(path))
     return null;
   try {
-    const text = readFileSync18(path, "utf-8");
+    const text = readFileSync22(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -6093,8 +7111,8 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const skillDir2 = join26(root, dirName);
-    const skillFile = join26(skillDir2, "SKILL.md");
+    const skillDir2 = join32(root, dirName);
+    const skillFile = join32(skillDir2, "SKILL.md");
     const remoteVersion = Number(row.version ?? 1);
     const localVersion = readLocalVersion(skillFile);
     const action = decideAction({
@@ -6105,14 +7123,14 @@ async function runPull(opts) {
     });
     let manifestError;
     if (action === "wrote") {
-      mkdirSync10(skillDir2, { recursive: true });
-      if (existsSync20(skillFile)) {
+      mkdirSync14(skillDir2, { recursive: true });
+      if (existsSync24(skillFile)) {
         try {
-          renameSync6(skillFile, `${skillFile}.bak`);
+          renameSync7(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync14(skillFile, renderSkillFile(row));
+      writeFileSync17(skillFile, renderSkillFile(row));
       const symlinks = opts.install === "global" ? fanOutSymlinks(skillDir2, dirName, detectAgentSkillsRoots(root)) : [];
       try {
         recordPull({
@@ -6154,15 +7172,15 @@ async function runPull(opts) {
 }
 
 // dist/src/skillify/unpull.js
-import { existsSync as existsSync21, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync25, readdirSync as readdirSync5, rmSync as rmSync5, statSync as statSync6 } from "node:fs";
+import { homedir as homedir18 } from "node:os";
+import { join as join33 } from "node:path";
 function resolveUnpullRoot(install, cwd) {
   if (install === "global")
-    return join27(homedir14(), ".claude", "skills");
+    return join33(homedir18(), ".claude", "skills");
   if (!cwd)
     throw new Error("cwd required when install === 'project'");
-  return join27(cwd, ".claude", "skills");
+  return join33(cwd, ".claude", "skills");
 }
 function runUnpull(opts) {
   const root = resolveUnpullRoot(opts.install, opts.cwd);
@@ -6185,8 +7203,8 @@ function runUnpull(opts) {
   const entries = entriesForRoot(manifest, opts.install, root);
   for (const entry of entries) {
     summary.scanned++;
-    const path = join27(root, entry.dirName);
-    if (!existsSync21(path)) {
+    const path = join33(root, entry.dirName);
+    if (!existsSync25(path)) {
       if (!opts.dryRun) {
         unlinkSymlinks(entry.symlinks);
         removePullEntry(opts.install, entry.installRoot, entry.dirName);
@@ -6239,15 +7257,15 @@ function runUnpull(opts) {
     }
     summary.entries.push(result);
   }
-  if (existsSync21(root) && (opts.all || opts.legacyCleanup)) {
+  if (existsSync25(root) && (opts.all || opts.legacyCleanup)) {
     const manifestDirNames = new Set(entries.map((e) => e.dirName));
-    for (const dirName of readdirSync3(root)) {
+    for (const dirName of readdirSync5(root)) {
       if (manifestDirNames.has(dirName))
         continue;
-      const path = join27(root, dirName);
+      const path = join33(root, dirName);
       let st;
       try {
-        st = statSync4(path);
+        st = statSync6(path);
       } catch {
         continue;
       }
@@ -6322,31 +7340,31 @@ function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
 }
 
 // dist/src/commands/mine-local.js
-import { spawn } from "node:child_process";
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync16 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { basename, dirname as dirname7, join as join31 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync29, mkdirSync as mkdirSync16, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { basename as basename2, dirname as dirname10, join as join37 } from "node:path";
 
 // dist/src/skillify/local-source.js
-import { readdirSync as readdirSync4, readFileSync as readFileSync19, existsSync as existsSync22, statSync as statSync5 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
-import { join as join28 } from "node:path";
-var HOME2 = homedir15();
+import { readdirSync as readdirSync6, readFileSync as readFileSync23, existsSync as existsSync26, statSync as statSync7 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import { join as join34 } from "node:path";
+var HOME2 = homedir19();
 function encodeCwdClaudeCode(cwd) {
   return cwd.replace(/[/_]/g, "-");
 }
 function detectInstalledAgents() {
   const installs = [];
-  const claudeRoot = join28(HOME2, ".claude", "projects");
-  if (existsSync22(claudeRoot)) {
+  const claudeRoot = join34(HOME2, ".claude", "projects");
+  if (existsSync26(claudeRoot)) {
     installs.push({
       agent: "claude_code",
       sessionRoot: claudeRoot,
       encodeCwd: encodeCwdClaudeCode
     });
   }
-  const codexRoot = join28(HOME2, ".codex", "sessions");
-  if (existsSync22(codexRoot)) {
+  const codexRoot = join34(HOME2, ".codex", "sessions");
+  if (existsSync26(codexRoot)) {
     installs.push({
       agent: "codex",
       sessionRoot: codexRoot,
@@ -6368,14 +7386,14 @@ function listLocalSessions(installs, cwd) {
     const cwdEncoded = install.encodeCwd(cwd);
     let subdirs = [];
     try {
-      subdirs = readdirSync4(install.sessionRoot);
+      subdirs = readdirSync6(install.sessionRoot);
     } catch {
       continue;
     }
     for (const sub of subdirs) {
-      const subdirPath = join28(install.sessionRoot, sub);
+      const subdirPath = join34(install.sessionRoot, sub);
       try {
-        if (!statSync5(subdirPath).isDirectory())
+        if (!statSync7(subdirPath).isDirectory())
           continue;
       } catch {
         continue;
@@ -6383,17 +7401,17 @@ function listLocalSessions(installs, cwd) {
       const inCwd = sub === cwdEncoded;
       let files = [];
       try {
-        files = readdirSync4(subdirPath);
+        files = readdirSync6(subdirPath);
       } catch {
         continue;
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const fullPath = join28(subdirPath, f);
+        const fullPath = join34(subdirPath, f);
         let stats;
         try {
-          stats = statSync5(fullPath);
+          stats = statSync7(fullPath);
         } catch {
           continue;
         }
@@ -6451,7 +7469,7 @@ function pickSessions(candidates, opts) {
 function nativeJsonlToRows(filePath, sessionId, agent) {
   let raw;
   try {
-    raw = readFileSync19(filePath, "utf-8");
+    raw = readFileSync23(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -6541,22 +7559,22 @@ function extractPairs(rows) {
 }
 
 // dist/src/skillify/gate-runner.js
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir16 } from "node:os";
-import { join as join29 } from "node:path";
+import { homedir as homedir20 } from "node:os";
+import { join as join35 } from "node:path";
 var requireForCp = createRequire(import.meta.url);
 var { execFileSync: runChildProcess } = requireForCp("node:child_process");
 var inheritedEnv = process;
 function firstExistingPath(candidates) {
   for (const c of candidates) {
-    if (existsSync23(c))
+    if (existsSync27(c))
       return c;
   }
   return null;
 }
 function findAgentBin(agent) {
-  const home = homedir16();
+  const home = homedir20();
   switch (agent) {
     // /usr/bin/<name> is included in every candidate list — that's the
     // common Linux package-manager install path (apt, dnf, pacman). Old
@@ -6565,45 +7583,45 @@ function findAgentBin(agent) {
     // #170 caught the gap.
     case "claude_code":
       return firstExistingPath([
-        join29(home, ".claude", "local", "claude"),
+        join35(home, ".claude", "local", "claude"),
         "/usr/local/bin/claude",
         "/usr/bin/claude",
-        join29(home, ".npm-global", "bin", "claude"),
-        join29(home, ".local", "bin", "claude"),
+        join35(home, ".npm-global", "bin", "claude"),
+        join35(home, ".local", "bin", "claude"),
         "/opt/homebrew/bin/claude"
-      ]) ?? join29(home, ".claude", "local", "claude");
+      ]) ?? join35(home, ".claude", "local", "claude");
     case "codex":
       return firstExistingPath([
         "/usr/local/bin/codex",
         "/usr/bin/codex",
-        join29(home, ".npm-global", "bin", "codex"),
-        join29(home, ".local", "bin", "codex"),
+        join35(home, ".npm-global", "bin", "codex"),
+        join35(home, ".local", "bin", "codex"),
         "/opt/homebrew/bin/codex"
       ]) ?? "/usr/local/bin/codex";
     case "cursor":
       return firstExistingPath([
         "/usr/local/bin/cursor-agent",
         "/usr/bin/cursor-agent",
-        join29(home, ".npm-global", "bin", "cursor-agent"),
-        join29(home, ".local", "bin", "cursor-agent"),
+        join35(home, ".npm-global", "bin", "cursor-agent"),
+        join35(home, ".local", "bin", "cursor-agent"),
         "/opt/homebrew/bin/cursor-agent"
       ]) ?? "/usr/local/bin/cursor-agent";
     case "hermes":
       return firstExistingPath([
-        join29(home, ".local", "bin", "hermes"),
+        join35(home, ".local", "bin", "hermes"),
         "/usr/local/bin/hermes",
         "/usr/bin/hermes",
-        join29(home, ".npm-global", "bin", "hermes"),
+        join35(home, ".npm-global", "bin", "hermes"),
         "/opt/homebrew/bin/hermes"
-      ]) ?? join29(home, ".local", "bin", "hermes");
+      ]) ?? join35(home, ".local", "bin", "hermes");
     case "pi":
       return firstExistingPath([
-        join29(home, ".local", "bin", "pi"),
+        join35(home, ".local", "bin", "pi"),
         "/usr/local/bin/pi",
         "/usr/bin/pi",
-        join29(home, ".npm-global", "bin", "pi"),
+        join35(home, ".npm-global", "bin", "pi"),
         "/opt/homebrew/bin/pi"
-      ]) ?? join29(home, ".local", "bin", "pi");
+      ]) ?? join35(home, ".local", "bin", "pi");
   }
 }
 
@@ -6633,27 +7651,28 @@ function extractJsonBlock(s) {
 }
 
 // dist/src/skillify/local-manifest.js
-import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname6, join as join30 } from "node:path";
-var LOCAL_MANIFEST_PATH = join30(homedir17(), ".claude", "hivemind", "local-mined.json");
-var LOCAL_MINE_LOCK_PATH = join30(homedir17(), ".claude", "hivemind", "local-mined.lock");
+import { existsSync as existsSync28, mkdirSync as mkdirSync15, readFileSync as readFileSync24, writeFileSync as writeFileSync18 } from "node:fs";
+import { homedir as homedir21 } from "node:os";
+import { dirname as dirname9, join as join36 } from "node:path";
+var LOCAL_MANIFEST_PATH = join36(homedir21(), ".claude", "hivemind", "local-mined.json");
+var LOCAL_MINE_LOCK_PATH = join36(homedir21(), ".claude", "hivemind", "local-mined.lock");
 function readLocalManifest(path = LOCAL_MANIFEST_PATH) {
-  if (!existsSync24(path))
+  if (!existsSync28(path))
     return null;
   try {
-    return JSON.parse(readFileSync20(path, "utf-8"));
+    return JSON.parse(readFileSync24(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeLocalManifest(m, path = LOCAL_MANIFEST_PATH) {
-  mkdirSync11(dirname6(path), { recursive: true });
-  writeFileSync15(path, JSON.stringify(m, null, 2));
+  mkdirSync15(dirname9(path), { recursive: true });
+  writeFileSync18(path, JSON.stringify(m, null, 2));
 }
+var LATEST_RUN_WINDOW_MS = 5 * 60 * 1e3;
 
 // dist/src/commands/mine-local.js
-import { unlinkSync as unlinkSync10 } from "node:fs";
+import { unlinkSync as unlinkSync11 } from "node:fs";
 var EPSILON = 0.3;
 var DEFAULT_N = 8;
 var PAIR_CHAR_CAP = 4e3;
@@ -6664,9 +7683,9 @@ var IN_FLIGHT_MAX_AGE_MS = 6e4;
 var GATE_TIMEOUT_MS = 24e4;
 var MANIFEST_PATH = LOCAL_MANIFEST_PATH;
 function runGateViaStdin(opts) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     if (opts.agent !== "claude_code") {
-      resolve2({
+      resolve3({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6674,8 +7693,8 @@ function runGateViaStdin(opts) {
       });
       return;
     }
-    if (!existsSync25(opts.bin)) {
-      resolve2({
+    if (!existsSync29(opts.bin)) {
+      resolve3({
         stdout: "",
         stderr: "",
         errored: true,
@@ -6691,7 +7710,7 @@ function runGateViaStdin(opts) {
       "--permission-mode",
       "bypassPermissions"
     ];
-    const child = spawn(opts.bin, args, {
+    const child = spawn2(opts.bin, args, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, HIVEMIND_WIKI_WORKER: "1", HIVEMIND_CAPTURE: "false" }
     });
@@ -6702,7 +7721,7 @@ function runGateViaStdin(opts) {
       if (settled)
         return;
       settled = true;
-      resolve2(r);
+      resolve3(r);
     };
     const timer = setTimeout(() => {
       try {
@@ -6782,11 +7801,26 @@ function buildSessionPrompt(pairs2, session, verdictPath) {
     `- A skill qualifies if it captures a concrete, repeatable workflow OR a non-obvious`,
     `  constraint/gotcha a future engineer would benefit from knowing. Intra-session is fine \u2014`,
     `  one deep dive yielding a generalizable takeaway counts.`,
+    `- Especially valuable: REPEATABLE-MISTAKE patterns. Cases where the assistant declared`,
+    `  work "done"/"fixed"/"verified" and the user came back to the same problem later; where`,
+    `  the same class of mistake recurs (forgot to run tests, mishandled async state,`,
+    `  hallucinated function/file existence, re-asked for confirmation on already-authorized`,
+    `  work, jumped to plans without checking with the user, etc.); where the user manually`,
+    `  corrected the same kind of error >1 time. These are the highest-value catches.`,
     `- Skip patterns that are obvious from reading the codebase or already in CLAUDE.md.`,
     `- Each body uses short sections (When to use, Workflow, Anti-patterns), concrete commands`,
     `  / paths / snippets drawn from the exchanges below, no marketing, no emojis.`,
     `- Each body under ~3000 characters.`,
     `- Skill names are kebab-case slugs (lowercase letters/digits/hyphens only).`,
+    `- For each skill, also emit a one-line "insight": a concrete, quantified, second-person`,
+    `  sentence describing what hivemind found that prompted the skill. Examples:`,
+    `    "You revisited 4 merged PRs in the last month because the assistant declared 'done'`,
+    `     before checking test output."`,
+    `    "You corrected the same env-mismatch (beta vs prod) twice in the same week before`,
+    `     deciding to switch deployment targets."`,
+    `  The insight is what users will see at next SessionStart, so it must be honest \u2014 only`,
+    `  assert counts and patterns you can ground in THIS session's exchanges. Omit the field`,
+    `  if you cannot write a concrete, quantified line.`,
     ``,
     `=== EXCHANGES (user prompts + assistant final answers, tool calls stripped) ===`,
     renderPairsBlock(pairs2),
@@ -6805,7 +7839,8 @@ function buildSessionPrompt(pairs2, session, verdictPath) {
     `      "name": "<kebab-case>",`,
     `      "description": "<one-line>",`,
     `      "trigger": "<short trigger>",`,
-    `      "body": "<full SKILL.md body without frontmatter>"`,
+    `      "body": "<full SKILL.md body without frontmatter>",`,
+    `      "insight": "<one-line, concrete + quantified + second person; OPTIONAL>"`,
     `    },`,
     `    ... up to 3 entries, or [] if nothing qualifies`,
     `  ]`,
@@ -6837,9 +7872,12 @@ function parseMultiVerdict(raw) {
     const description = typeof s.description === "string" ? s.description.trim() : "";
     const body = typeof s.body === "string" ? s.body.trim() : "";
     const trigger = typeof s.trigger === "string" ? s.trigger.trim() : void 0;
+    const rawInsight = typeof s.insight === "string" ? s.insight : "";
+    const normalizedInsight = rawInsight.replace(/\s+/g, " ").trim();
+    const insight = normalizedInsight.length > 0 ? normalizedInsight.slice(0, 280) : void 0;
     if (!name || !body)
       continue;
-    out.push({ name, description, body, trigger });
+    out.push({ name, description, body, trigger, insight });
   }
   return { reason: typeof parsed.reason === "string" ? parsed.reason : void 0, skills: out };
 }
@@ -6962,7 +8000,7 @@ async function runMineLocal(args) {
       return;
     lockReleased = true;
     try {
-      unlinkSync10(LOCAL_MINE_LOCK_PATH);
+      unlinkSync11(LOCAL_MINE_LOCK_PATH);
     } catch {
     }
   };
@@ -7019,8 +8057,8 @@ async function runMineLocalImpl(args) {
     console.log(`Dry-run: would invoke ${gateAgent} gate on ${picked.length} session(s) in parallel (concurrency=${GATE_CONCURRENCY}).`);
     return;
   }
-  const tmpDir = join31(homedir18(), ".claude", "hivemind", `mine-local-${Date.now()}`);
-  mkdirSync12(tmpDir, { recursive: true });
+  const tmpDir = join37(homedir22(), ".claude", "hivemind", `mine-local-${Date.now()}`);
+  mkdirSync16(tmpDir, { recursive: true });
   console.log(`Running ${picked.length} gate call(s) in parallel (concurrency=${GATE_CONCURRENCY}, timeout=${GATE_TIMEOUT_MS / 1e3}s each)...`);
   const results = await parallelMap(picked, GATE_CONCURRENCY, async (s) => {
     const shortId = s.sessionId.slice(0, 8);
@@ -7031,23 +8069,23 @@ async function runMineLocalImpl(args) {
       return { session: s, skills: [], reason: "no pairs", error: null };
     }
     const tail = pairs2.slice(-PER_SESSION_PAIR_CAP);
-    const sessionTmp = join31(tmpDir, `s-${shortId}`);
-    mkdirSync12(sessionTmp, { recursive: true });
-    const verdictPath = join31(sessionTmp, "verdict.json");
+    const sessionTmp = join37(tmpDir, `s-${shortId}`);
+    mkdirSync16(sessionTmp, { recursive: true });
+    const verdictPath = join37(sessionTmp, "verdict.json");
     const prompt = buildSessionPrompt(tail, s, verdictPath);
-    writeFileSync16(join31(sessionTmp, "prompt.txt"), prompt);
+    writeFileSync19(join37(sessionTmp, "prompt.txt"), prompt);
     const gate = await runGateViaStdin({ agent: gateAgent, bin: gateBin, prompt, timeoutMs: GATE_TIMEOUT_MS });
     try {
-      writeFileSync16(join31(sessionTmp, "gate-stdout.txt"), gate.stdout);
+      writeFileSync19(join37(sessionTmp, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync16(join31(sessionTmp, "gate-stderr.txt"), gate.stderr);
+        writeFileSync19(join37(sessionTmp, "gate-stderr.txt"), gate.stderr);
     } catch {
     }
     if (gate.errored) {
       console.log(`  [${shortId}] gate failed: ${gate.errorMessage}`);
       return { session: s, skills: [], reason: null, error: gate.errorMessage ?? "gate failed" };
     }
-    const verdictText = existsSync25(verdictPath) ? readFileSync21(verdictPath, "utf-8") : gate.stdout;
+    const verdictText = existsSync29(verdictPath) ? readFileSync25(verdictPath, "utf-8") : gate.stdout;
     const mv = parseMultiVerdict(verdictText);
     if (!mv) {
       console.log(`  [${shortId}] unparseable verdict (kept at ${sessionTmp})`);
@@ -7099,8 +8137,8 @@ async function runMineLocalImpl(args) {
         sourceSessions: [session.sessionId],
         agent: gateAgent
       });
-      const canonicalDir = dirname7(result.path);
-      const symlinks = fanOutRoots.length > 0 ? fanOutSymlinks(canonicalDir, basename(canonicalDir), fanOutRoots) : [];
+      const canonicalDir = dirname10(result.path);
+      const symlinks = fanOutRoots.length > 0 ? fanOutSymlinks(canonicalDir, basename2(canonicalDir), fanOutRoots) : [];
       const symlinkSuffix = symlinks.length > 0 ? `, fan-out \u2192 ${symlinks.length} root(s)` : "";
       console.log(`  wrote ${skill.name} \u2190 session ${session.sessionId.slice(0, 8)} (${session.agent}${symlinkSuffix})`);
       written.push({ skill, session, result, symlinks });
@@ -7124,7 +8162,12 @@ async function runMineLocalImpl(args) {
       source_agent: session.agent,
       gate_agent: gateAgent,
       created_at: result.createdAt,
-      uploaded: false
+      uploaded: false,
+      // Persist the one-line insight when the gate produced one. Omitted
+      // (undefined → absent in JSON) when the gate couldn't ground a
+      // concrete line, so the SessionStart banner falls back to the
+      // count-only surface for entries written before this field landed.
+      ...skill.insight ? { insight: skill.insight } : {}
     }));
     saveManifest2({
       created_at: existing?.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -7271,11 +8314,11 @@ function showStatus() {
   console.log(`team:    ${cfg.team.length === 0 ? "(empty)" : cfg.team.join(", ")}`);
   console.log(`install: ${cfg.install}  (${cfg.install === "global" ? "~/.claude/skills/" : "<project>/.claude/skills/"})`);
   const dir = stateDir();
-  if (!existsSync26(dir)) {
+  if (!existsSync30(dir)) {
     console.log(`state: (no projects tracked yet)`);
     return;
   }
-  const files = readdirSync5(dir).filter((f) => f.endsWith(".json") && f !== "config.json" && f !== "pulled.json" && f !== "autopull-last-run.json");
+  const files = readdirSync7(dir).filter((f) => f.endsWith(".json") && f !== "config.json" && f !== "pulled.json" && f !== "autopull-last-run.json");
   if (files.length === 0) {
     console.log(`state: (no projects tracked yet)`);
     return;
@@ -7283,7 +8326,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync22(join32(dir, f), "utf-8"));
+      const s = JSON.parse(readFileSync26(join38(dir, f), "utf-8"));
       const last = typeof s.updatedAt === "number" ? new Date(s.updatedAt).toISOString() : s.lastDate ?? "never";
       const skills = Array.isArray(s.skillsGenerated) && s.skillsGenerated.length > 0 ? s.skillsGenerated.join(", ") : "none";
       console.log(`  - ${s.project} (counter=${s.counter}, last=${last}, skills=${skills})`);
@@ -7310,7 +8353,7 @@ function setInstall(loc) {
   }
   const cfg = loadScopeConfig();
   saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join32(homedir19(), ".claude", "skills") : "<cwd>/.claude/skills";
+  const path = loc === "global" ? join38(homedir23(), ".claude", "skills") : "<cwd>/.claude/skills";
   console.log(`Install location set to '${loc}'. New skills will be written to ${path}/<name>/SKILL.md.`);
 }
 function promoteSkill(name, cwd) {
@@ -7318,18 +8361,18 @@ function promoteSkill(name, cwd) {
     console.error("Usage: hivemind skillify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join32(cwd, ".claude", "skills", name);
-  const globalPath = join32(homedir19(), ".claude", "skills", name);
-  if (!existsSync26(join32(projectPath, "SKILL.md"))) {
+  const projectPath = join38(cwd, ".claude", "skills", name);
+  const globalPath = join38(homedir23(), ".claude", "skills", name);
+  if (!existsSync30(join38(projectPath, "SKILL.md"))) {
     console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
     process.exit(1);
   }
-  if (existsSync26(join32(globalPath, "SKILL.md"))) {
+  if (existsSync30(join38(globalPath, "SKILL.md"))) {
     console.error(`Skill '${name}' already exists at ${globalPath}/SKILL.md \u2014 refusing to overwrite. Remove it first or rename the project skill.`);
     process.exit(1);
   }
-  mkdirSync13(dirname8(globalPath), { recursive: true });
-  renameSync7(projectPath, globalPath);
+  mkdirSync17(dirname11(globalPath), { recursive: true });
+  renameSync8(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
 function teamAdd(name) {
@@ -7435,7 +8478,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join32(homedir19(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join38(homedir23(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterDesc = users.length === 0 ? "all users" : users.join(", ");
   console.log(`Destination: ${dest}`);
   console.log(`Filter:      ${filterDesc}${skillName ? ` \xB7 skill='${skillName}'` : ""}${dryRun ? " \xB7 dry-run" : ""}${force ? " \xB7 force" : ""}`);
@@ -7485,7 +8528,7 @@ async function unpullSkills(args) {
     all,
     legacyCleanup
   });
-  const dest = toRaw === "global" ? join32(homedir19(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join38(homedir23(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterParts = [];
   if (users.length > 0)
     filterParts.push(`users=${users.join(",")}`);
@@ -7581,14 +8624,14 @@ if (process.argv[1] && process.argv[1].endsWith("skillify.js")) {
 
 // dist/src/cli/update.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { closeSync as closeSync2, existsSync as existsSync27, mkdirSync as mkdirSync14, openSync as openSync2, readFileSync as readFileSync24, realpathSync, unlinkSync as unlinkSync11, writeSync } from "node:fs";
-import { homedir as homedir20 } from "node:os";
-import { dirname as dirname10, join as join34, sep } from "node:path";
+import { closeSync as closeSync3, existsSync as existsSync31, mkdirSync as mkdirSync18, openSync as openSync3, readFileSync as readFileSync28, realpathSync, unlinkSync as unlinkSync12, writeSync as writeSync2 } from "node:fs";
+import { homedir as homedir24 } from "node:os";
+import { dirname as dirname13, join as join40, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/src/utils/version-check.js
-import { readFileSync as readFileSync23 } from "node:fs";
-import { dirname as dirname9, join as join33 } from "node:path";
+import { readFileSync as readFileSync27 } from "node:fs";
+import { dirname as dirname12, join as join39 } from "node:path";
 function isNewer(latest, current) {
   const parse = (v) => v.split(".").map(Number);
   const [la, lb, lc] = parse(latest);
@@ -7600,7 +8643,7 @@ function isNewer(latest, current) {
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@deeplake/hivemind/latest";
 var PKG_NAME = "@deeplake/hivemind";
 function defaultLockPath() {
-  return join34(homedir20(), ".deeplake", "hivemind-update.lock");
+  return join40(homedir24(), ".deeplake", "hivemind-update.lock");
 }
 function detectInstallKind(argv1) {
   const realArgv1 = (() => {
@@ -7610,24 +8653,24 @@ function detectInstallKind(argv1) {
       return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
     }
   })();
-  let dir = dirname10(realArgv1);
+  let dir = dirname13(realArgv1);
   let installDir = null;
   for (let i = 0; i < 10; i++) {
     const pkgPath = `${dir}${sep}package.json`;
     try {
-      const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync28(pkgPath, "utf-8"));
       if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
         installDir = dir;
         break;
       }
     } catch {
     }
-    const parent = dirname10(dir);
+    const parent = dirname13(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  installDir ??= dirname10(realArgv1);
+  installDir ??= dirname13(realArgv1);
   if (realArgv1.includes(`${sep}_npx${sep}`) || realArgv1.includes(`${sep}.npx${sep}`)) {
     return { kind: "npx", installDir };
   }
@@ -7636,10 +8679,10 @@ function detectInstallKind(argv1) {
   }
   let gitDir = installDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync27(`${gitDir}${sep}.git`)) {
+    if (existsSync31(`${gitDir}${sep}.git`)) {
       return { kind: "local-dev", installDir };
     }
-    const parent = dirname10(gitDir);
+    const parent = dirname13(gitDir);
     if (parent === gitDir)
       break;
     gitDir = parent;
@@ -7661,10 +8704,10 @@ var defaultSpawn = (cmd, args) => {
   execFileSync4(cmd, args, { stdio: "inherit" });
 };
 function tryAcquireLock(path) {
-  mkdirSync14(dirname10(path), { recursive: true, mode: 448 });
+  mkdirSync18(dirname13(path), { recursive: true, mode: 448 });
   const claim = () => {
-    const fd = openSync2(path, "wx", 384);
-    writeSync(fd, String(process.pid));
+    const fd = openSync3(path, "wx", 384);
+    writeSync2(fd, String(process.pid));
     return fd;
   };
   try {
@@ -7675,7 +8718,7 @@ function tryAcquireLock(path) {
   }
   let holderPid = 0;
   try {
-    holderPid = Number(readFileSync24(path, "utf-8").trim()) || 0;
+    holderPid = Number(readFileSync28(path, "utf-8").trim()) || 0;
   } catch {
     try {
       return claim();
@@ -7692,7 +8735,7 @@ function tryAcquireLock(path) {
     }
   }
   try {
-    unlinkSync11(path);
+    unlinkSync12(path);
   } catch {
   }
   try {
@@ -7704,11 +8747,11 @@ function tryAcquireLock(path) {
 }
 function releaseLock(fd, path) {
   try {
-    closeSync2(fd);
+    closeSync3(fd);
   } catch {
   }
   try {
-    unlinkSync11(path);
+    unlinkSync12(path);
   } catch {
   }
 }
@@ -7726,7 +8769,7 @@ async function runUpdate(opts = {}) {
   }
   log(`Update available: ${current} \u2192 ${latest}`);
   const detected = opts.installKindOverride ?? detectInstallKind();
-  const spawn2 = opts.spawn ?? defaultSpawn;
+  const spawn3 = opts.spawn ?? defaultSpawn;
   switch (detected.kind) {
     case "npm-global": {
       if (opts.dryRun) {
@@ -7741,7 +8784,7 @@ async function runUpdate(opts = {}) {
       try {
         log(`Upgrading via npm\u2026`);
         try {
-          spawn2("npm", ["install", "-g", `${PKG_NAME}@latest`]);
+          spawn3("npm", ["install", "-g", `${PKG_NAME}@latest`]);
         } catch (e) {
           warn(`npm install failed: ${e.message}`);
           warn(`Try running it manually: npm install -g ${PKG_NAME}@latest`);
@@ -7750,7 +8793,7 @@ async function runUpdate(opts = {}) {
         log(``);
         log(`Refreshing agent bundles\u2026`);
         try {
-          spawn2("hivemind", ["install", "--skip-auth"]);
+          spawn3("hivemind", ["install", "--skip-auth"]);
         } catch (e) {
           warn(`Agent refresh failed: ${e.message}`);
           warn(`Run manually: hivemind install`);
@@ -7814,7 +8857,7 @@ var AUTH_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "autoupdate",
   "sessions"
 ]);
-var USAGE = `
+var USAGE2 = `
 hivemind \u2014 one brain for every agent on your team
 
 Usage:
@@ -7844,6 +8887,18 @@ Usage:
       Check npm for a newer @deeplake/hivemind, upgrade the CLI, and refresh
       every detected agent bundle. Single command for all agents.
 
+  hivemind dashboard [--cwd <path>] [--out <path>] [--no-open]
+                     [--serve] [--port <n>]
+      Build a self-contained HTML dashboard for this repo. Combines
+      KPI cards (tokens saved, skills created, memory recalls,
+      sessions) with the codebase-graph visualization. Writes to
+      ~/.hivemind/dashboards/<repo-key>/index.html by default.
+      --no-open skips the browser launch (headless / CI scenarios).
+      --serve starts a loopback HTTP server at http://127.0.0.1:<port>
+      (default 8123) so the dashboard is reachable via a URL \u2014 useful
+      over SSH; VS Code / Cursor Remote-SSH auto-forwards the port
+      and opens it in the integrated Simple Browser tab on click.
+
 Semantic search (embeddings):
   hivemind embeddings install                Download @huggingface/transformers
                                              once (~600 MB) into a shared dir,
@@ -8062,7 +9117,7 @@ async function main() {
   const args = process.argv.slice(2);
   const cmd = args[0];
   if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
-    log(USAGE);
+    log(USAGE2);
     return;
   }
   if (cmd === "--version" || cmd === "-v" || cmd === "version") {
@@ -8096,6 +9151,10 @@ async function main() {
     runSkillifyCommand(args.slice(1));
     return;
   }
+  if (cmd === "dashboard") {
+    const code = await runDashboardCommand(args.slice(1));
+    process.exit(code);
+  }
   if (cmd === "embeddings") {
     const sub = args[1];
     if (sub === "install") {
@@ -8143,7 +9202,7 @@ async function main() {
     return;
   }
   warn(`Unknown command: ${cmd}`);
-  log(USAGE);
+  log(USAGE2);
   process.exit(1);
 }
 main().catch((err) => {