@deeplake/hivemind 0.7.16 → 0.7.18

package/openclaw/dist/{skilify-worker.js → skillify-worker.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-// dist/src/skilify/skilify-worker.js
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync4, appendFileSync as appendFileSync2, rmSync } from "node:fs";
-import { join as join5 } from "node:path";
+// dist/src/skillify/skillify-worker.js
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, appendFileSync as appendFileSync2, rmSync } from "node:fs";
+import { join as join6 } from "node:path";
 
 // dist/src/utils/debug.js
 import { appendFileSync } from "node:fs";
@@ -29,7 +29,7 @@ function deeplakeClientHeader() {
   return { [DEEPLAKE_CLIENT_HEADER]: deeplakeClientValue() };
 }
 
-// dist/src/skilify/extractors/index.js
+// dist/src/skillify/extractors/index.js
 function extractPairs(rows) {
   const pairs = [];
   let pendingPrompt = null;
@@ -60,7 +60,7 @@ function extractPairs(rows) {
   return pairs;
 }
 
-// dist/src/skilify/skill-writer.js
+// dist/src/skillify/skill-writer.js
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
@@ -216,7 +216,7 @@ function resolveSkillsRoot(install, cwd) {
   return join2(cwd, ".claude", "skills");
 }
 
-// dist/src/skilify/skills-table.js
+// dist/src/skillify/skills-table.js
 import { randomUUID } from "node:crypto";
 
 // dist/src/utils/sql.js
@@ -227,7 +227,7 @@ function sqlIdent(name) {
   return name;
 }
 
-// dist/src/skilify/skills-table.js
+// dist/src/skillify/skills-table.js
 function createSkillsTableSql(tableName) {
   const safe = sqlIdent(tableName);
   return `CREATE TABLE IF NOT EXISTS "${safe}" (id TEXT NOT NULL DEFAULT '', name TEXT NOT NULL DEFAULT '', project TEXT NOT NULL DEFAULT '', project_key TEXT NOT NULL DEFAULT '', local_path TEXT NOT NULL DEFAULT '', install TEXT NOT NULL DEFAULT 'project', source_sessions TEXT NOT NULL DEFAULT '[]', source_agent TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT 'me', author TEXT NOT NULL DEFAULT '', description TEXT NOT NULL DEFAULT '', trigger_text TEXT NOT NULL DEFAULT '', body TEXT NOT NULL DEFAULT '', version BIGINT NOT NULL DEFAULT 1, created_at TEXT NOT NULL DEFAULT '', updated_at TEXT NOT NULL DEFAULT '') USING deeplake`;
@@ -256,7 +256,7 @@ async function insertSkillRow(args) {
   }
 }
 
-// dist/src/skilify/gate-parser.js
+// dist/src/skillify/gate-parser.js
 function extractJsonBlock(s) {
   const trimmed = s.trim();
   if (!trimmed)
@@ -294,7 +294,7 @@ function parseVerdict(raw) {
   }
 }
 
-// dist/src/skilify/gate-runner.js
+// dist/src/skillify/gate-runner.js
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
@@ -403,28 +403,61 @@ function runGate(opts) {
   }
 }
 
-// dist/src/skilify/state.js
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, writeSync, mkdirSync as mkdirSync2, renameSync, existsSync as existsSync3, unlinkSync, openSync, closeSync } from "node:fs";
+// dist/src/skillify/state.js
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, writeSync, mkdirSync as mkdirSync2, renameSync as renameSync2, existsSync as existsSync4, unlinkSync, openSync, closeSync } from "node:fs";
 import { execSync } from "node:child_process";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { createHash } from "node:crypto";
-import { join as join4, basename } from "node:path";
-var dlog = (msg) => log("skilify-state", msg);
-var STATE_DIR = join4(homedir4(), ".deeplake", "state", "skilify");
+import { join as join5, basename } from "node:path";
+
+// dist/src/skillify/legacy-migration.js
+import { existsSync as existsSync3, renameSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var dlog = (msg) => log("skillify-migrate", msg);
+var attempted = false;
+function migrateLegacyStateDir() {
+  if (attempted)
+    return;
+  attempted = true;
+  const root = join4(homedir4(), ".deeplake", "state");
+  const legacy = join4(root, "skilify");
+  const current = join4(root, "skillify");
+  if (!existsSync3(legacy))
+    return;
+  if (existsSync3(current))
+    return;
+  try {
+    renameSync(legacy, current);
+    dlog(`migrated ${legacy} -> ${current}`);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EXDEV" || code === "EPERM") {
+      dlog(`migration failed (${code}); leaving legacy dir in place`);
+      return;
+    }
+    throw err;
+  }
+}
+
+// dist/src/skillify/state.js
+var dlog2 = (msg) => log("skillify-state", msg);
+var STATE_DIR = join5(homedir5(), ".deeplake", "state", "skillify");
 var YIELD_BUF = new Int32Array(new SharedArrayBuffer(4));
 var TRIGGER_THRESHOLD = (() => {
-  const n = Number(process.env.HIVEMIND_SKILIFY_EVERY_N_TURNS ?? "");
+  const n = Number(process.env.HIVEMIND_SKILLIFY_EVERY_N_TURNS ?? "");
   return Number.isInteger(n) && n > 0 ? n : 20;
 })();
 function statePath(projectKey) {
-  return join4(STATE_DIR, `${projectKey}.json`);
+  return join5(STATE_DIR, `${projectKey}.json`);
 }
 function lockPath(projectKey) {
-  return join4(STATE_DIR, `${projectKey}.lock`);
+  return join5(STATE_DIR, `${projectKey}.lock`);
 }
 function readState(projectKey) {
+  migrateLegacyStateDir();
   const p = statePath(projectKey);
-  if (!existsSync3(p))
+  if (!existsSync4(p))
     return null;
   try {
     return JSON.parse(readFileSync2(p, "utf-8"));
@@ -433,13 +466,15 @@ function readState(projectKey) {
   }
 }
 function writeState(projectKey, state) {
+  migrateLegacyStateDir();
   mkdirSync2(STATE_DIR, { recursive: true });
   const p = statePath(projectKey);
   const tmp = `${p}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync2(tmp, JSON.stringify(state, null, 2));
-  renameSync(tmp, p);
+  renameSync2(tmp, p);
 }
 function withRmwLock(projectKey, fn) {
+  migrateLegacyStateDir();
   mkdirSync2(STATE_DIR, { recursive: true });
   const rmw = lockPath(projectKey) + ".rmw";
   const deadline = Date.now() + 2e3;
@@ -451,11 +486,11 @@ function withRmwLock(projectKey, fn) {
       if (e.code !== "EEXIST")
         throw e;
       if (Date.now() > deadline) {
-        dlog(`rmw lock deadline exceeded for ${projectKey}, reclaiming stale lock`);
+        dlog2(`rmw lock deadline exceeded for ${projectKey}, reclaiming stale lock`);
         try {
           unlinkSync(rmw);
         } catch (unlinkErr) {
-          dlog(`stale rmw lock unlink failed for ${projectKey}: ${unlinkErr.message}`);
+          dlog2(`stale rmw lock unlink failed for ${projectKey}: ${unlinkErr.message}`);
         }
         continue;
       }
@@ -469,7 +504,7 @@ function withRmwLock(projectKey, fn) {
     try {
       unlinkSync(rmw);
     } catch (unlinkErr) {
-      dlog(`rmw lock cleanup failed for ${projectKey}: ${unlinkErr.message}`);
+      dlog2(`rmw lock cleanup failed for ${projectKey}: ${unlinkErr.message}`);
     }
   }
 }
@@ -509,18 +544,18 @@ function releaseWorkerLock(projectKey) {
   }
 }
 
-// dist/src/skilify/skilify-worker.js
+// dist/src/skillify/skillify-worker.js
 var cfg = JSON.parse(readFileSync3(process.argv[2], "utf-8"));
 var tmpDir = cfg.tmpDir;
-var verdictPath = join5(tmpDir, "verdict.json");
-var promptPath = join5(tmpDir, "prompt.txt");
+var verdictPath = join6(tmpDir, "verdict.json");
+var promptPath = join6(tmpDir, "prompt.txt");
 var SESSIONS_TO_MINE = 10;
 var PAIR_CHAR_CAP = 2e3;
 var TOTAL_PAIRS_CHAR_CAP = 4e4;
 var EXISTING_SKILLS_CHAR_CAP = 3e4;
 function wlog(msg) {
   try {
-    appendFileSync2(cfg.skilifyLog, `[${utcTimestamp()}] skilify-worker(${cfg.projectKey}): ${msg}
+    appendFileSync2(cfg.skillifyLog, `[${utcTimestamp()}] skillify-worker(${cfg.projectKey}): ${msg}
 `);
   } catch {
   }
@@ -715,7 +750,7 @@ function buildPrompt(pairs) {
   ].join("\n");
 }
 function readVerdict(stdout) {
-  if (existsSync4(verdictPath)) {
+  if (existsSync5(verdictPath)) {
     try {
       const text = readFileSync3(verdictPath, "utf-8");
       const v2 = parseVerdict(text);
@@ -784,9 +819,9 @@ async function main() {
       timeoutMs: 12e4
     });
     try {
-      writeFileSync3(join5(tmpDir, "gate-stdout.txt"), gate.stdout);
+      writeFileSync3(join6(tmpDir, "gate-stdout.txt"), gate.stdout);
       if (gate.stderr)
-        writeFileSync3(join5(tmpDir, "gate-stderr.txt"), gate.stderr);
+        writeFileSync3(join6(tmpDir, "gate-stderr.txt"), gate.stderr);
     } catch {
     }
     if (gate.errored) {

package/openclaw/openclaw.plugin.json

@@ -52,5 +52,5 @@
       }
     }
   },
-  "version": "0.7.16"
+  "version": "0.7.18"
 }

package/openclaw/package.json

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

package/openclaw/skills/SKILL.md

@@ -45,28 +45,28 @@ Do NOT jump straight to reading raw JSONL files. Always start with `hivemind_ind
 - `/hivemind_update` — shows how to install (ask the agent, or run `hivemind update` in your terminal)
 - `/hivemind_autoupdate [on|off]` — toggle the agent-facing update nudge (on by default: when a newer version is available, the agent is prompted to install it via `exec` if you ask to update)
 
-## Skill Management (skilify)
+## Skill Management (skillify)
 
 Hivemind also mines reusable Claude skills from agent sessions and stores them in a per-org Deeplake table. Openclaw itself doesn't run sessions to mine, but you can pull skills others have already mined for the user. These run in the user's terminal (the openclaw plugin does not register them as `/hivemind_*` commands):
 
-- `hivemind skilify` — show scope/team/install + per-project state
-- `hivemind skilify pull` — sync skills for the current project from the org table
-- `hivemind skilify pull --user <email>` — only that author's skills
-- `hivemind skilify pull --users a,b,c` — multiple authors (CSV)
-- `hivemind skilify pull --all-users` — explicit "no author filter"
-- `hivemind skilify pull --to project|global` — install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)
-- `hivemind skilify pull --dry-run` — preview without touching disk
-- `hivemind skilify pull --force` — overwrite local (creates `.bak`)
-- `hivemind skilify pull <skill-name>` — pull only that one skill (combines with `--user`)
-- `hivemind skilify unpull` — remove every skill previously installed by pull
-- `hivemind skilify unpull --user <email>` — remove only that author's pulls
-- `hivemind skilify unpull --not-mine` — remove all pulls except your own
-- `hivemind skilify unpull --dry-run` — preview without touching disk
-- `hivemind skilify scope <me|team|org>` — set sharing scope for new skills
-- `hivemind skilify install <project|global>` — default install location
-- `hivemind skilify team add|remove|list <name>` — manage team list
-
-If the user asks to "pull skills from X", "share skills with the team", or similar, suggest the matching `hivemind skilify` command. Run `hivemind skilify --help` for the full reference.
+- `hivemind skillify` — show scope/team/install + per-project state
+- `hivemind skillify pull` — sync skills for the current project from the org table
+- `hivemind skillify pull --user <email>` — only that author's skills
+- `hivemind skillify pull --users a,b,c` — multiple authors (CSV)
+- `hivemind skillify pull --all-users` — explicit "no author filter"
+- `hivemind skillify pull --to project|global` — install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)
+- `hivemind skillify pull --dry-run` — preview without touching disk
+- `hivemind skillify pull --force` — overwrite local (creates `.bak`)
+- `hivemind skillify pull <skill-name>` — pull only that one skill (combines with `--user`)
+- `hivemind skillify unpull` — remove every skill previously installed by pull
+- `hivemind skillify unpull --user <email>` — remove only that author's pulls
+- `hivemind skillify unpull --not-mine` — remove all pulls except your own
+- `hivemind skillify unpull --dry-run` — preview without touching disk
+- `hivemind skillify scope <me|team|org>` — set sharing scope for new skills
+- `hivemind skillify install <project|global>` — default install location
+- `hivemind skillify team add|remove|list <name>` — manage team list
+
+If the user asks to "pull skills from X", "share skills with the team", or similar, suggest the matching `hivemind skillify` command. Run `hivemind skillify --help` for the full reference.
 
 ## Limits
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeplake/hivemind",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
   "type": "module",
   "repository": {

package/pi/extension-source/hivemind.ts

@@ -26,12 +26,12 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import {
   readFileSync, existsSync, appendFileSync, mkdirSync, writeFileSync,
-  openSync, closeSync, constants as fsConstants,
+  openSync, closeSync, renameSync, constants as fsConstants,
 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 import { connect } from "node:net";
-import { spawn, execSync } from "node:child_process";
+import { spawn, spawnSync, execSync } from "node:child_process";
 import { createHash } from "node:crypto";
 
 // ---------- diagnostic logging --------------------------------------------------
@@ -205,11 +205,51 @@ function tryEmbedOverSocket(text: string, kind: "document" | "query"): Promise<n
 
 const SUMMARY_STATE_DIR = join(homedir(), ".claude", "hooks", "summary-state");
 const PI_WIKI_WORKER_PATH = join(homedir(), ".pi", "agent", "hivemind", "wiki-worker.js");
-// Skilify worker installed alongside wiki-worker by `hivemind pi install`.
+// Skillify worker installed alongside wiki-worker by `hivemind pi install`.
 // Spawned on session_shutdown to mine reusable Claude skills from the just-
 // finished session. Same shared bundle used by CC/Codex/Cursor/Hermes.
-const PI_SKILIFY_WORKER_PATH = join(homedir(), ".pi", "agent", "hivemind", "skilify-worker.js");
-const SKILIFY_STATE_DIR = join(homedir(), ".deeplake", "state", "skilify");
+const PI_SKILLIFY_WORKER_PATH = join(homedir(), ".pi", "agent", "hivemind", "skillify-worker.js");
+// Auto-pull worker installed alongside wiki-worker / skillify-worker by
+// `hivemind pi install`. Spawned synchronously on session_start to fetch
+// all-author skills from the org table. The worker is a thin wrapper
+// around the shared autoPullSkills() that codex / cursor / hermes call
+// directly — pi can't import the TS module (raw .ts, zero deps), so it
+// routes through this child process. Keeps pi's pulled skills layout +
+// symlink fan-out in lockstep with the other agents automatically.
+const PI_AUTOPULL_WORKER_PATH = join(homedir(), ".pi", "agent", "hivemind", "autopull-worker.js");
+
+/**
+ * Synchronously run the bundled auto-pull worker. Bounded by a 6s
+ * wall-clock cap (the worker's internal timeout is 5s; the extra second
+ * is defence-in-depth for spawn overhead). Returns when the worker
+ * exits, regardless of exit code — autoPullSkills is documented as
+ * never-rejecting and the worker swallows all failures, so a non-zero
+ * exit code can only mean an unrecoverable runtime error that we want
+ * to ignore here too. Pi's session_start blocks on this, mirroring the
+ * `await autoPullSkills()` in the other agents.
+ */
+function runAutopullWorker(): void {
+  if (!existsSync(PI_AUTOPULL_WORKER_PATH)) {
+    logHm(`autopull: worker bundle missing at ${PI_AUTOPULL_WORKER_PATH} — skipping`);
+    return;
+  }
+  try {
+    const result = spawnSync(process.execPath, [PI_AUTOPULL_WORKER_PATH], {
+      stdio: "ignore",
+      timeout: 6_000,
+      env: process.env,
+    });
+    if (result.error) {
+      logHm(`autopull: spawn failed (swallowed): ${result.error.message}`);
+    } else if (result.signal) {
+      logHm(`autopull: worker killed by signal ${result.signal} (likely the 6s cap)`);
+    } else {
+      logHm(`autopull: worker exited code=${result.status}`);
+    }
+  } catch (e: any) {
+    logHm(`autopull: spawn threw (swallowed): ${e?.message ?? e}`);
+  }
+}
 
 interface SummaryState {
   lastSummaryAt: number;
@@ -404,20 +444,20 @@ function spawnWikiWorker(
   }
 }
 
-// ---------- skilify worker spawn ---------------------------------------------
+// ---------- skillify worker spawn ---------------------------------------------
 //
-// Mirror of src/skilify/spawn-skilify-worker.ts and src/skilify/triggers.ts —
+// Mirror of src/skillify/spawn-skillify-worker.ts and src/skillify/triggers.ts —
 // inlined here because pi/extension-source/hivemind.ts is shipped as raw .ts
 // with zero non-builtin runtime dependencies (pi compiles + loads it at
-// extension-load time). The shared TypeScript modules under src/skilify/
+// extension-load time). The shared TypeScript modules under src/skillify/
 // can't be imported from this file.
 //
-// The skilify worker mines the just-finished session for reusable Claude
+// The skillify worker mines the just-finished session for reusable Claude
 // skills, gates each cluster via a model call, and writes SKILL.md files +
 // rows in the org's skills Deeplake table.
 
-/** Stable project key — sha1(cwd) truncated, mirrors src/skilify/state.ts deriveProjectKey. */
-function deriveSkilifyProjectKey(cwd: string): { key: string; project: string } {
+/** Stable project key — sha1(cwd) truncated, mirrors src/skillify/state.ts deriveProjectKey. */
+function deriveSkillifyProjectKey(cwd: string): { key: string; project: string } {
   const project = (cwd ?? "").split("/").pop() || "unknown";
   // Pi's extension can't easily run `git config` synchronously here; use cwd
   // as the signature. Two checkouts of the same repo at different paths get
@@ -427,15 +467,15 @@ function deriveSkilifyProjectKey(cwd: string): { key: string; project: string }
   return { key, project };
 }
 
-function spawnPiSkilifyWorker(creds: Creds, sessionId: string, cwd: string): void {
-  if (!existsSync(PI_SKILIFY_WORKER_PATH)) {
-    logHm(`spawnPiSkilifyWorker: no worker at ${PI_SKILIFY_WORKER_PATH} — install via 'hivemind pi install' or rebuild`);
+function spawnPiSkillifyWorker(creds: Creds, sessionId: string, cwd: string): void {
+  if (!existsSync(PI_SKILLIFY_WORKER_PATH)) {
+    logHm(`spawnPiSkillifyWorker: no worker at ${PI_SKILLIFY_WORKER_PATH} — install via 'hivemind pi install' or rebuild`);
     return;
   }
-  const { key: projectKey, project } = deriveSkilifyProjectKey(cwd);
+  const { key: projectKey, project } = deriveSkillifyProjectKey(cwd);
 
   // No spawn-side lock: the worker itself acquires `<projectKey>.lock` via
-  // src/skilify/state.ts:tryAcquireWorkerLock and releases it on exit (with
+  // src/skillify/state.ts:tryAcquireWorkerLock and releases it on exit (with
   // a 10-min stale-lock fallback). A spawn-side lock here would create a
   // SECOND lockfile (`<projectKey>.worker.lock`) that nobody releases,
   // permanently blocking subsequent spawns from the same Pi runtime
@@ -443,12 +483,12 @@ function spawnPiSkilifyWorker(creds: Creds, sessionId: string, cwd: string): voi
   // back-to-back spawns where a worker is in flight cost only one extra
   // node cold-start (~50ms) before the worker self-skips on the lock.
 
-  const tmpDir = join(tmpdir(), `deeplake-skilify-${projectKey}-${Date.now()}`);
+  const tmpDir = join(tmpdir(), `deeplake-skillify-${projectKey}-${Date.now()}`);
   try { mkdirSync(tmpDir, { recursive: true, mode: 0o700 }); }
-  catch (e: any) { logHm(`spawnPiSkilifyWorker: mkdir failed: ${e?.message ?? e}`); return; }
+  catch (e: any) { logHm(`spawnPiSkillifyWorker: mkdir failed: ${e?.message ?? e}`); return; }
   const configPath = join(tmpDir, "config.json");
 
-  // Same shape the spawn-skilify-worker.ts module writes for the other agents.
+  // Same shape the spawn-skillify-worker.ts module writes for the other agents.
   // Defaults match scope-config.ts: scope=me, install=project, no team list.
   // Pi-specific: no per-agent gate binary (`gateBin: null`) — the worker's
   // gate-runner falls back to its agent dispatch which for `agent: "pi"`
@@ -476,21 +516,21 @@ function spawnPiSkilifyWorker(creds: Creds, sessionId: string, cwd: string): voi
     // pi-specific gate args — match wikiWorker config defaults (google + gemini-2.5-flash)
     piProvider: process.env.HIVEMIND_PI_PROVIDER ?? "google",
     piModel: process.env.HIVEMIND_PI_MODEL ?? "gemini-2.5-flash",
-    skilifyLog: join(homedir(), ".deeplake", "hivemind-pi-skilify.log"),
+    skillifyLog: join(homedir(), ".deeplake", "hivemind-pi-skillify.log"),
     currentSessionId: sessionId,
   };
   try { writeFileSync(configPath, JSON.stringify(config), { mode: 0o600 }); }
-  catch (e: any) { logHm(`spawnPiSkilifyWorker: config write failed: ${e?.message ?? e}`); return; }
+  catch (e: any) { logHm(`spawnPiSkillifyWorker: config write failed: ${e?.message ?? e}`); return; }
 
-  logHm(`spawnPiSkilifyWorker: spawning ${PI_SKILIFY_WORKER_PATH} project=${project} key=${projectKey} session=${sessionId}`);
+  logHm(`spawnPiSkillifyWorker: spawning ${PI_SKILLIFY_WORKER_PATH} project=${project} key=${projectKey} session=${sessionId}`);
   try {
-    spawn(process.execPath, [PI_SKILIFY_WORKER_PATH, configPath], {
+    spawn(process.execPath, [PI_SKILLIFY_WORKER_PATH, configPath], {
       detached: true,
       stdio: "ignore",
-      env: { ...process.env, HIVEMIND_SKILIFY_WORKER: "1", HIVEMIND_CAPTURE: "false" },
+      env: { ...process.env, HIVEMIND_SKILLIFY_WORKER: "1", HIVEMIND_CAPTURE: "false" },
     }).unref();
   } catch (e: any) {
-    logHm(`spawnPiSkilifyWorker: spawn failed: ${e?.message ?? e}`);
+    logHm(`spawnPiSkillifyWorker: spawn failed: ${e?.message ?? e}`);
   }
 }
 
@@ -656,23 +696,23 @@ Organization management — each argument is SEPARATE (do NOT quote subcommands
 - hivemind members                            — list members
 - hivemind remove <user-id>                   — remove member
 
-SKILLS (skilify) — mine + share reusable skills across the org. Run these in a terminal (or via shell if available):
-- hivemind skilify                         — show scope/team/install + per-project state
-- hivemind skilify pull                    — sync project skills from the org table
-- hivemind skilify pull --user <email>     — only that author's skills
-- hivemind skilify pull --users a,b,c      — multiple authors (CSV)
-- hivemind skilify pull --all-users        — explicit "no author filter"
-- hivemind skilify pull --to project|global  — install location
-- hivemind skilify pull --dry-run          — preview only
-- hivemind skilify pull --force            — overwrite local (creates .bak)
-- hivemind skilify pull <skill-name>       — pull only that skill (combines with --user)
-- hivemind skilify unpull                  — remove every skill previously installed by pull
-- hivemind skilify unpull --user <email>   — remove only that author's pulls
-- hivemind skilify unpull --not-mine       — remove all pulls except your own
-- hivemind skilify unpull --dry-run        — preview without touching disk
-- hivemind skilify scope <me|team|org>     — sharing scope for new skills
-- hivemind skilify install <project|global>  — default install location
-- hivemind skilify team add|remove|list <name>  — manage team list`;
+SKILLS (skillify) — mine + share reusable skills across the org. Run these in a terminal (or via shell if available):
+- hivemind skillify                         — show scope/team/install + per-project state
+- hivemind skillify pull                    — sync project skills from the org table
+- hivemind skillify pull --user <email>     — only that author's skills
+- hivemind skillify pull --users a,b,c      — multiple authors (CSV)
+- hivemind skillify pull --all-users        — explicit "no author filter"
+- hivemind skillify pull --to project|global  — install location
+- hivemind skillify pull --dry-run          — preview only
+- hivemind skillify pull --force            — overwrite local (creates .bak)
+- hivemind skillify pull <skill-name>       — pull only that skill (combines with --user)
+- hivemind skillify unpull                  — remove every skill previously installed by pull
+- hivemind skillify unpull --user <email>   — remove only that author's pulls
+- hivemind skillify unpull --not-mine       — remove all pulls except your own
+- hivemind skillify unpull --dry-run        — preview without touching disk
+- hivemind skillify scope <me|team|org>     — sharing scope for new skills
+- hivemind skillify install <project|global>  — default install location
+- hivemind skillify team add|remove|list <name>  — manage team list`;
 
 export default function hivemindExtension(pi: ExtensionAPI): void {
   const captureEnabled = process.env.HIVEMIND_CAPTURE !== "false";
@@ -850,6 +890,15 @@ export default function hivemindExtension(pi: ExtensionAPI): void {
       }
       logHm(`session_start: sessions table visible=${visible} (probe took ${Date.now() - start}ms)`);
     }
+
+    // Auto-pull all-author skills via the bundled worker (same shared
+    // autoPullSkills as codex / cursor / hermes — see runAutopullWorker
+    // above). Synchronous so freshly pulled skills are visible to pi
+    // before the first prompt; 6s upper bound. Throttling, layout, and
+    // per-agent symlink fan-out all live in the worker — no inline
+    // duplicate maintained here.
+    if (creds) runAutopullWorker();
+
     const additional = creds
       ? `${CONTEXT_PREAMBLE}\nLogged in to Deeplake as org: ${creds.orgName ?? creds.orgId} (workspace: ${creds.workspaceId}).`
       : `${CONTEXT_PREAMBLE}\nNot logged in to Deeplake. Run \`hivemind login\` to authenticate.`;
@@ -958,13 +1007,13 @@ export default function hivemindExtension(pi: ExtensionAPI): void {
     // skips if a periodic worker is mid-flight. Non-fatal either way.
     spawnWikiWorker(creds, sessionId, cwd, "final");
 
-    // Also kick off the skilify worker so this session's prompt+answer
+    // Also kick off the skillify worker so this session's prompt+answer
     // pairs become candidates for reusable skills. Lock keyed on
     // projectKey, not sessionId — multiple sessions in the same project
     // shouldn't race the gate. Non-fatal: failure here only loses the
     // mining for this one session, never breaks the wiki summary above.
-    try { spawnPiSkilifyWorker(creds, sessionId, cwd); }
-    catch (e: any) { logHm(`session_shutdown: skilify spawn threw: ${e?.message ?? e}`); }
+    try { spawnPiSkillifyWorker(creds, sessionId, cwd); }
+    catch (e: any) { logHm(`session_shutdown: skillify spawn threw: ${e?.message ?? e}`); }
   });
 
   // Module-load breadcrumb so we know the extension's default export ran at all.