@deeplake/hivemind 0.7.45 → 0.7.47

package/openclaw/dist/index.js

@@ -200,6 +200,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) {
@@ -219,9 +278,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((c) => `${c.name} ${c.sql}`).join(", ");
@@ -757,6 +845,27 @@ 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();
@@ -769,6 +878,106 @@ 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")`);
+  }
 };
 
 // src/shell/grep-core.ts
@@ -1528,7 +1737,7 @@ function loadCredsModule() {
   return credsModulePromise;
 }
 function loadConfigModule() {
-  if (!configModulePromise) configModulePromise = import("./chunks/config-XEK4MJJS.js");
+  if (!configModulePromise) configModulePromise = import("./chunks/config-FH6JYSJW.js");
   return configModulePromise;
 }
 async function loadCredentials2() {
@@ -1584,7 +1793,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.45".length > 0 ? "0.7.45" : null;
+  return "0.7.47".length > 0 ? "0.7.47" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);
@@ -1684,6 +1893,8 @@ var api = null;
 var sessionsTable = "sessions";
 var memoryTable = "memory";
 var skillsTable = "skills";
+var goalsTable = "hivemind_goals";
+var kpisTable = "hivemind_kpis";
 var captureEnabled = true;
 var capturedCounts = /* @__PURE__ */ new Map();
 var fallbackSessionId = crypto.randomUUID();
@@ -1873,6 +2084,8 @@ async function getApi() {
   sessionsTable = config.sessionsTableName;
   memoryTable = config.tableName;
   skillsTable = config.skillsTableName;
+  goalsTable = config.goalsTableName;
+  kpisTable = config.kpisTableName;
   const candidate = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, config.tableName);
   await candidate.ensureTable();
   await candidate.ensureSessionsTable(sessionsTable);
@@ -2228,6 +2441,98 @@ ${body.slice(0, 500)}`;
             }
           }
         });
+        pluginApi.registerTool({
+          name: "hivemind_goal_add",
+          label: "Hivemind Goal Add",
+          description: "Create a new Hivemind team goal. Persists to the org-shared hivemind_goals table \u2014 teammates see it on next SessionStart. Returns the generated goal_id. Use when the user wants to track a measurable objective or milestone.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              text: {
+                type: "string",
+                minLength: 1,
+                description: "One-line goal description (e.g. 'ship the goals feature by Friday')."
+              }
+            },
+            required: ["text"]
+          },
+          execute: async (_toolCallId, rawParams) => {
+            const params = rawParams;
+            const dl = await getApi();
+            if (!dl) {
+              return { content: [{ type: "text", text: "Not logged in. Run /hivemind_login first." }] };
+            }
+            try {
+              const config2 = await loadConfig();
+              const owner = config2?.userName ?? "unknown";
+              await dl.ensureGoalsTable(goalsTable);
+              const goalId = crypto.randomUUID();
+              const ts = (/* @__PURE__ */ new Date()).toISOString();
+              const safe = goalsTable.replace(/[^A-Za-z0-9_]/g, "");
+              await dl.query(
+                `INSERT INTO "${safe}" (id, goal_id, owner, status, content, version, created_at, agent, plugin_version) VALUES ('${crypto.randomUUID()}', '${sqlStr(goalId)}', '${sqlStr(owner)}', 'opened', E'${sqlStr(params.text)}', 1, '${sqlStr(ts)}', 'openclaw', '')`
+              );
+              pluginApi.logger.info?.(`hivemind_goal_add \u2192 ${goalId}`);
+              return { content: [{ type: "text", text: `Goal created.
+goal_id: ${goalId}
+owner: ${owner}
+status: opened
+text: ${params.text}` }], details: { goal_id: goalId } };
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              pluginApi.logger.error(`hivemind_goal_add failed: ${msg}`);
+              return { content: [{ type: "text", text: `Goal add failed: ${msg}` }] };
+            }
+          }
+        });
+        pluginApi.registerTool({
+          name: "hivemind_kpi_add",
+          label: "Hivemind KPI Add",
+          description: "Add a measurable KPI to an existing Hivemind goal. Persists to the org-shared hivemind_kpis table. Only call after the user has explicitly asked for KPIs \u2014 do NOT auto-generate them.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              goal_id: { type: "string", minLength: 1, description: "Existing goal_id (UUID) returned by hivemind_goal_add." },
+              kpi_id: { type: "string", minLength: 1, description: "Short slug for this KPI (e.g. 'k-prs')." },
+              target: { type: "integer", minimum: 1, description: "Positive integer target." },
+              unit: { type: "string", minLength: 1, description: "Unit label (e.g. 'count', 'PRs', 'lines')." },
+              name: { type: "string", description: "Optional human-readable name. Defaults to kpi_id." }
+            },
+            required: ["goal_id", "kpi_id", "target", "unit"]
+          },
+          execute: async (_toolCallId, rawParams) => {
+            const params = rawParams;
+            const dl = await getApi();
+            if (!dl) {
+              return { content: [{ type: "text", text: "Not logged in. Run /hivemind_login first." }] };
+            }
+            try {
+              await dl.ensureKpisTable(kpisTable);
+              const name = params.name ?? params.kpi_id;
+              const content = `${name}
+
+- target: ${params.target}
+- current: 0
+- unit: ${params.unit}`;
+              const ts = (/* @__PURE__ */ new Date()).toISOString();
+              const safe = kpisTable.replace(/[^A-Za-z0-9_]/g, "");
+              await dl.query(
+                `INSERT INTO "${safe}" (id, goal_id, kpi_id, content, version, created_at, agent, plugin_version) VALUES ('${crypto.randomUUID()}', '${sqlStr(params.goal_id)}', '${sqlStr(params.kpi_id)}', E'${sqlStr(content)}', 1, '${sqlStr(ts)}', 'openclaw', '')`
+              );
+              pluginApi.logger.info?.(`hivemind_kpi_add \u2192 ${params.goal_id}/${params.kpi_id}`);
+              return { content: [{ type: "text", text: `KPI added.
+goal_id: ${params.goal_id}
+kpi_id: ${params.kpi_id}
+target: ${params.target} ${params.unit}` }] };
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              pluginApi.logger.error(`hivemind_kpi_add failed: ${msg}`);
+              return { content: [{ type: "text", text: `KPI add failed: ${msg}` }] };
+            }
+          }
+        });
         pluginApi.registerMemoryCorpusSupplement({
           search: async ({ query, maxResults }) => {
             const dl = await getApi();

package/openclaw/dist/skillify-worker.js

@@ -379,6 +379,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) {
@@ -396,9 +455,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((c) => `${c.name} ${c.sql}`).join(", ");
@@ -694,9 +782,12 @@ function resolveRecordScope(args) {
 
 // dist/src/skillify/state.js
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, writeSync, mkdirSync as mkdirSync2, renameSync as renameSync2, rmdirSync, existsSync as existsSync4, lstatSync, unlinkSync, openSync, closeSync } from "node:fs";
+import { join as join6 } from "node:path";
+
+// dist/src/utils/repo-identity.js
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { join as join6, basename } from "node:path";
+import { basename, resolve } from "node:path";
 
 // dist/src/skillify/legacy-migration.js
 import { existsSync as existsSync3, renameSync } from "node:fs";
@@ -882,7 +973,7 @@ async function query(sql, retries = 4) {
         const base = Math.min(3e4, 2e3 * Math.pow(2, attempt));
         const delay = base + Math.floor(Math.random() * 1e3);
         wlog(`fetch failed (${e?.name ?? e?.code ?? e?.message}), retrying in ${delay}ms (attempt ${attempt + 1}/${retries})`);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
         continue;
       }
       throw e;
@@ -898,7 +989,7 @@ async function query(sql, retries = 4) {
       const base = Math.min(3e4, 2e3 * Math.pow(2, attempt));
       const delay = base + Math.floor(Math.random() * 1e3);
       wlog(`API ${r.status}, retrying in ${delay}ms (attempt ${attempt + 1}/${retries})`);
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
       continue;
     }
     throw new Error(`API ${r.status}: ${(await r.text()).slice(0, 200)}`);

package/openclaw/openclaw.plugin.json

@@ -9,7 +9,9 @@
     "tools": [
       "hivemind_search",
       "hivemind_read",
-      "hivemind_index"
+      "hivemind_index",
+      "hivemind_goal_add",
+      "hivemind_kpi_add"
     ],
     "commands": [
       "hivemind_login",
@@ -52,5 +54,5 @@
       }
     }
   },
-  "version": "0.7.45"
+  "version": "0.7.47"
 }

package/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivemind",
-  "version": "0.7.45",
+  "version": "0.7.47",
   "type": "module",
   "description": "Hivemind — cloud-backed persistent shared memory for AI agents, powered by DeepLake",
   "license": "Apache-2.0",

package/openclaw/skills/hivemind-goals/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: hivemind-goals
+description: Create, track, and read team goals + KPIs via Hivemind from openclaw. Use whenever the user mentions a goal, objective, KPI, target, milestone, or asks to track progress on something measurable.
+allowed-tools: hivemind_search, hivemind_read, hivemind_index, hivemind_goal_add, hivemind_kpi_add
+---
+
+# Hivemind Goals (openclaw)
+
+OpenClaw exposes purpose-built tools for goals + KPIs. Use them directly — do NOT try to write files via the host filesystem.
+
+## Tools
+
+- `hivemind_goal_add({ text })` — create a new goal. Returns `goal_id` (UUID). Status starts at `opened`.
+- `hivemind_kpi_add({ goal_id, kpi_id, target, unit, name? })` — add a KPI to an existing goal. Only call when the user explicitly asks for KPIs; do NOT auto-generate.
+- `hivemind_search({ query })` — search Hivemind shared memory (summaries + sessions). Use this when the user asks "what's already there" before creating a duplicate.
+- `hivemind_read({ path })` — read the full content of a specific Hivemind path.
+- `hivemind_index({})` — list everything in memory.
+
+## Workflow when the user expresses a goal
+
+1. (Optional) `hivemind_search` first to surface any existing related goal.
+2. `hivemind_goal_add({ text: "<short description>" })` — capture the returned `goal_id`.
+3. ONLY if the user asks for KPIs: `hivemind_kpi_add` once per KPI with `goal_id` + `kpi_id` (short slug like `k-prs`) + `target` (positive int) + `unit`.
+4. Confirm to the user with the goal_id and that the goal is team-visible.
+
+## What NOT to do
+
+- Do NOT write files anywhere under `~/.deeplake/memory/`. OpenClaw's runtime does not route filesystem writes to the Deeplake tables — only the `hivemind_*` tools above do.
+- Do NOT call `hivemind_kpi_add` unsolicited. Wait for the user to ask.
+- Do NOT use `hivemind_search` to *create* anything — it's read-only.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.7.45",
+  "version": "0.7.47",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {
@@ -52,11 +52,14 @@
     "*.md": []
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.97.1",
     "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "deeplake": "^0.3.30",
     "js-yaml": "^4.1.1",
     "just-bash": "^2.14.0",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-typescript": "^0.23.2",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6"
   },

package/openclaw/dist/chunks/config-XEK4MJJS.js

@@ -1,36 +0,0 @@
-globalThis.__hivemind_tuning__ ??= {};
-
-// src/config.ts
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { homedir, userInfo } from "node:os";
-function loadConfig() {
-  const home = homedir();
-  const credPath = join(home, ".deeplake", "credentials.json");
-  let creds = null;
-  if (existsSync(credPath)) {
-    try {
-      creds = JSON.parse(readFileSync(credPath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  const token = creds?.token;
-  const orgId = creds?.orgId;
-  if (!token || !orgId) return null;
-  return {
-    token,
-    orgId,
-    orgName: creds?.orgName ?? orgId,
-    userName: creds?.userName || userInfo().username || "unknown",
-    workspaceId: creds?.workspaceId ?? "default",
-    apiUrl: creds?.apiUrl ?? "https://api.deeplake.ai",
-    tableName: "memory",
-    sessionsTableName: "sessions",
-    skillsTableName: process.env.HIVEMIND_SKILLS_TABLE ?? "skills",
-    memoryPath: join(home, ".deeplake", "memory")
-  };
-}
-export {
-  loadConfig
-};