@deeplake/hivemind 0.7.46 → 0.7.47

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

@@ -66792,6 +66792,22 @@ 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")
   };
@@ -66893,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) {
@@ -66936,6 +67011,11 @@ var CODEBASE_COLUMNS = Object.freeze([
 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);
@@ -67532,6 +67612,111 @@ 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
@@ -68544,6 +68729,82 @@ 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";
@@ -69061,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) {
@@ -69071,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`;
@@ -69120,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 ───────────────────────────────────────────────────────
@@ -69189,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);
@@ -69212,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;
@@ -69583,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)
@@ -69633,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 });
   }
@@ -70787,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.

package/cursor/bundle/skillify-worker.js

@@ -378,6 +378,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) {
@@ -421,6 +480,11 @@ var CODEBASE_COLUMNS = Object.freeze([
 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);