@deeplake/hivemind 0.7.45 → 0.7.47

package/cursor/bundle/session-start.js

@@ -121,6 +121,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 ?? join3(home, ".deeplake", "memory")
   };
 }
@@ -209,6 +226,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) {
@@ -226,9 +302,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(", ");
@@ -775,6 +880,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();
@@ -788,8 +911,467 @@ 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/rules/write.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// dist/src/rules/read.js
+var SELECT_COLS = "id, rule_id, text, scope, status, assigned_by, version, created_at, agent, plugin_version";
+async function listRules(query, tableName, opts = {}) {
+  const safe = sqlIdent(tableName);
+  const rows = await query(`SELECT ${SELECT_COLS} FROM "${safe}" ORDER BY version DESC, created_at DESC, id DESC`);
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = normalize(r);
+    if (!row)
+      continue;
+    if (!latest.has(row.rule_id))
+      latest.set(row.rule_id, row);
+  }
+  const statusFilter = opts.status ?? "active";
+  const filtered = [...latest.values()].filter((r) => statusFilter === "all" ? true : r.status === statusFilter);
+  filtered.sort((a, b) => b.created_at.localeCompare(a.created_at) || b.id.localeCompare(a.id));
+  return filtered.slice(0, opts.limit ?? 10);
+}
+function normalize(row) {
+  const vRaw = row.version;
+  const version = typeof vRaw === "number" ? vRaw : typeof vRaw === "string" ? Number(vRaw) : NaN;
+  if (!Number.isFinite(version))
+    return null;
+  return {
+    id: String(row.id ?? ""),
+    rule_id: String(row.rule_id ?? ""),
+    text: String(row.text ?? ""),
+    scope: String(row.scope ?? ""),
+    status: String(row.status ?? ""),
+    assigned_by: String(row.assigned_by ?? ""),
+    version,
+    created_at: String(row.created_at ?? ""),
+    agent: String(row.agent ?? ""),
+    plugin_version: String(row.plugin_version ?? "")
+  };
+}
+
+// dist/src/tasks/write.js
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// dist/src/tasks/kpi-validator.js
+function parseKpis(raw) {
+  if (raw == null || raw === "")
+    return [];
+  let arr;
+  if (typeof raw === "string") {
+    try {
+      arr = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  } else {
+    arr = raw;
+  }
+  if (!Array.isArray(arr))
+    return [];
+  const out = [];
+  for (const item of arr) {
+    const kpi = validateOne(item);
+    if (kpi)
+      out.push(kpi);
+  }
+  return out;
+}
+function validateOne(item) {
+  if (!isObject(item))
+    return null;
+  const kpi_id = safeStr(item.kpi_id);
+  const name = safeStr(item.name);
+  const target = num(item.target);
+  const unit = safeStr(item.unit);
+  const generated_by = safeStr(item.generated_by);
+  const generated_at = isoStr(item.generated_at);
+  if (kpi_id === null || name === null || target === null || unit === null || generated_by === null || generated_at === null) {
+    return null;
+  }
+  if (!Number.isInteger(target) || target <= 0) {
+    return null;
+  }
+  const out = {
+    kpi_id,
+    name,
+    target,
+    unit,
+    generated_by,
+    generated_at
+  };
+  const current = num(item.current);
+  if (current !== null)
+    out.current = current;
+  return out;
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str(v) {
+  if (typeof v !== "string" || v.length === 0)
+    return null;
+  return v;
+}
+function safeStr(v) {
+  const s = str(v);
+  if (s === null)
+    return null;
+  if (/[\r\n\u2028\u2029\u0085]/.test(s))
+    return null;
+  return s;
+}
+function num(v) {
+  if (typeof v !== "number" || !Number.isFinite(v))
+    return null;
+  return v;
+}
+function isoStr(v) {
+  const s = safeStr(v);
+  if (s === null)
+    return null;
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})?$/.test(s)) {
+    return null;
+  }
+  return s;
+}
+
+// dist/src/tasks/read.js
+var SELECT_COLS2 = "id, task_id, text, scope, status, assigned_to, assigned_by, kpis, version, created_at, agent, plugin_version";
+async function listTasks(query, tableName, opts = {}) {
+  const safe = sqlIdent(tableName);
+  const rows = await query(`SELECT ${SELECT_COLS2} FROM "${safe}" ORDER BY version DESC, created_at DESC, id DESC`);
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const row = normalize2(r);
+    if (!row)
+      continue;
+    if (!latest.has(row.task_id))
+      latest.set(row.task_id, row);
+  }
+  const scope = opts.scope ?? "all";
+  const status = opts.status ?? "active";
+  const current = opts.current_user;
+  const filtered = [...latest.values()].filter((row) => {
+    if (status !== "all" && row.status !== status)
+      return false;
+    if (scope === "mine") {
+      if (!current)
+        return false;
+      return row.assigned_to === current;
+    }
+    if (scope === "me") {
+      if (!current)
+        return false;
+      return row.scope === "me" && row.assigned_to === current;
+    }
+    if (scope === "team")
+      return row.scope === "team";
+    return true;
+  });
+  filtered.sort((a, b) => b.created_at.localeCompare(a.created_at) || b.id.localeCompare(a.id));
+  return filtered.slice(0, opts.limit ?? 10);
+}
+function normalize2(row) {
+  const vRaw = row.version;
+  const version = typeof vRaw === "number" ? vRaw : typeof vRaw === "string" ? Number(vRaw) : NaN;
+  if (!Number.isFinite(version))
+    return null;
+  return {
+    id: String(row.id ?? ""),
+    task_id: String(row.task_id ?? ""),
+    text: String(row.text ?? ""),
+    scope: String(row.scope ?? ""),
+    status: String(row.status ?? ""),
+    assigned_to: String(row.assigned_to ?? ""),
+    assigned_by: String(row.assigned_by ?? ""),
+    kpis: parseKpis(row.kpis),
+    version,
+    created_at: String(row.created_at ?? ""),
+    agent: String(row.agent ?? ""),
+    plugin_version: String(row.plugin_version ?? "")
+  };
+}
+
+// dist/src/events/append.js
+import { randomUUID as randomUUID5 } from "node:crypto";
+
+// dist/src/events/aggregate.js
+async function computeAllForTasks(query, tableName, taskIds) {
+  if (taskIds.length === 0)
+    return {};
+  const safe = sqlIdent(tableName);
+  const inList = taskIds.map((id) => `'${sqlStr(id)}'`).join(", ");
+  const rows = await query(`SELECT task_id, kpi_id, SUM(value) AS total FROM "${safe}" WHERE task_id IN (${inList}) GROUP BY task_id, kpi_id`);
+  const out = {};
+  for (const row of rows) {
+    const tid = typeof row.task_id === "string" ? row.task_id : "";
+    const kid = typeof row.kpi_id === "string" ? row.kpi_id : "";
+    if (!tid || !kid)
+      continue;
+    if (!out[tid])
+      out[tid] = {};
+    out[tid][kid] = normalizeTotal(row.total);
+  }
+  return out;
+}
+function normalizeTotal(raw) {
+  if (raw == null)
+    return 0;
+  if (typeof raw === "number")
+    return Number.isFinite(raw) ? raw : 0;
+  if (typeof raw === "string") {
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return 0;
+}
+
+// dist/src/hooks/shared/context-renderer.js
+async function renderContextBlock(query, input, opts = {}) {
+  const maxRules = opts.maxRules ?? 10;
+  const maxTasks = opts.maxTasks ?? 10;
+  const log7 = opts.log ?? (() => {
+  });
+  try {
+    let rules = [];
+    try {
+      rules = await listRules(query, input.rulesTable, {
+        status: "active",
+        limit: Math.max(maxRules * 4, maxRules + 1)
+      });
+    } catch (rulesErr) {
+      const rmsg = rulesErr instanceof Error ? rulesErr.message : String(rulesErr);
+      log7(`render-context-block: rules unavailable (continuing): ${rmsg}`);
+    }
+    let teamTasks = [];
+    let myTasks = [];
+    try {
+      teamTasks = await listTasks(query, input.tasksTable, {
+        scope: "team",
+        status: "active",
+        limit: Math.max(maxTasks * 4, maxTasks + 1)
+      });
+      myTasks = await listTasks(query, input.tasksTable, {
+        scope: "me",
+        status: "active",
+        current_user: input.currentUser,
+        limit: Math.max(maxTasks * 4, maxTasks + 1)
+      });
+    } catch (tasksErr) {
+      const tmsg = tasksErr instanceof Error ? tasksErr.message : String(tasksErr);
+      log7(`render-context-block: tasks unavailable (continuing): ${tmsg}`);
+    }
+    const visibleTasks = mergeAndDedupTasks(teamTasks, myTasks);
+    const rulesShown = rules.slice(0, maxRules);
+    const rulesHidden = Math.max(0, rules.length - maxRules);
+    const tasksShown = visibleTasks.slice(0, maxTasks);
+    const tasksHidden = Math.max(0, visibleTasks.length - maxTasks);
+    const taskIds = tasksShown.map((t) => t.task_id);
+    let totals = {};
+    try {
+      totals = await computeAllForTasks(query, input.taskEventsTable, taskIds);
+    } catch (aggErr) {
+      const aggMsg = aggErr instanceof Error ? aggErr.message : String(aggErr);
+      log7(`render-context-block: aggregate failed (continuing with 0/target): ${aggMsg}`);
+    }
+    return formatBlock({
+      rules: rulesShown,
+      rulesHidden,
+      tasks: tasksShown,
+      tasksHidden,
+      totals,
+      currentUser: input.currentUser
+    });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    log7(`render-context-block: ${msg}`);
+    return "";
+  }
+}
+function mergeAndDedupTasks(teamTasks, myTasks) {
+  const winner = /* @__PURE__ */ new Map();
+  for (const t of [...teamTasks, ...myTasks]) {
+    const prev = winner.get(t.task_id);
+    if (!prev) {
+      winner.set(t.task_id, t);
+      continue;
+    }
+    if (t.version > prev.version) {
+      winner.set(t.task_id, t);
+    } else if (t.version === prev.version && t.created_at > prev.created_at) {
+      winner.set(t.task_id, t);
+    }
+  }
+  const merged = [...winner.values()];
+  merged.sort((a, b) => {
+    const aMe = a.scope === "me" ? 0 : 1;
+    const bMe = b.scope === "me" ? 0 : 1;
+    if (aMe !== bMe)
+      return aMe - bMe;
+    return b.created_at.localeCompare(a.created_at);
+  });
+  return merged;
+}
+function formatBlock(input) {
+  if (input.rules.length === 0 && input.tasks.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (input.rules.length > 0) {
+    lines.push(`=== HIVEMIND RULES (${input.rules.length} active) ===`);
+    for (const r of input.rules) {
+      lines.push(`- ${r.rule_id}: ${sanitizeForInject(r.text)}`);
+    }
+    if (input.rulesHidden > 0) {
+      lines.push(`(${input.rulesHidden} more \u2014 run 'hivemind rules list' to see all)`);
+    }
+    lines.push("");
+  }
+  if (input.tasks.length > 0) {
+    lines.push(`=== HIVEMIND TASKS (${input.tasks.length} active) ===`);
+    for (const t of input.tasks) {
+      lines.push(formatTaskLine(t, input.totals[t.task_id] ?? {}, input.currentUser));
+    }
+    if (input.tasksHidden > 0) {
+      lines.push(`(${input.tasksHidden} more \u2014 run 'hivemind tasks list' to see all)`);
+    }
+    lines.push("");
+  }
+  lines.push("=== HIVEMIND HOW-TO ===");
+  lines.push("- Rules above are team principles. Treat any action that would violate one as a critical error and surface it to the user before proceeding.");
+  lines.push("- Tasks above are your current work. Use 'hivemind tasks progress <task-id> <kpi-id> --value N' to record progress on a KPI.");
+  lines.push("- Run 'hivemind rules list' / 'hivemind tasks list' for the full inventories beyond what's shown here.");
+  return lines.join("\n");
+}
+function formatTaskLine(task, kpiTotals, currentUser) {
+  const tag = task.scope === "team" ? "[team]" : "[me]";
+  const highlight = task.scope === "team" && task.assigned_to === currentUser ? " \u2605YOU" : "";
+  const kpiSummary = formatKpiSummary(task.kpis, kpiTotals);
+  return `${tag} ${task.task_id}: ${sanitizeForInject(task.text)}${highlight}${kpiSummary}`;
+}
+function sanitizeForInject(text) {
+  return text.replace(LINE_TERMINATOR_RE, "\\n");
+}
+var LINE_TERMINATOR_RE = /\r\n?|[\n\u2028\u2029\u0085]/g;
+function formatKpiSummary(kpis, totals) {
+  if (kpis.length === 0)
+    return "";
+  const parts = kpis.map((k) => {
+    const current = totals[k.kpi_id] ?? 0;
+    return `${sanitizeForInject(k.name)}: ${current}/${k.target} ${sanitizeForInject(k.unit)}`;
+  });
+  return ` | ${parts.join(", ")}`;
+}
+
 // dist/src/cli/skillify-spec.js
 var SKILLIFY_COMMANDS = [
   { cmd: "hivemind skillify", desc: "show scope, team, install, per-project state" },
@@ -1723,6 +2305,61 @@ async function autoPullSkills(deps = {}) {
   }
 }
 
+// dist/src/hooks/shared/goals-instructions.js
+var GOALS_INSTRUCTIONS_CLI = `HIVEMIND GOALS \u2014 track team goals via the \`hivemind\` CLI on this runtime. Your Write/Edit tools do NOT route to the team-shared tables here, so use these shell commands instead. All commands persist to the org-shared \`hivemind_goals\` / \`hivemind_kpis\` tables \u2014 other team members see your goals at SessionStart.
+
+Commands (invoke via your Shell / terminal / Bash tool):
+
+  hivemind goal add "<text>"
+      Create a new goal (status=opened, assigned to you). Prints goal_id on stdout.
+
+  hivemind goal list [--all|--mine]
+      List goals. Default: --mine. Columns are tab-separated: goal_id, owner, status, first-line-of-text.
+
+  hivemind goal done <goal_id>
+      Mark a goal closed.
+
+  hivemind goal progress <goal_id> <opened|in_progress|closed>
+      Flip a goal to any status.
+
+  hivemind kpi add <goal_id> <kpi_id> <target> <unit> [name...]
+      Add a KPI to an existing goal. <kpi_id> = short slug (e.g. k-prs).
+      <target> = positive integer. [name] defaults to the kpi_id.
+
+  hivemind kpi list <goal_id>
+      Tab-separated list of (kpi_id, first-line-of-content).
+
+  hivemind kpi bump <goal_id> <kpi_id> <delta>
+      Increment (positive int) or decrement (negative) the current value of one KPI.
+
+Workflow when the user expresses a goal:
+  1. \`hivemind goal add "<short description>"\` \u2014 capture stdout as goal_id.
+  2. ONLY if the user explicitly asks for KPIs: \`hivemind kpi add <goal_id> <slug> <target> <unit>\` per KPI.
+  3. Tell the user the goal_id and that it is now visible to the team.
+
+Do NOT use Write/Edit on \`~/.deeplake/memory/goal/...\` here \u2014 on this runtime those tool calls write to the host filesystem only, not the shared table.`;
+
+// dist/src/graph/spawn-pull-worker.js
+import { spawn as spawn3 } from "node:child_process";
+import { join as join17 } from "node:path";
+function spawnGraphPullWorker(cwd, bundleDir, deps = {}) {
+  if (process.env.HIVEMIND_GRAPH_PULL === "0")
+    return;
+  const workerPath = join17(bundleDir, "graph-pull-worker.js");
+  const opts = {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"]
+  };
+  try {
+    const sp = deps.spawn ?? spawn3;
+    const child = sp("nohup", ["node", workerPath, "--cwd", cwd], opts);
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
 // dist/src/hooks/cursor/session-start.js
 var log6 = (msg) => log("cursor-session-start", msg);
 var __bundleDir = dirname7(fileURLToPath2(import.meta.url));
@@ -1800,17 +2437,28 @@ async function main() {
   const current = getInstalledVersion(__bundleDir, ".claude-plugin");
   const pluginVersion = current ?? "";
   const captureEnabled = process.env.HIVEMIND_CAPTURE !== "false";
-  if (creds?.token && captureEnabled) {
+  let rulesTasksBlock = "";
+  if (creds?.token) {
     try {
       const config = loadConfig();
       if (config) {
         const table = config.tableName;
         const sessionsTable = config.sessionsTableName;
         const api = new DeeplakeApi(config.token, config.apiUrl, config.orgId, config.workspaceId, table);
-        await api.ensureTable();
-        await api.ensureSessionsTable(sessionsTable);
-        await createPlaceholder(api, table, sessionId, cwd, config.userName, config.orgName, config.workspaceId, pluginVersion);
-        log6("placeholder created");
+        if (captureEnabled) {
+          await api.ensureTable();
+          await api.ensureSessionsTable(sessionsTable);
+          await createPlaceholder(api, table, sessionId, cwd, config.userName, config.orgName, config.workspaceId, pluginVersion);
+          log6("placeholder created");
+        } else {
+          log6("placeholder + schema ensure skipped (HIVEMIND_CAPTURE=false)");
+        }
+        rulesTasksBlock = await renderContextBlock((sql) => api.query(sql), {
+          rulesTable: config.rulesTableName,
+          tasksTable: config.tasksTableName,
+          taskEventsTable: config.taskEventsTableName,
+          currentUser: config.userName
+        }, { log: log6 });
       }
     } catch (e) {
       log6(`placeholder failed: ${e.message}`);
@@ -1825,9 +2473,17 @@ Hivemind v${current}`;
   const localMined = countLocalManifestEntries();
   const localMinedNote = localMined > 0 ? `
 ${localMined} local skill${localMined === 1 ? "" : "s"} from past 'hivemind skillify mine-local' run(s) live in ~/.claude/skills/. Run 'hivemind login' to start sharing new mining results with your team.` : "";
-  const additionalContext = creds?.token ? `${context}
+  if (creds?.token)
+    spawnGraphPullWorker(resolveCwd(input), __bundleDir);
+  const baseContext = creds?.token ? `${context}
 Logged in to Deeplake as org: ${creds.orgName ?? creds.orgId} (workspace: ${creds.workspaceId ?? "default"})${versionNotice}` : `${context}
 Not logged in to Deeplake. Run: hivemind login${localMinedNote}${versionNotice}`;
+  const baseWithGoals = creds?.token ? `${baseContext}
+
+${GOALS_INSTRUCTIONS_CLI}` : baseContext;
+  const additionalContext = rulesTasksBlock ? `${baseWithGoals}
+
+${rulesTasksBlock}` : baseWithGoals;
   console.log(JSON.stringify({ additional_context: additionalContext }));
 }
 main().catch((e) => {