@deeplake/hivemind 0.7.45 → 0.7.47

package/codex/bundle/shell/deeplake-shell.js

@@ -46081,14 +46081,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self2, node);
         }
-        return join14(output, replacement);
+        return join18(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self2 = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join14(output, rule.append(self2.options));
+          output = join18(output, rule.append(self2.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -46100,7 +46100,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace.leading || whitespace.trailing) content = content.trim();
       return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
     }
-    function join14(output, replacement) {
+    function join18(output, replacement) {
       var s12 = trimTrailingNewlines(output);
       var s22 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s12.length, replacement.length - s22.length);
@@ -66792,6 +66792,23 @@ function loadConfig() {
     tableName: process.env.HIVEMIND_TABLE ?? "memory",
     sessionsTableName: process.env.HIVEMIND_SESSIONS_TABLE ?? "sessions",
     skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
+    // Defaults match the table name written into the SQL — keep aligned
+    // with RULES_COLUMNS / TASKS_COLUMNS / TASK_EVENTS_COLUMNS in
+    // deeplake-schema.ts and with the e2e test-org override convention
+    // (memory_test / sessions_test → goals_test, etc.) documented in
+    // CLAUDE.md.
+    rulesTableName: process.env.HIVEMIND_RULES_TABLE ?? "hivemind_rules",
+    tasksTableName: process.env.HIVEMIND_TASKS_TABLE ?? "hivemind_tasks",
+    taskEventsTableName: process.env.HIVEMIND_TASK_EVENTS_TABLE ?? "hivemind_task_events",
+    // Goals + KPIs (refined design — VFS path classifier maps
+    //   memory/goal/<user>/<status>/<uuid>.md → hivemind_goals row
+    //   memory/kpi/<uuid>/<kpi_id>.md → hivemind_kpis row
+    // See src/shell/deeplake-fs.ts for the translation logic and
+    // GOALS_COLUMNS / KPIS_COLUMNS in deeplake-schema.ts for the
+    // table shape.
+    goalsTableName: process.env.HIVEMIND_GOALS_TABLE ?? "hivemind_goals",
+    kpisTableName: process.env.HIVEMIND_KPIS_TABLE ?? "hivemind_kpis",
+    codebaseTableName: process.env.HIVEMIND_CODEBASE_TABLE ?? "codebase",
     memoryPath: process.env.HIVEMIND_MEMORY_PATH ?? join4(home, ".deeplake", "memory")
   };
 }
@@ -66892,6 +66909,65 @@ var SKILLS_COLUMNS = Object.freeze([
   { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
   { name: "updated_at", sql: "TEXT NOT NULL DEFAULT ''" }
 ]);
+var RULES_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "rule_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'team'" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'active'" },
+  { name: "assigned_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var TASKS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "text", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "scope", sql: "TEXT NOT NULL DEFAULT 'me'" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'active'" },
+  { name: "assigned_to", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "assigned_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "kpis", sql: "JSONB" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var TASK_EVENTS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "task_version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "kpi_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "value", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "note", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "source", sql: "TEXT NOT NULL DEFAULT 'user'" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var GOALS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "owner", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "status", sql: "TEXT NOT NULL DEFAULT 'opened'" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
+var KPIS_COLUMNS = Object.freeze([
+  { name: "id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "goal_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "kpi_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "content", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "version", sql: "BIGINT NOT NULL DEFAULT 1" },
+  { name: "created_at", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "agent", sql: "TEXT NOT NULL DEFAULT 'manual'" },
+  { name: "plugin_version", sql: "TEXT NOT NULL DEFAULT ''" }
+]);
 function validateSchema(label, cols) {
   const seen = /* @__PURE__ */ new Set();
   for (const col of cols) {
@@ -66909,9 +66985,38 @@ function validateSchema(label, cols) {
     }
   }
 }
+var CODEBASE_COLUMNS = Object.freeze([
+  // Identity key (matches the PK below)
+  { name: "org_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "workspace_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "repo_slug", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "user_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "worktree_id", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "commit_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Observation metadata
+  { name: "parent_sha", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "branch", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "ts", sql: "TIMESTAMP" },
+  { name: "pushed_by", sql: "TEXT NOT NULL DEFAULT ''" },
+  // Snapshot payload
+  { name: "snapshot_sha256", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "snapshot_jsonb", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "node_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  { name: "edge_count", sql: "BIGINT NOT NULL DEFAULT 0" },
+  // Generator metadata (for drift diagnostics — what hivemind version produced this?)
+  { name: "generator", sql: "TEXT NOT NULL DEFAULT 'hivemind-graph'" },
+  { name: "generator_version", sql: "TEXT NOT NULL DEFAULT ''" },
+  { name: "schema_version", sql: "BIGINT NOT NULL DEFAULT 1" }
+]);
 validateSchema("MEMORY_COLUMNS", MEMORY_COLUMNS);
 validateSchema("SESSIONS_COLUMNS", SESSIONS_COLUMNS);
 validateSchema("SKILLS_COLUMNS", SKILLS_COLUMNS);
+validateSchema("RULES_COLUMNS", RULES_COLUMNS);
+validateSchema("TASKS_COLUMNS", TASKS_COLUMNS);
+validateSchema("TASK_EVENTS_COLUMNS", TASK_EVENTS_COLUMNS);
+validateSchema("GOALS_COLUMNS", GOALS_COLUMNS);
+validateSchema("KPIS_COLUMNS", KPIS_COLUMNS);
+validateSchema("CODEBASE_COLUMNS", CODEBASE_COLUMNS);
 function buildCreateTableSql(tableName, cols) {
   const safe = sqlIdent(tableName);
   const colSql = cols.map((c15) => `${c15.name} ${c15.sql}`).join(", ");
@@ -67136,7 +67241,7 @@ function getQueryTimeoutMs() {
   return Number(process.env.HIVEMIND_QUERY_TIMEOUT_MS ?? 1e4);
 }
 function sleep2(ms3) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms3));
+  return new Promise((resolve7) => setTimeout(resolve7, ms3));
 }
 function isTimeoutError(error) {
   const name = error instanceof Error ? error.name.toLowerCase() : "";
@@ -67166,7 +67271,7 @@ var Semaphore = class {
       this.active++;
       return;
     }
-    await new Promise((resolve6) => this.waiting.push(resolve6));
+    await new Promise((resolve7) => this.waiting.push(resolve7));
   }
   release() {
     this.active--;
@@ -67476,6 +67581,24 @@ var DeeplakeApi = class {
    * This sidesteps the Deeplake UPDATE-coalescing quirk that bit the wiki
    * worker.
    */
+  /**
+   * Create the codebase table. One row per (org, workspace, repo, user,
+   * worktree, commit) — see CODEBASE_COLUMNS for the schema. Healing
+   * + index follow the same pattern as ensureSessionsTable.
+   */
+  async ensureCodebaseTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, CODEBASE_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, CODEBASE_COLUMNS);
+    await this.ensureLookupIndex(safe, "codebase_identity", `("org_id", "workspace_id", "repo_slug", "user_id", "worktree_id", "commit_sha")`);
+  }
   async ensureSkillsTable(name) {
     const safe = sqlIdent(name);
     const tables = await this.listTables();
@@ -67489,13 +67612,118 @@ var DeeplakeApi = class {
     await this.healSchema(safe, SKILLS_COLUMNS);
     await this.ensureLookupIndex(safe, "project_key_name", `("project_key", "name")`);
   }
+  /**
+   * Create the rules table.
+   *
+   * One row per rule version (same write pattern as skills): edits INSERT
+   * a fresh row with version+1, reads pick latest per rule_id via
+   * `ORDER BY version DESC LIMIT 1`. Sidesteps the Deeplake
+   * UPDATE-coalescing quirk by never UPDATEing.
+   */
+  async ensureRulesTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, RULES_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, RULES_COLUMNS);
+    await this.ensureLookupIndex(safe, "rule_id_version", `("rule_id", "version")`);
+  }
+  /**
+   * Create the tasks table.
+   *
+   * Same write pattern as rules + skills. `kpis` is a nullable JSONB
+   * column with the agent's KPI metadata; KPI current values come from
+   * `task_events` (SUM(value)), not this snapshot.
+   */
+  async ensureTasksTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, TASKS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, TASKS_COLUMNS);
+    await this.ensureLookupIndex(safe, "task_id_version", `("task_id", "version")`);
+  }
+  /**
+   * Create the task-events table.
+   *
+   * Append-only. Every INSERT is a fresh row; never UPDATE. KPI current
+   * value is `SUM(value) WHERE task_id=? AND kpi_id=?`. Index on
+   * (task_id, kpi_id) is the canonical aggregation key.
+   */
+  async ensureTaskEventsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, TASK_EVENTS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, TASK_EVENTS_COLUMNS);
+    await this.ensureLookupIndex(safe, "task_id_kpi_id", `("task_id", "kpi_id")`);
+  }
+  /**
+   * Create the goals table.
+   *
+   * Backed by the VFS path convention memory/goal/<owner>/<status>/<goal_id>.md.
+   * INSERT-only version-bumped: rm and mv operations translate to fresh
+   * v=N+1 rows (status flips for mv → closed; rm is the same soft-close).
+   * The (goal_id, version) index lets the VFS dispatch a cheap latest-row
+   * read on cat / Read of a single goal.
+   */
+  async ensureGoalsTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, GOALS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, GOALS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_version", `("goal_id", "version")`);
+    await this.ensureLookupIndex(safe, "owner_status", `("owner", "status")`);
+  }
+  /**
+   * Create the kpis table.
+   *
+   * Backed by memory/kpi/<goal_id>/<kpi_id>.md. KPI rows do NOT carry
+   * owner — ownership derives from the parent goal via logical join on
+   * goal_id. INSERT-only version-bumped. (goal_id, kpi_id) index is the
+   * canonical lookup the VFS uses on Read and Write.
+   */
+  async ensureKpisTable(name) {
+    const safe = sqlIdent(name);
+    const tables = await this.listTables();
+    if (!tables.includes(safe)) {
+      log3(`table "${safe}" not found, creating`);
+      await this.createTableWithRetry(buildCreateTableSql(safe, KPIS_COLUMNS), safe);
+      log3(`table "${safe}" created`);
+      if (!tables.includes(safe))
+        this._tablesCache = [...tables, safe];
+    }
+    await this.healSchema(safe, KPIS_COLUMNS);
+    await this.ensureLookupIndex(safe, "goal_id_kpi_id", `("goal_id", "kpi_id")`);
+  }
 };
 
 // dist/src/shell/deeplake-fs.js
-import { basename as basename4, posix } from "node:path";
+import { basename as basename5, posix } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname9, join as join16 } from "node:path";
 
 // dist/src/shell/grep-core.js
 var TOOL_INPUT_FIELDS = [
@@ -68176,7 +68404,7 @@ var EmbedClient = class {
     }
   }
   connectOnce() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const sock = connect(this.socketPath);
       const to3 = setTimeout(() => {
         sock.destroy();
@@ -68184,7 +68412,7 @@ var EmbedClient = class {
       }, this.timeoutMs);
       sock.once("connect", () => {
         clearTimeout(to3);
-        resolve6(sock);
+        resolve7(sock);
       });
       sock.once("error", (e6) => {
         clearTimeout(to3);
@@ -68266,7 +68494,7 @@ var EmbedClient = class {
     throw new Error("daemon did not become ready within spawnWaitMs");
   }
   sendAndWait(sock, req) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       let buf = "";
       const to3 = setTimeout(() => {
         sock.destroy();
@@ -68281,7 +68509,7 @@ var EmbedClient = class {
         const line = buf.slice(0, nl3);
         clearTimeout(to3);
         try {
-          resolve6(JSON.parse(line));
+          resolve7(JSON.parse(line));
         } catch (e6) {
           reject(e6);
         }
@@ -68501,6 +68729,516 @@ function buildVirtualIndexContent(summaryRows, sessionRows = [], opts = {}) {
   return lines.join("\n");
 }
 
+// dist/src/shell/goal-paths.js
+var VALID_STATUS = /* @__PURE__ */ new Set(["opened", "in_progress", "closed"]);
+function segmentsUnderMemory(p22) {
+  let s10 = p22.replace(/\/+$/, "");
+  const memIdx = s10.lastIndexOf("/memory/");
+  if (memIdx >= 0) {
+    s10 = s10.slice(memIdx + "/memory/".length);
+  } else {
+    s10 = s10.replace(/^\/+/, "");
+    if (s10 === "memory")
+      return null;
+    if (s10.startsWith("memory/"))
+      s10 = s10.slice("memory/".length);
+  }
+  if (s10.length === 0)
+    return null;
+  return s10.split("/");
+}
+function classifyPath(p22) {
+  const segs = segmentsUnderMemory(p22);
+  if (!segs)
+    return "memory";
+  if (segs[0] === "goal") {
+    if (segs.length === 4 && segs[3].endsWith(".md") && VALID_STATUS.has(segs[2])) {
+      return "goal";
+    }
+    return "memory";
+  }
+  if (segs[0] === "kpi") {
+    if (segs.length === 3 && segs[2].endsWith(".md")) {
+      return "kpi";
+    }
+    return "memory";
+  }
+  return "memory";
+}
+function decomposeGoalPath(p22) {
+  const segs = segmentsUnderMemory(p22);
+  if (!segs || segs.length !== 4 || segs[0] !== "goal") {
+    throw new Error(`Not a goal path: ${p22}`);
+  }
+  const status = segs[2];
+  if (!VALID_STATUS.has(status)) {
+    throw new Error(`Invalid goal status in path: ${p22} (got '${status}')`);
+  }
+  const filename = segs[3];
+  if (!filename.endsWith(".md")) {
+    throw new Error(`Goal path must end with .md: ${p22}`);
+  }
+  return {
+    owner: segs[1],
+    status,
+    goal_id: filename.slice(0, -".md".length)
+  };
+}
+function decomposeKpiPath(p22) {
+  const segs = segmentsUnderMemory(p22);
+  if (!segs || segs.length !== 3 || segs[0] !== "kpi") {
+    throw new Error(`Not a kpi path: ${p22}`);
+  }
+  const filename = segs[2];
+  if (!filename.endsWith(".md")) {
+    throw new Error(`KPI path must end with .md: ${p22}`);
+  }
+  return {
+    goal_id: segs[1],
+    kpi_id: filename.slice(0, -".md".length)
+  };
+}
+function composeGoalPath(parts) {
+  return `/goal/${parts.owner}/${parts.status}/${parts.goal_id}.md`;
+}
+function composeKpiPath(parts) {
+  return `/kpi/${parts.goal_id}/${parts.kpi_id}.md`;
+}
+
+// dist/src/graph/vfs-handler.js
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { join as join15, dirname as dirname8 } from "node:path";
+
+// dist/src/graph/last-build.js
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync7, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join12 } from "node:path";
+function lastBuildPath(baseDir, worktreeId) {
+  if (worktreeId !== void 0) {
+    return join12(baseDir, "worktrees", worktreeId, ".last-build.json");
+  }
+  return join12(baseDir, ".last-build.json");
+}
+function readLastBuild(baseDir, worktreeId) {
+  let path2 = lastBuildPath(baseDir, worktreeId);
+  if (!existsSync6(path2)) {
+    if (worktreeId === void 0)
+      return null;
+    const legacy = lastBuildPath(baseDir, void 0);
+    if (!existsSync6(legacy))
+      return null;
+    path2 = legacy;
+  }
+  let raw;
+  try {
+    raw = readFileSync7(path2, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object")
+    return null;
+  const o14 = parsed;
+  if (typeof o14.ts !== "number" || !Number.isFinite(o14.ts))
+    return null;
+  if (o14.commit_sha !== null && typeof o14.commit_sha !== "string")
+    return null;
+  if (typeof o14.snapshot_sha256 !== "string")
+    return null;
+  const out = { ts: o14.ts, commit_sha: o14.commit_sha, snapshot_sha256: o14.snapshot_sha256 };
+  if (typeof o14.node_count === "number" && Number.isFinite(o14.node_count) && o14.node_count >= 0) {
+    out.node_count = o14.node_count;
+  }
+  if (typeof o14.edge_count === "number" && Number.isFinite(o14.edge_count) && o14.edge_count >= 0) {
+    out.edge_count = o14.edge_count;
+  }
+  return out;
+}
+
+// dist/src/graph/snapshot.js
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync7, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname7, join as join14 } from "node:path";
+
+// dist/src/graph/history.js
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname6, join as join13 } from "node:path";
+
+// dist/src/graph/snapshot.js
+function graphsRoot() {
+  return process.env.HIVEMIND_GRAPHS_HOME ?? join14(homedir8(), ".hivemind", "graphs");
+}
+function repoDir(repoKey) {
+  return join14(graphsRoot(), repoKey);
+}
+
+// dist/src/utils/repo-identity.js
+import { execSync } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { basename as basename4, resolve as resolve5 } from "node:path";
+var DEFAULT_PORTS = {
+  http: "80",
+  https: "443",
+  ssh: "22",
+  git: "9418"
+};
+function normalizeGitRemoteUrl(url) {
+  let s10 = url.trim();
+  const schemeMatch = s10.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+  const scheme = schemeMatch ? schemeMatch[1].toLowerCase() : null;
+  if (schemeMatch)
+    s10 = s10.slice(schemeMatch[0].length);
+  if (!scheme) {
+    const scp = s10.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/);
+    if (scp)
+      s10 = `${scp[1]}/${scp[2]}`;
+  }
+  s10 = s10.replace(/^[^@/]+@/, "");
+  if (scheme && DEFAULT_PORTS[scheme]) {
+    s10 = s10.replace(new RegExp(`^([^/]+):${DEFAULT_PORTS[scheme]}(/|$)`), "$1$2");
+  }
+  s10 = s10.replace(/\.git\/?$/i, "");
+  s10 = s10.replace(/\/+$/, "");
+  return s10.toLowerCase();
+}
+function deriveProjectKey(cwd) {
+  const absCwd = resolve5(cwd);
+  const project = basename4(absCwd) || "unknown";
+  let signature = null;
+  try {
+    const raw = execSync("git config --get remote.origin.url", {
+      cwd: absCwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    signature = raw ? normalizeGitRemoteUrl(raw) : null;
+  } catch {
+  }
+  const input = signature ?? absCwd;
+  const key = createHash2("sha1").update(input).digest("hex").slice(0, 16);
+  return { key, project };
+}
+
+// dist/src/graph/vfs-handler.js
+function workTreeIdFor(cwd) {
+  return createHash3("sha256").update(cwd).digest("hex").slice(0, 16);
+}
+function handleGraphVfs(subpath, cwd) {
+  const path2 = subpath.replace(/^\/+/, "");
+  if (path2 === "" || path2 === "/") {
+    return { kind: "ok", body: dirListing() };
+  }
+  if (path2 === "index.md" || path2 === "index") {
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderIndex(snap, baseDir, cwd)
+    }));
+  }
+  if (path2.startsWith("find/")) {
+    const pattern = path2.slice("find/".length);
+    if (pattern === "") {
+      return { kind: "not-found", message: "find/ requires a pattern: cat memory/graph/find/<keyword>" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderFind(snap, pattern, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  if (path2.startsWith("show/")) {
+    const key = path2.slice("show/".length);
+    if (key === "") {
+      return { kind: "not-found", message: "show/ requires a handle or pattern" };
+    }
+    return loadSnapshotOrError(cwd, (snap, baseDir) => ({
+      kind: "ok",
+      body: renderShow(snap, key, baseDir, workTreeIdFor(cwd))
+    }));
+  }
+  return {
+    kind: "not-found",
+    message: `Unknown endpoint: graph/${path2}
+Available: index.md, find/<pattern>, show/<handle-or-pattern>`
+  };
+}
+function loadSnapshotOrError(cwd, fn4) {
+  let key;
+  let baseDir;
+  try {
+    key = deriveProjectKey(cwd).key;
+    baseDir = repoDir(key);
+  } catch (e6) {
+    return { kind: "no-graph", message: `Cannot derive repo identity: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+  const wt3 = workTreeIdFor(cwd);
+  const last = readLastBuild(baseDir, wt3);
+  if (last === null) {
+    return {
+      kind: "no-graph",
+      message: "No local graph for this worktree yet. Run `hivemind graph build` (or `hivemind graph pull` if a teammate has built this commit)."
+    };
+  }
+  const fileBase = last.commit_sha ?? last.snapshot_sha256;
+  const snapPath = join15(baseDir, "snapshots", `${fileBase}.json`);
+  if (!existsSync8(snapPath)) {
+    return { kind: "no-graph", message: `Snapshot file missing on disk: ${snapPath}` };
+  }
+  let snap;
+  try {
+    snap = JSON.parse(readFileSync9(snapPath, "utf8"));
+  } catch (e6) {
+    return { kind: "no-graph", message: `Failed to parse snapshot: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+  if (!Array.isArray(snap.nodes) || !Array.isArray(snap.links)) {
+    return { kind: "no-graph", message: "Snapshot schema is invalid (missing nodes/links arrays)." };
+  }
+  try {
+    return fn4(snap, baseDir);
+  } catch (e6) {
+    return { kind: "no-graph", message: `Failed to render graph view: ${e6 instanceof Error ? e6.message : String(e6)}` };
+  }
+}
+function dirListing() {
+  return [
+    "index.md",
+    "find/",
+    "show/"
+  ].join("\n");
+}
+function renderIndex(snap, baseDir, cwd) {
+  const commit = snap.graph.commit_sha?.slice(0, 7) ?? "no-commit";
+  const fullCommit = snap.graph.commit_sha ?? "no-commit";
+  const totalNodes = snap.nodes.length;
+  const totalEdges = snap.links.length;
+  const byFile = {};
+  for (const n24 of snap.nodes)
+    byFile[n24.source_file] = (byFile[n24.source_file] ?? 0) + 1;
+  const topFiles = Object.entries(byFile).sort(([, a15], [, b26]) => b26 - a15).slice(0, 8);
+  const byRel = {};
+  for (const e6 of snap.links)
+    byRel[e6.relation] = (byRel[e6.relation] ?? 0) + 1;
+  const byKind = {};
+  for (const n24 of snap.nodes)
+    byKind[n24.kind] = (byKind[n24.kind] ?? 0) + 1;
+  const lines = [];
+  lines.push(`# Code Graph \u2014 ${snap.observation.repo_project}`);
+  lines.push("");
+  lines.push(`Commit:  ${fullCommit}  (built ${snap.observation.ts})`);
+  lines.push(`Branch:  ${snap.observation.branch ?? "(detached)"}`);
+  lines.push(`Source:  ${join15(baseDir, "snapshots", `${commit ? snap.graph.commit_sha : "?"}.json`)}`);
+  lines.push("");
+  lines.push(`Nodes:   ${totalNodes}    Edges: ${totalEdges}`);
+  lines.push("");
+  lines.push("## How to query");
+  lines.push("  cat ~/.deeplake/memory/graph/find/<pattern>");
+  lines.push("    Case-insensitive substring match on node id + label.");
+  lines.push("    Emits numbered handles [1] [2] ... saved for this worktree.");
+  lines.push("");
+  lines.push("  cat ~/.deeplake/memory/graph/show/<handle-or-pattern>");
+  lines.push("    <handle>: a digit from a prior `find/` (e.g. 3).");
+  lines.push("    <pattern>: a substring; resolves to a unique node if possible,");
+  lines.push("               or shows candidates if ambiguous.");
+  lines.push("    Output: node detail + 1-hop neighbors grouped by edge kind.");
+  lines.push("");
+  lines.push("## Node kinds");
+  for (const [k17, n24] of Object.entries(byKind).sort(([, a15], [, b26]) => b26 - a15)) {
+    lines.push(`  ${k17.padEnd(12)} ${n24}`);
+  }
+  lines.push("");
+  lines.push("## Edge kinds");
+  for (const [k17, n24] of Object.entries(byRel).sort(([, a15], [, b26]) => b26 - a15)) {
+    lines.push(`  ${k17.padEnd(12)} ${n24}`);
+  }
+  lines.push("");
+  lines.push("## Top files by node count");
+  for (const [f11, n24] of topFiles) {
+    lines.push(`  ${String(n24).padStart(4)}  ${f11}`);
+  }
+  lines.push("");
+  lines.push(`Limitations:`);
+  lines.push(`  - TypeScript only. AST-based, no semantic similarity edges.`);
+  lines.push(`  - 'calls' edges are intra-file only (Phase 1 extractor doesn't resolve cross-file).`);
+  lines.push(`    A node showing "Incoming (0)" may still have callers in OTHER files \u2014`);
+  lines.push(`    treat it as "no callers in the same file", not "unused".`);
+  lines.push(`  - 'imports' edges are file-level and DO span files; trust them.`);
+  lines.push(`  - Stale after edits \u2014 if a file's mtime is newer than the build, read the live source.`);
+  void cwd;
+  return lines.join("\n");
+}
+function renderFind(snap, pattern, baseDir, worktreeId) {
+  const needle = pattern.toLowerCase();
+  const matches = [];
+  for (const n24 of snap.nodes) {
+    const id = n24.id.toLowerCase();
+    const lbl = n24.label.toLowerCase();
+    if (id.includes(needle) || lbl.includes(needle))
+      matches.push(n24);
+  }
+  matches.sort((a15, b26) => {
+    const ra2 = rank(a15, needle);
+    const rb = rank(b26, needle);
+    if (ra2 !== rb)
+      return ra2 - rb;
+    return a15.id.localeCompare(b26.id);
+  });
+  const capped = matches.slice(0, 50);
+  if (capped.length === 0) {
+    return `No matches for "${pattern}" in ${snap.nodes.length} nodes.
+Try a shorter or different substring.`;
+  }
+  saveHandles(baseDir, worktreeId, capped.map((n24) => n24.id), pattern);
+  const lines = [];
+  lines.push(`${matches.length} match${matches.length === 1 ? "" : "es"} for "${pattern}"${matches.length > capped.length ? ` (showing first ${capped.length})` : ""}:`);
+  lines.push("");
+  for (let i11 = 0; i11 < capped.length; i11++) {
+    const n24 = capped[i11];
+    const tag = n24.exported ? "exported" : "internal";
+    lines.push(`  [${i11 + 1}]  ${n24.id}   ${n24.kind} (${tag})`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N> to see node + 1-hop neighbors");
+  return lines.join("\n");
+}
+function renderShow(snap, key, baseDir, worktreeId) {
+  if (/^\d+$/.test(key)) {
+    const idx = parseInt(key, 10);
+    const handles = loadHandles(baseDir, worktreeId);
+    if (handles === null) {
+      return `Handle [${idx}] not resolvable: no recent find/ in this worktree. Run cat memory/graph/find/<pattern> first.`;
+    }
+    if (idx < 1 || idx > handles.ids.length) {
+      return `Handle [${idx}] out of range. Last find/${handles.pattern} produced ${handles.ids.length} matches.`;
+    }
+    const nodeId = handles.ids[idx - 1];
+    const node = snap.nodes.find((n24) => n24.id === nodeId);
+    if (!node) {
+      return `Handle [${idx}] points at "${nodeId}" but that node is no longer in the snapshot (graph rebuilt since last find?). Re-run find.`;
+    }
+    return renderNodeDetail(snap, node);
+  }
+  const needle = key.toLowerCase();
+  const matches = snap.nodes.filter((n24) => n24.id.toLowerCase().includes(needle));
+  if (matches.length === 0) {
+    return `No node matches "${key}". Try cat memory/graph/find/${key} for fuzzy search.`;
+  }
+  if (matches.length === 1) {
+    return renderNodeDetail(snap, matches[0]);
+  }
+  saveHandles(baseDir, worktreeId, matches.slice(0, 50).map((n24) => n24.id), key);
+  const lines = [];
+  lines.push(`"${key}" matches ${matches.length} nodes. Pick one:`);
+  lines.push("");
+  for (let i11 = 0; i11 < Math.min(matches.length, 50); i11++) {
+    lines.push(`  [${i11 + 1}]  ${matches[i11].id}`);
+  }
+  lines.push("");
+  lines.push("Use: cat ~/.deeplake/memory/graph/show/<N>");
+  return lines.join("\n");
+}
+function renderNodeDetail(snap, node) {
+  const incoming = [];
+  const outgoing = [];
+  for (const e6 of snap.links) {
+    if (e6.target === node.id)
+      incoming.push(e6);
+    if (e6.source === node.id)
+      outgoing.push(e6);
+  }
+  const groupBy = (es3) => {
+    const m26 = /* @__PURE__ */ new Map();
+    for (const e6 of es3) {
+      const list = m26.get(e6.relation) ?? [];
+      list.push(e6);
+      m26.set(e6.relation, list);
+    }
+    return m26;
+  };
+  const inGrp = groupBy(incoming);
+  const outGrp = groupBy(outgoing);
+  const lines = [];
+  lines.push(`Node: ${node.id}`);
+  lines.push(`  source: ${node.source_file}:${node.source_location}`);
+  lines.push(`  kind:   ${node.kind}`);
+  lines.push(`  label:  ${node.label}`);
+  lines.push(`  ${node.exported ? "exported" : "internal"}`);
+  lines.push("");
+  const inHint = incoming.length === 0 ? "  \u2014 no edges from THIS file (intra-file only; may still be called from other files)" : ":";
+  lines.push(`Incoming (${incoming.length})${inHint}`);
+  for (const [rel, es3] of [...inGrp.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
+    lines.push(`  ${rel} (${es3.length}):`);
+    for (const e6 of es3.slice(0, 20)) {
+      lines.push(`    ${e6.source}`);
+    }
+    if (es3.length > 20)
+      lines.push(`    ... and ${es3.length - 20} more`);
+  }
+  lines.push("");
+  lines.push(`Outgoing (${outgoing.length})${outgoing.length === 0 ? "  \u2014 this node has no edges out" : ":"}`);
+  for (const [rel, es3] of [...outGrp.entries()].sort(([a15], [b26]) => a15.localeCompare(b26))) {
+    lines.push(`  ${rel} (${es3.length}):`);
+    for (const e6 of es3.slice(0, 20)) {
+      lines.push(`    ${e6.target}`);
+    }
+    if (es3.length > 20)
+      lines.push(`    ... and ${es3.length - 20} more`);
+  }
+  return lines.join("\n");
+}
+function rank(n24, needle) {
+  const lbl = n24.label.toLowerCase();
+  const id = n24.id.toLowerCase();
+  if (lbl === needle)
+    return 0;
+  if (lbl.startsWith(needle))
+    return 1;
+  if (lbl.includes(needle))
+    return 2;
+  if (id.includes(needle))
+    return 3;
+  return 4;
+}
+function handlesPath(baseDir, worktreeId) {
+  return join15(baseDir, "worktrees", worktreeId, ".find-handles.json");
+}
+function saveHandles(baseDir, worktreeId, ids, pattern) {
+  const path2 = handlesPath(baseDir, worktreeId);
+  const payload = { pattern, ts: Date.now(), ids };
+  try {
+    mkdirSync8(dirname8(path2), { recursive: true });
+    const tmp = `${path2}.tmp.${process.pid}.${Date.now()}`;
+    writeFileSync7(tmp, JSON.stringify(payload));
+    renameSync5(tmp, path2);
+  } catch {
+  }
+}
+function loadHandles(baseDir, worktreeId) {
+  const path2 = handlesPath(baseDir, worktreeId);
+  if (!existsSync8(path2))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync9(path2, "utf8"));
+    if (parsed === null || typeof parsed !== "object")
+      return null;
+    const o14 = parsed;
+    if (typeof o14.pattern !== "string")
+      return null;
+    if (typeof o14.ts !== "number")
+      return null;
+    if (!Array.isArray(o14.ids))
+      return null;
+    if (!o14.ids.every((s10) => typeof s10 === "string"))
+      return null;
+    return { pattern: o14.pattern, ts: o14.ts, ids: o14.ids };
+  } catch {
+    return null;
+  }
+}
+
 // dist/src/shell/deeplake-fs.js
 var BATCH_SIZE = 10;
 var PREFETCH_BATCH_SIZE = 50;
@@ -68530,7 +69268,7 @@ function normalizeSessionMessage(path2, message) {
   return normalizeContent(path2, raw);
 }
 function resolveEmbedDaemonPath() {
-  return join12(dirname5(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
+  return join16(dirname9(fileURLToPath(import.meta.url)), "..", "embeddings", "embed-daemon.js");
 }
 function joinSessionMessages(path2, messages) {
   return messages.map((message) => normalizeSessionMessage(path2, message)).join("\n");
@@ -68538,6 +69276,29 @@ function joinSessionMessages(path2, messages) {
 function fsErr(code, msg, path2) {
   return Object.assign(new Error(`${code}: ${msg}, '${path2}'`), { code });
 }
+var GRAPH_ROOT = "/graph";
+var GRAPH_PREFIX = "/graph/";
+var GRAPH_DIRS = /* @__PURE__ */ new Set([GRAPH_ROOT, "/graph/find", "/graph/show"]);
+function isGraphPath(p22) {
+  return p22 === GRAPH_ROOT || p22.startsWith(GRAPH_PREFIX);
+}
+function isGraphDir(p22) {
+  return GRAPH_DIRS.has(p22);
+}
+function graphSubpathOf(p22) {
+  if (p22 === GRAPH_ROOT)
+    return "";
+  return p22.slice(GRAPH_PREFIX.length);
+}
+function readGraphFile(p22, cwd) {
+  const sub = graphSubpathOf(p22);
+  const r10 = handleGraphVfs(sub, cwd);
+  if (r10.kind === "ok")
+    return r10.body;
+  if (r10.kind === "no-graph")
+    return `(no-graph) ${r10.message}`;
+  throw fsErr("ENOENT", `${r10.message}`, p22);
+}
 var DeeplakeFs = class _DeeplakeFs {
   client;
   table;
@@ -68561,6 +69322,12 @@ var DeeplakeFs = class _DeeplakeFs {
   // Paths that live in the sessions table (multi-row, read by concatenation)
   sessionPaths = /* @__PURE__ */ new Set();
   sessionsTable = null;
+  // Path-routed structured tables. When non-null, the VFS classifies
+  // each path (see ./goal-paths.ts) and dispatches reads/writes to
+  // the right table instead of the generic memory table. Null means
+  // the goal/kpi routing is disabled (test or legacy configurations).
+  goalsTable = null;
+  kpisTable = null;
   // Embedding client lazily created on first flush. Lives as long as the process.
   embedClient = null;
   constructor(client, table, mountPoint) {
@@ -68571,10 +69338,24 @@ var DeeplakeFs = class _DeeplakeFs {
     if (mountPoint !== "/")
       this.dirs.set("/", /* @__PURE__ */ new Set([mountPoint.slice(1)]));
   }
-  static async create(client, table, mount = "/memory", sessionsTable) {
+  static async create(client, table, mount = "/memory", sessionsTable, extra) {
     const fs3 = new _DeeplakeFs(client, table, mount);
     fs3.sessionsTable = sessionsTable ?? null;
+    fs3.goalsTable = extra?.goalsTable ?? null;
+    fs3.kpisTable = extra?.kpisTable ?? null;
     await client.ensureTable();
+    if (fs3.goalsTable) {
+      try {
+        await client.ensureGoalsTable(fs3.goalsTable);
+      } catch {
+      }
+    }
+    if (fs3.kpisTable) {
+      try {
+        await client.ensureKpisTable(fs3.kpisTable);
+      } catch {
+      }
+    }
     let sessionSyncOk = true;
     const memoryBootstrap = (async () => {
       const sql = `SELECT path, size_bytes, mime_type FROM "${table}" ORDER BY path`;
@@ -68620,7 +69401,61 @@ var DeeplakeFs = class _DeeplakeFs {
       } catch {
       }
     })() : Promise.resolve();
-    await Promise.all([memoryBootstrap, sessionsBootstrap]);
+    const goalsBootstrap = fs3.goalsTable ? (async () => {
+      try {
+        const goalRows = await client.query(
+          // One row per goal_id (UPDATE-or-INSERT model). Synthesize
+          // the canonical VFS path from owner / status / goal_id.
+          `SELECT goal_id, owner, status, content, created_at FROM "${fs3.goalsTable}" ORDER BY created_at DESC`
+        );
+        for (const row of goalRows) {
+          const owner = String(row["owner"] ?? "");
+          const status = String(row["status"] ?? "");
+          const goal_id = String(row["goal_id"] ?? "");
+          if (!owner || !status || !goal_id)
+            continue;
+          if (status !== "opened" && status !== "in_progress" && status !== "closed")
+            continue;
+          const p22 = composeGoalPath({ owner, status, goal_id });
+          const content = String(row["content"] ?? "");
+          fs3.files.set(p22, Buffer.from(content, "utf-8"));
+          fs3.meta.set(p22, {
+            size: Buffer.byteLength(content, "utf-8"),
+            mime: "text/markdown",
+            mtime: /* @__PURE__ */ new Date()
+          });
+          fs3.addToTree(p22);
+          fs3.flushed.add(p22);
+        }
+      } catch {
+      }
+    })() : Promise.resolve();
+    const kpisBootstrap = fs3.kpisTable ? (async () => {
+      try {
+        const kpiRows = await client.query(
+          // One row per (goal_id, kpi_id) (UPDATE-or-INSERT model).
+          `SELECT goal_id, kpi_id, content, created_at FROM "${fs3.kpisTable}" ORDER BY created_at DESC`
+        );
+        for (const row of kpiRows) {
+          const goal_id = String(row["goal_id"] ?? "");
+          const kpi_id = String(row["kpi_id"] ?? "");
+          if (!goal_id || !kpi_id)
+            continue;
+          const p22 = composeKpiPath({ goal_id, kpi_id });
+          const content = String(row["content"] ?? "");
+          fs3.files.set(p22, Buffer.from(content, "utf-8"));
+          fs3.meta.set(p22, {
+            size: Buffer.byteLength(content, "utf-8"),
+            mime: "text/markdown",
+            mtime: /* @__PURE__ */ new Date()
+          });
+          fs3.addToTree(p22);
+          fs3.flushed.add(p22);
+        }
+      } catch {
+      }
+    })() : Promise.resolve();
+    await Promise.all([memoryBootstrap, sessionsBootstrap, goalsBootstrap, kpisBootstrap]);
     return fs3;
   }
   // ── tree management ───────────────────────────────────────────────────────
@@ -68639,7 +69474,7 @@ var DeeplakeFs = class _DeeplakeFs {
     this.pending.delete(filePath);
     this.flushed.delete(filePath);
     const parent = parentOf(filePath);
-    this.dirs.get(parent)?.delete(basename4(filePath));
+    this.dirs.get(parent)?.delete(basename5(filePath));
   }
   // ── flush / write batching ────────────────────────────────────────────────
   scheduleFlush() {
@@ -68689,6 +69524,15 @@ var DeeplakeFs = class _DeeplakeFs {
     return Promise.all(rows.map((r10) => this.embedClient.embed(r10.contentText, "document")));
   }
   async upsertRow(r10, embedding) {
+    const kind = classifyPath(r10.path);
+    if (kind === "goal" && this.goalsTable) {
+      await this.upsertGoalRow(r10);
+      return;
+    }
+    if (kind === "kpi" && this.kpisTable) {
+      await this.upsertKpiRow(r10);
+      return;
+    }
     const text = sqlStr(r10.contentText);
     const p22 = sqlStr(r10.path);
     const fname = sqlStr(r10.filename);
@@ -68712,6 +69556,57 @@ var DeeplakeFs = class _DeeplakeFs {
       this.flushed.add(r10.path);
     }
   }
+  /**
+   * UPDATE-or-INSERT for a goal row, keyed by goal_id. One row per
+   * goal forever — status changes, owner reassignments, and text
+   * edits all mutate the same row in place. The version column
+   * stays at 1 (vestigial in the schema; kept so the column is
+   * already there if we ever bring back the audit-trail pattern).
+   *
+   * Trade-off versus the prior INSERT-only-version-bump design:
+   *   - Pros: 1 row per goal makes the Deeplake table view obvious,
+   *     no row proliferation, simpler bootstrap queries.
+   *   - Cons: no audit trail; vulnerable to Deeplake's
+   *     UPDATE-coalescing quirk if two writes hit the same row
+   *     within microseconds. For the v1 single-user / small-team
+   *     workflow the user explicitly chose this trade-off.
+   */
+  async upsertGoalRow(r10) {
+    if (!this.goalsTable)
+      throw new Error("goalsTable not configured");
+    const parts = decomposeGoalPath(r10.path);
+    const safe = this.goalsTable;
+    const ts3 = r10.lastUpdateDate ?? r10.creationDate ?? (/* @__PURE__ */ new Date()).toISOString();
+    const existing = await this.client.query(`SELECT id FROM "${safe}" WHERE goal_id = '${sqlStr(parts.goal_id)}' LIMIT 1`);
+    if (existing.length > 0) {
+      await this.client.query(`UPDATE "${safe}" SET owner = '${sqlStr(parts.owner)}', status = '${sqlStr(parts.status)}', content = E'${sqlStr(r10.contentText)}', created_at = '${sqlStr(ts3)}' WHERE goal_id = '${sqlStr(parts.goal_id)}'`);
+    } else {
+      const id = randomUUID2();
+      await this.client.query(`INSERT INTO "${safe}" (id, goal_id, owner, status, content, version, created_at, agent, plugin_version) VALUES ('${id}', '${sqlStr(parts.goal_id)}', '${sqlStr(parts.owner)}', '${sqlStr(parts.status)}', E'${sqlStr(r10.contentText)}', 1, '${sqlStr(ts3)}', 'manual', '')`);
+    }
+    this.flushed.add(r10.path);
+  }
+  /**
+   * UPDATE-or-INSERT for a KPI row, keyed by (goal_id, kpi_id).
+   * Same trade-off as upsertGoalRow — one row per KPI forever,
+   * no version proliferation. Progress bumps (Edit on the `current:`
+   * line) and any other content edits mutate the same row in place.
+   */
+  async upsertKpiRow(r10) {
+    if (!this.kpisTable)
+      throw new Error("kpisTable not configured");
+    const parts = decomposeKpiPath(r10.path);
+    const safe = this.kpisTable;
+    const ts3 = r10.lastUpdateDate ?? r10.creationDate ?? (/* @__PURE__ */ new Date()).toISOString();
+    const existing = await this.client.query(`SELECT id FROM "${safe}" WHERE goal_id = '${sqlStr(parts.goal_id)}' AND kpi_id = '${sqlStr(parts.kpi_id)}' LIMIT 1`);
+    if (existing.length > 0) {
+      await this.client.query(`UPDATE "${safe}" SET content = E'${sqlStr(r10.contentText)}', created_at = '${sqlStr(ts3)}' WHERE goal_id = '${sqlStr(parts.goal_id)}' AND kpi_id = '${sqlStr(parts.kpi_id)}'`);
+    } else {
+      const id = randomUUID2();
+      await this.client.query(`INSERT INTO "${safe}" (id, goal_id, kpi_id, content, version, created_at, agent, plugin_version) VALUES ('${id}', '${sqlStr(parts.goal_id)}', '${sqlStr(parts.kpi_id)}', E'${sqlStr(r10.contentText)}', 1, '${sqlStr(ts3)}', 'manual', '')`);
+    }
+    this.flushed.add(r10.path);
+  }
   // ── Virtual index.md generation ────────────────────────────────────────────
   async generateVirtualIndex() {
     const fetchLimit = INDEX_LIMIT_PER_SECTION + 1;
@@ -68813,6 +69708,11 @@ var DeeplakeFs = class _DeeplakeFs {
   }
   async readFile(path2, _opts) {
     const p22 = normPath(path2);
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        throw fsErr("EISDIR", "illegal operation on a directory", p22);
+      return readGraphFile(p22, process.cwd());
+    }
     if (this.dirs.has(p22) && !this.files.has(p22))
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     if (p22 === "/index.md" && !this.files.has(p22)) {
@@ -68860,13 +69760,13 @@ var DeeplakeFs = class _DeeplakeFs {
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     const text = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
     const buf = Buffer.from(text, "utf-8");
-    const mime = guessMime(basename4(p22));
+    const mime = guessMime(basename5(p22));
     this.files.set(p22, buf);
     this.meta.set(p22, { size: buf.length, mime, mtime: /* @__PURE__ */ new Date() });
     this.addToTree(p22);
     this.pending.set(p22, {
       path: p22,
-      filename: basename4(p22),
+      filename: basename5(p22),
       contentText: text,
       mimeType: mime,
       sizeBytes: buf.length,
@@ -68885,13 +69785,13 @@ var DeeplakeFs = class _DeeplakeFs {
       throw fsErr("EISDIR", "illegal operation on a directory", p22);
     const text = typeof content === "string" ? content : Buffer.from(content).toString("utf-8");
     const buf = Buffer.from(text, "utf-8");
-    const mime = guessMime(basename4(p22));
+    const mime = guessMime(basename5(p22));
     this.files.set(p22, buf);
     this.meta.set(p22, { size: buf.length, mime, mtime: /* @__PURE__ */ new Date() });
     this.addToTree(p22);
     this.pending.set(p22, {
       path: p22,
-      filename: basename4(p22),
+      filename: basename5(p22),
       contentText: text,
       mimeType: mime,
       sizeBytes: buf.length
@@ -68925,10 +69825,33 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     if (p22 === "/index.md")
       return true;
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        return true;
+      const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+      return r10.kind === "ok" || r10.kind === "no-graph";
+    }
     return this.files.has(p22) || this.dirs.has(p22);
   }
   async stat(path2) {
     const p22 = normPath(path2);
+    if (isGraphPath(p22)) {
+      if (!isGraphDir(p22)) {
+        const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+        if (r10.kind === "not-found")
+          throw fsErr("ENOENT", "no such file or directory", p22);
+      }
+      const dir = isGraphDir(p22);
+      return {
+        isFile: !dir,
+        isDirectory: dir,
+        isSymbolicLink: false,
+        mode: dir ? 493 : 420,
+        size: 0,
+        // synthesized; cheaper than computing the body just to size it
+        mtime: /* @__PURE__ */ new Date()
+      };
+    }
     const isFile = this.files.has(p22);
     const isDir = this.dirs.has(p22);
     if (p22 === "/index.md" && !isFile && !isDir) {
@@ -68973,6 +69896,14 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     if (p22 === "/index.md")
       return p22;
+    if (isGraphPath(p22)) {
+      if (isGraphDir(p22))
+        return p22;
+      const r10 = handleGraphVfs(graphSubpathOf(p22), process.cwd());
+      if (r10.kind === "ok" || r10.kind === "no-graph")
+        return p22;
+      throw fsErr("ENOENT", "no such file or directory", p22);
+    }
     if (!this.files.has(p22) && !this.dirs.has(p22))
       throw fsErr("ENOENT", "no such file or directory", p22);
     return p22;
@@ -68996,16 +69927,24 @@ var DeeplakeFs = class _DeeplakeFs {
     const parent = parentOf(p22);
     if (!this.dirs.has(parent))
       this.dirs.set(parent, /* @__PURE__ */ new Set());
-    this.dirs.get(parent).add(basename4(p22));
+    this.dirs.get(parent).add(basename5(p22));
   }
   async readdir(path2) {
     const p22 = normPath(path2);
+    if (p22 === GRAPH_ROOT)
+      return ["index.md", "find", "show"];
+    if (p22 === "/graph/find" || p22 === "/graph/show") {
+      return [];
+    }
     if (!this.dirs.has(p22))
       throw fsErr("ENOTDIR", "not a directory", p22);
     const entries = [...this.dirs.get(p22) ?? []];
     if (p22 === "/" && !entries.includes("index.md")) {
       entries.push("index.md");
     }
+    if (p22 === "/" && !entries.includes("graph")) {
+      entries.push("graph");
+    }
     return entries;
   }
   async readdirWithFileTypes(path2) {
@@ -69013,6 +69952,14 @@ var DeeplakeFs = class _DeeplakeFs {
     const p22 = normPath(path2);
     return names.map((name) => {
       const child = p22 === "/" ? `/${name}` : `${p22}/${name}`;
+      if (isGraphPath(child)) {
+        return {
+          name,
+          isFile: !isGraphDir(child),
+          isDirectory: isGraphDir(child),
+          isSymbolicLink: false
+        };
+      }
       return {
         name,
         isFile: (this.files.has(child) || child === "/index.md") && !this.dirs.has(child),
@@ -69031,6 +69978,31 @@ var DeeplakeFs = class _DeeplakeFs {
         return;
       throw fsErr("ENOENT", "no such file or directory", p22);
     }
+    if (this.goalsTable && classifyPath(p22) === "goal") {
+      const parts = decomposeGoalPath(p22);
+      if (parts.status === "closed") {
+        this.removeFromTree(p22);
+        return;
+      }
+      const closedPath = composeGoalPath({ ...parts, status: "closed" });
+      const contentBuf = this.files.get(p22);
+      const content = contentBuf instanceof Buffer ? contentBuf.toString("utf-8") : "";
+      await this.upsertGoalRow({
+        path: closedPath,
+        filename: basename5(closedPath),
+        contentText: content,
+        mimeType: "text/markdown",
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        creationDate: void 0,
+        lastUpdateDate: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.files.set(closedPath, contentBuf ?? null);
+      this.meta.set(closedPath, this.meta.get(p22) ?? { size: 0, mime: "text/markdown", mtime: /* @__PURE__ */ new Date() });
+      this.addToTree(closedPath);
+      this.flushed.add(closedPath);
+      this.removeFromTree(p22);
+      return;
+    }
     if (this.dirs.has(p22)) {
       const children = this.dirs.get(p22) ?? /* @__PURE__ */ new Set();
       if (children.size > 0 && !opts?.recursive)
@@ -69051,7 +70023,7 @@ var DeeplakeFs = class _DeeplakeFs {
       for (const fp of safeToDelete)
         this.removeFromTree(fp);
       this.dirs.delete(p22);
-      this.dirs.get(parentOf(p22))?.delete(basename4(p22));
+      this.dirs.get(parentOf(p22))?.delete(basename5(p22));
       if (safeToDelete.length > 0) {
         const inList = safeToDelete.map((fp) => `'${sqlStr(fp)}'`).join(", ");
         await this.client.query(`DELETE FROM "${this.table}" WHERE path IN (${inList})`);
@@ -69081,6 +70053,32 @@ var DeeplakeFs = class _DeeplakeFs {
       throw fsErr("EPERM", "session files are read-only", s10);
     if (this.sessionPaths.has(d15))
       throw fsErr("EPERM", "session files are read-only", d15);
+    if (this.goalsTable && classifyPath(s10) === "goal" && classifyPath(d15) === "goal") {
+      const from = decomposeGoalPath(s10);
+      const to3 = decomposeGoalPath(d15);
+      if (from.goal_id !== to3.goal_id || from.owner !== to3.owner) {
+        throw fsErr("EPERM", "cannot rename goal_id or owner via mv (only status)", d15);
+      }
+      if (!this.files.has(s10))
+        throw fsErr("ENOENT", "no such file or directory", s10);
+      const contentBuf = this.files.get(s10);
+      const content = contentBuf instanceof Buffer ? contentBuf.toString("utf-8") : "";
+      await this.upsertGoalRow({
+        path: d15,
+        filename: basename5(d15),
+        contentText: content,
+        mimeType: "text/markdown",
+        sizeBytes: Buffer.byteLength(content, "utf-8"),
+        creationDate: void 0,
+        lastUpdateDate: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.files.set(d15, contentBuf ?? null);
+      this.meta.set(d15, this.meta.get(s10) ?? { size: 0, mime: "text/markdown", mtime: /* @__PURE__ */ new Date() });
+      this.addToTree(d15);
+      this.flushed.add(d15);
+      this.removeFromTree(s10);
+      return;
+    }
     await this.cp(src, dest, { recursive: true });
     await this.rm(src, { recursive: true, force: true });
   }
@@ -69096,7 +70094,7 @@ var DeeplakeFs = class _DeeplakeFs {
 
 // node_modules/yargs-parser/build/lib/index.js
 import { format } from "util";
-import { normalize, resolve as resolve5 } from "path";
+import { normalize, resolve as resolve6 } from "path";
 
 // node_modules/yargs-parser/build/lib/string-utils.js
 function camelCase2(str) {
@@ -70034,7 +71032,7 @@ function stripQuotes(val) {
 }
 
 // node_modules/yargs-parser/build/lib/index.js
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { createRequire as createRequire2 } from "node:module";
 var _a3;
 var _b;
@@ -70056,12 +71054,12 @@ var parser = new YargsParser({
   },
   format,
   normalize,
-  resolve: resolve5,
+  resolve: resolve6,
   require: (path2) => {
     if (typeof require2 !== "undefined") {
       return require2(path2);
     } else if (path2.match(/\.json$/)) {
-      return JSON.parse(readFileSync7(path2, "utf8"));
+      return JSON.parse(readFileSync10(path2, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -70081,11 +71079,11 @@ var lib_default = yargsParser;
 
 // dist/src/shell/grep-interceptor.js
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname6, join as join13 } from "node:path";
+import { dirname as dirname10, join as join17 } from "node:path";
 var SEMANTIC_SEARCH_ENABLED = process.env.HIVEMIND_SEMANTIC_SEARCH !== "false" && !embeddingsDisabled();
 var SEMANTIC_EMBED_TIMEOUT_MS = Number(process.env.HIVEMIND_SEMANTIC_EMBED_TIMEOUT_MS ?? "500");
 function resolveGrepEmbedDaemonPath() {
-  return join13(dirname6(fileURLToPath2(import.meta.url)), "..", "embeddings", "embed-daemon.js");
+  return join17(dirname10(fileURLToPath2(import.meta.url)), "..", "embeddings", "embed-daemon.js");
 }
 var sharedGrepEmbedClient = null;
 function getGrepEmbedClient() {
@@ -70235,13 +71233,15 @@ async function main() {
   }
   const table = process.env["HIVEMIND_TABLE"] ?? "memory";
   const sessionsTable = process.env["HIVEMIND_SESSIONS_TABLE"] ?? "sessions";
+  const goalsTable = process.env["HIVEMIND_GOALS_TABLE"] ?? config.goalsTableName;
+  const kpisTable = process.env["HIVEMIND_KPIS_TABLE"] ?? config.kpisTableName;
   const mount = process.env["HIVEMIND_MOUNT"] ?? "/";
   const client = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, table);
   if (!isOneShot) {
     process.stderr.write(`Connecting to deeplake://${config.workspaceId}/${table} ...
 `);
   }
-  const fs3 = await DeeplakeFs.create(client, table, mount, sessionsTable);
+  const fs3 = await DeeplakeFs.create(client, table, mount, sessionsTable, { goalsTable, kpisTable });
   if (!isOneShot) {
     const fileCount = fs3.getAllPaths().filter((p22) => !!p22).length;
     process.stderr.write(`Ready. ${fileCount} files loaded.