@deeplake/hivemind 0.7.14 → 0.7.16

package/.claude-plugin/marketplace.json

@@ -6,13 +6,13 @@
   },
   "metadata": {
     "description": "Cloud-backed persistent shared memory for AI agents powered by Deeplake",
-    "version": "0.7.14"
+    "version": "0.7.16"
   },
   "plugins": [
     {
       "name": "hivemind",
       "description": "Persistent shared memory powered by Deeplake — captures all session activity and provides cross-session, cross-agent memory search",
-      "version": "0.7.14",
+      "version": "0.7.16",
       "source": "./claude-code",
       "homepage": "https://github.com/activeloopai/hivemind"
     }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "hivemind",
   "description": "Cloud-backed persistent memory powered by Deeplake — read, write, and share memory across Claude Code sessions and agents",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "author": {
     "name": "Activeloop",
     "url": "https://deeplake.ai"

package/README.md

@@ -11,24 +11,27 @@
 <h4 align="center">One brain for all your agents</h4>
 
 <p align="center">
+  <a href="https://www.npmjs.com/package/@deeplake/hivemind"><img src="https://img.shields.io/npm/v/@deeplake/hivemind?color=blue&label=npm" alt="npm"></a>
+  <a href="https://github.com/activeloopai/hivemind/stargazers"><img src="https://img.shields.io/github/stars/activeloopai/hivemind?style=social" alt="GitHub stars"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License"></a>
   <a href="package.json"><img src="https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg" alt="Node"></a>
   <a href="https://deeplake.ai"><img src="https://img.shields.io/badge/Powered%20by-Deeplake-orange.svg" alt="Deeplake"></a>
 </p>
 
 <p align="center">
-  Persistent, cloud-backed shared memory for <b>Claude Code • OpenClaw • Codex • Cursor • Hermes • pi</b> agents.<br>
+  Auto-learning, cloud-backed shared brain for <b>Claude Code • OpenClaw • Codex • Cursor • Hermes • pi</b> agents.<br>
 </p>
 
-> One session ends, everything important disappears. 
+> One engineer's agent figures out a tricky migration on Monday.
 >
-> Hivemind finally fixes the "agent amnesia" problem. 
+> Tuesday, every agent on the team can execute the pattern.
 
-Hivemind automatically captures every prompt, tool call, decision, and file operation. Then turns them into searchable memory that is instantly available to every agent and teammate across sessions, machines, and time.
+**Beyond memory.** Hivemind captures every coding-agent interaction in your org as a structured trace, codifies repeated patterns into reusable skills, and propagates those skills to every agent on your team.
 
-- 🧠 **Captures** every session's prompts, tool calls, and responses into a shared SQL table on Deeplake Cloud
-- 🔍 **Searches** across all memory with lexical search (falls back to grep when index unavailable)
-- 🔗 **Shares** memory across sessions, agents, teammates, and machines in real-time
+- 📥 **Captures** every session's prompts, tool calls, and responses as structured traces in Deeplake
+- 🧠 **Codifies** patterns in those traces into reusable skills, available to every agent on your team
+- 🔍 **Searches** across all traces and skills with lexical retrieval (grep fallback when index unavailable)
+- 🔗 **Propagates** capability across sessions, agents, teammates, and machines in real time
 - 📁 **Intercepts** file operations on `~/.deeplake/memory/` through a virtual filesystem backed by SQL
 - 📝 **Summarizes** sessions into AI-generated wiki pages via a background worker at session end
 
@@ -40,7 +43,7 @@ One command, all your agents:
 npm install -g @deeplake/hivemind && hivemind install
 ```
 
-That's it. The installer detects every supported assistant on your machine (Claude Code, Codex, OpenClaw, Cursor, Hermes Agent, pi), wires up the hooks, and opens a browser once for login. Restart your assistants and they all share the same brain.
+The installer detects every supported assistant on your machine (table below), wires up the hooks, and opens a browser once for login. Restart them after install.
 
 **Install for a specific assistant only:**
 
@@ -188,51 +191,21 @@ hivemind codex uninstall        # remove from one
 
 ## How it works
 
-```
-┌─────────────────────────────────────────────────────┐
-│                   Your Coding Agent                 │
-└──────────────────────────┬──────────────────────────┘
-                           │
-        ┌──────────────────▼──────────────────┐
-        │  📥 Capture (every turn)            │
-        │  prompts · tool calls · responses   │
-        └──────────────────┬──────────────────┘
-                           │
-        ┌──────────────────▼──────────────────┐
-        │  🧠 Hivemind                        │
-        │  SQL tables · Virtual File System   │
-        │  Search Memory · inject context     │
-        └──────────────────┬──────────────────┘
-                           │
-        ┌──────────────────▼──────────────────┐
-        │  🌊 Deeplake                        │
-        │   Shared across all agents          │
-        │   Postgres · S3                     │
-        └─────────────────────────────────────┘
-```
-
-Every session is captured. Every agent can recall. Teammates in the same org see the same memory.
+**Capture → Codify → Propagate → Compound.** Every coding-agent interaction (prompt, tool call, response) is captured as a structured trace in Deeplake. A background worker mines traces for repeated patterns and codifies them into `SKILL.md` files, scoped to your workspace. Codified skills propagate into every Hivemind-connected agent's context at inference time. The agent your junior engineer used this morning is sharper because of what your senior engineer's agent figured out last week.
 
 ## Features
 
 ### 🔍 Natural search
 
-Just ask Claude naturally:
+Just ask your agent naturally:
 
 ```
 "What was Emanuele working on?"
-"Search memory for authentication bugs"
+"Search traces for authentication bugs we've solved"
 "What did we decide about the API design?"
+"Show me skills my team has codified for handling migrations"
 ```
 
-### 📝 AI-generated session summaries
-
-After each session, a background worker generates a wiki summary: key decisions, code changes, next steps. Browse them at `~/.deeplake/memory/summaries/`.
-
-### 👥 Team sharing
-
-Invite teammates to your Deeplake org. Their agents see your memory, your agents see theirs. No setup, no sync, no merge conflicts.
-
 ### 🔒 Privacy controls
 
 Disable capture entirely:
@@ -256,10 +229,11 @@ This plugin captures session activity and stores it in your Deeplake workspace:
 | User prompts          | Every message you send             |
 | Tool calls            | Tool name + full input             |
 | Tool responses        | Full tool output                   |
-| Assistant responses   | Claude's final response            |
+| Assistant responses   | The agent's final response         |
 | Subagent activity     | Subagent tool calls and responses  |
+| Codified skills       | Patterns extracted from traces     |
 
-**All users in your Deeplake workspace can read this data.** A DATA NOTICE is displayed at the start of every session.
+**All users in your Deeplake workspace can read this data.** That's the design — shared capability requires shared substrate. A DATA NOTICE is displayed at the start of every session. Workspace-level isolation prevents data leakage between orgs.
 
 ## Configuration
 
@@ -276,256 +250,41 @@ This plugin captures session activity and stores it in your Deeplake workspace:
 | `HIVEMIND_EMBEDDINGS`     | `true`                    | Set to `false` to force lexical-only mode  |
 | `HIVEMIND_DEBUG`          | —                         | Set to `1` for verbose hook debug logs     |
 
-## Optional: enable semantic search (embeddings)
-
-Hivemind can run a local embedding daemon (nomic-embed-text-v1.5, ~130 MB)
-so that `Grep` over `~/.deeplake/memory/` uses hybrid semantic + lexical
-ranking instead of pure BM25. This is **off by default** — the daemon
-depends on `@huggingface/transformers`, which pulls onnxruntime-node and
-sharp (~600 MB total with native binaries). Shipping that with every agent
-install would 60× the install size for a feature most users don't need.
-
-To enable, run the bundled command:
-
-```bash
-hivemind embeddings install
-```
-
-This installs `@huggingface/transformers` **once** into a shared directory
-(`~/.hivemind/embed-deps/`) and symlinks every detected agent's plugin to
-it, so the 600 MB cost is paid one time regardless of how many agents you
-have wired up. Re-run the same command after installing a new agent and
-the new symlink is added (the npm install is skipped because it's cached).
-
-Or do it in one shot at install time:
-
-```bash
-hivemind install --with-embeddings           # all detected agents
-hivemind <agent> install --with-embeddings   # a single agent
-```
-
-Other commands:
+## Semantic search (optional)
 
-```bash
-hivemind embeddings status              # show shared deps + per-agent state
-hivemind embeddings uninstall           # remove the per-agent symlinks
-hivemind embeddings uninstall --prune   # also delete the shared dir (~600 MB)
-```
+Hivemind ships with a local embedding daemon (nomic-embed-text-v1.5) for hybrid semantic + lexical search over `~/.deeplake/memory/`. **Off by default** because the dependency footprint is ~600 MB. Enable with `hivemind embeddings install` (or `hivemind install --with-embeddings`). Without it, search degrades silently to BM25/lexical-only.
 
-Restart your agents after enabling. From the next session, captured
-messages and AI-generated summaries will include a 768-dim embedding,
-and semantic recall queries will route through the local daemon (the
-nomic model is downloaded on first use and cached in `~/.cache/huggingface/`).
+Full guide: **[docs/EMBEDDINGS.md](docs/EMBEDDINGS.md)**.
 
-If `@huggingface/transformers` is **not** present, Hivemind silently
-degrades to lexical-only mode:
+## Summaries
 
-- ✅ Capture continues; rows still land in Deeplake.
-- ✅ `Grep` still works via BM25 / `ILIKE` matching on text columns.
-- ⚪ The `message_embedding` / `summary_embedding` columns stay `NULL`.
-- ⚪ The hook log notes `embeddings: no-transformers` once at session start.
+After each session, a background worker generates an AI-written wiki summary and stores it in the `memory` table alongside its 768-dim embedding. Long sessions checkpoint mid-session every 50 messages or 2 hours (configurable). The wiki worker shells out to the host agent's own CLI (`claude -p`, `codex exec`, `pi --print`, …) — no separate API key. Browse summaries at `~/.deeplake/memory/summaries/`.
 
-You can also force lexical-only mode explicitly with
-`HIVEMIND_EMBEDDINGS=false` (useful for CI or air-gapped environments).
+Triggers, generation flow, and env-var reference: **[docs/SUMMARIES.md](docs/SUMMARIES.md)**.
 
-## Summaries
+## Skills (skillify)
 
-Hivemind doesn't just capture raw events — it also generates an
-**AI-written wiki summary** for each session and stores it in the
-`memory` table (alongside its 768-dim `summary_embedding`). The summary
-is what shows up when you `Grep` for past sessions or follow links from
-`~/.deeplake/memory/index.md`.
-
-### When summaries are written
-
-Each agent (Claude Code / Codex / Cursor / Hermes / pi) fires a wiki
-worker on two triggers:
-
-| Trigger           | When it fires                                                                 |
-|-------------------|-------------------------------------------------------------------------------|
-| **Final**         | At session end (Stop / SessionEnd / session_shutdown), once.                  |
-| **Periodic**      | Mid-session, when **either** of two thresholds is hit since the last summary: |
-|                   | • messages-since-last-summary ≥ `HIVEMIND_SUMMARY_EVERY_N_MSGS` (default 50)  |
-|                   | • elapsed time ≥ `HIVEMIND_SUMMARY_EVERY_HOURS` (default 2)                   |
-
-The first message after a long pause therefore triggers a fresh
-summary; long sessions naturally checkpoint every ~50 messages.
-
-A per-session JSON sidecar at
-`~/.claude/hooks/summary-state/<sessionId>.json` tracks
-`{lastSummaryAt, lastSummaryCount, totalCount}`. The dir is shared
-across all agents (session ids are UUIDs so no collisions). It is
-**never deleted**, so resuming a session via `--resume` / `--continue`
-picks up where it left off.
-
-### How a summary is generated
-
-1. The wiki worker queries the `sessions` table for every event tied to
-   that session.
-2. It builds a structured prompt asking the host agent's CLI to extract
-   entities, decisions, files modified, open questions, etc.
-3. It shells out to that agent's CLI (`claude -p`, `codex exec`,
-   `pi --print`, …) with the prompt — never a separate API key, the
-   agent's existing credentials are used.
-4. The generated markdown is uploaded to the `memory` table at
-   `/summaries/<user>/<sessionId>.md`. The shared embedding daemon
-   produces the 768-dim `summary_embedding` so the summary is recallable
-   via semantic search.
-
-A lock file at `~/.claude/hooks/summary-state/<sessionId>.lock`
-prevents two workers from running concurrently for the same session.
-
-### Configuration
-
-| Env var                            | Default        | Effect                                              |
-|------------------------------------|----------------|-----------------------------------------------------|
-| `HIVEMIND_SUMMARY_EVERY_N_MSGS`    | `50`           | Trigger periodic when messages-since-last ≥ this    |
-| `HIVEMIND_SUMMARY_EVERY_HOURS`     | `2`            | Trigger periodic after this many hours, with ≥1 msg |
-| `HIVEMIND_CURSOR_MODEL`            | `auto`         | (cursor only) model passed to `cursor-agent --print --model` |
-| `HIVEMIND_HERMES_PROVIDER`         | `openrouter`   | (hermes only) provider passed to `hermes -z --provider` |
-| `HIVEMIND_HERMES_MODEL`            | `anthropic/claude-haiku-4-5` | (hermes only) model passed to `hermes -z -m` |
-| `HIVEMIND_PI_PROVIDER`             | `google`       | (pi only) provider passed to `pi --print --provider`|
-| `HIVEMIND_PI_MODEL`                | `gemini-2.5-flash` | (pi only) model passed to `pi --print --model` |
-| `HIVEMIND_CAPTURE=false`           | unset          | Disable both capture and summary generation         |
-
-For pi specifically, the wiki worker is bundled separately at
-`~/.pi/agent/hivemind/wiki-worker.js` (deposited by `hivemind pi install`).
-The other agents ship the wiki worker inside their per-agent plugin
-bundle.
-
-## Skills (skilify)
-
-Hivemind also crystallises **recurring patterns from your recent sessions
-into reusable Claude Code skills**, automatically. Same architecture as
-the wiki worker: an async background process that fires on Stop /
-SessionEnd, mines recent sessions in scope, asks Haiku whether the
-activity contains something worth keeping, and writes a `SKILL.md` if so.
-
-### When the skilify worker fires
-
-| Trigger          | When it fires                                                                  |
-|------------------|--------------------------------------------------------------------------------|
-| **Stop counter** | Mid-session, after every `HIVEMIND_SKILIFY_EVERY_N_TURNS` (default 20) turns. |
-| **SessionEnd**   | Always at end-of-session, regardless of counter — catches tail-of-session knowledge. |
-
-Per-project counter state lives at
-`~/.deeplake/state/skilify/<project-key>.json`. Project key is the sha1
-of `git config remote.origin.url` (with the absolute path as fallback for
-non-git dirs).
-
-### How a skill is generated
-
-1. The worker pulls the **last 10 sessions in scope** from the `sessions`
-   Deeplake table — strictly newer than the watermark in the state file.
-2. It strips each session to **prompt + assistant text only** (tool calls
-   and thinking blocks are dropped — they're noise for skill mining).
-3. It builds a gate prompt: existing project skill bodies + the 10
-   stripped exchanges + decision rules.
-4. It runs `claude -p haiku --permission-mode bypassPermissions` with the
-   prompt. The model returns a JSON verdict:
-   - `KEEP <name> <body>` — write a new skill.
-   - `MERGE <existing-name> <merged-body>` — update an existing skill, bump version.
-   - `SKIP <reason>` — pattern is one-off / generic / already covered.
-5. On KEEP/MERGE the skill is written to `<project>/.claude/skills/<name>/SKILL.md`
-   (or `~/.claude/skills/...` if you've set `install` to `global`), with
-   provenance frontmatter (`source_sessions`, `version`, `created_by_agent`,
-   timestamps).
-6. A row is also inserted into the `skills` Deeplake table for org-wide
-   provenance (append-only — never UPDATE, sidesteps the
-   UPDATE-coalescing quirk).
-
-### `/skilify` — managing scope, team, install location
-
-The `/skilify` slash command (Claude Code, Codex) and the `hivemind
-skilify` CLI control mining behaviour.
+Hivemind **codifies recurring patterns from your team's recent sessions into reusable skills** that propagate to every agent on your team — automatically. An async background worker fires on Stop / SessionEnd, mines recent sessions in scope, asks Haiku whether the activity contains something worth keeping, and writes a `SKILL.md` to `<project>/.claude/skills/<name>/`.
 
 ```bash
-hivemind skilify                            # show current scope, team, install, per-project state
-hivemind skilify scope <me|team|org>        # who counts as "in scope" for mining
-hivemind skilify install <project|global>   # where new skills are written
-hivemind skilify promote <skill-name>       # move a project skill to ~/.claude/skills/
-hivemind skilify team add <username>        # add to the team list (used when scope=team)
-hivemind skilify team remove <username>     # remove from team
-hivemind skilify team list                  # list current team members
+hivemind skillify                            # show current scope, team, install, per-project state
+hivemind skillify scope <me|team|org>        # who counts as "in scope" for mining
+hivemind skillify pull                       # install teammates' skills locally
+hivemind skillify unpull                     # remove pulled skills
 ```
 
-The team list flows into the worker's session-fetch SQL: `scope=me`
-filters by your own username, `scope=team` filters by `author IN
-(<team>)`, `scope=org` applies no author filter.
-
-Config persists at `~/.deeplake/state/skilify/config.json` (one global
-file shared across projects).
-
-### Configuration
-
-| Env var                              | Default | Effect                                                  |
-|--------------------------------------|---------|---------------------------------------------------------|
-| `HIVEMIND_SKILIFY_EVERY_N_TURNS`     | `20`    | Stop-counter threshold for mid-session worker fires     |
-| `HIVEMIND_SKILLS_TABLE`              | `skills`| Deeplake table name for org-wide provenance             |
-| `HIVEMIND_SKILIFY_WORKER=1`          | unset   | Recursion guard (set automatically inside the worker)   |
-| `HIVEMIND_CURSOR_MODEL`              | `auto`  | (cursor only) model passed to the cursor-agent gate call |
-| `HIVEMIND_HERMES_PROVIDER`           | `openrouter` | (hermes only) provider passed to the hermes gate call |
-| `HIVEMIND_HERMES_MODEL`              | `anthropic/claude-haiku-4-5` | (hermes only) model passed to hermes |
-
-### Per-agent gate CLI
-
-The skilify worker calls each agent's own headless CLI for the gate
-prompt — so a user who only has codex / cursor / hermes installed
-never needs `claude` in their PATH:
-
-| Agent       | Gate command                                                                          |
-|-------------|----------------------------------------------------------------------------------------|
-| claude_code | `claude -p <prompt> --no-session-persistence --model haiku --permission-mode bypassPermissions` |
-| codex       | `codex exec --dangerously-bypass-approvals-and-sandbox <prompt>`                       |
-| cursor      | `cursor-agent --print --model <HIVEMIND_CURSOR_MODEL> --force --output-format text <prompt>` |
-| hermes      | `hermes -z <prompt> --provider <HIVEMIND_HERMES_PROVIDER> -m <HIVEMIND_HERMES_MODEL> --yolo --ignore-user-config` |
-
-For hermes via OpenRouter (the default), set `OPENROUTER_API_KEY` in
-the environment; the worker inherits the parent process env. Other
-providers (anthropic, openai, etc.) need their respective API keys.
-
-### Logs
-
-Worker activity logs to `~/.claude/hooks/skilify.log`. Each line shows
-which session pool was mined, what the gate decided, and whether a file
-was written.
+Triggers, generation flow, full `pull` / `unpull` semantics, gate-CLI table per agent, env vars, logs: **[docs/SKILLIFY.md](docs/SKILLIFY.md)**.
 
 ## Architecture
 
-### Integration model per agent
-
-| Agent             | Mechanism                          | Hooks/tools wired                                                                       |
-|-------------------|------------------------------------|-----------------------------------------------------------------------------------------|
-| **Claude Code**   | Marketplace plugin                 | `SessionStart` · `UserPromptSubmit` · `PreToolUse` · `PostToolUse` · `Stop` · `SubagentStop` · `SessionEnd` |
-| **Codex**         | `~/.codex/hooks.json`              | `SessionStart` · `UserPromptSubmit` · `PreToolUse(Bash)` · `PostToolUse` · `Stop`        |
-| **OpenClaw**      | Native extension at `~/.openclaw/extensions/hivemind/` | `agent_end` capture · `before_agent_start` recall · contracted tools (`hivemind_search`/`read`/`index`) |
-| **Cursor (1.7+)** | `~/.cursor/hooks.json`             | `sessionStart` · `beforeSubmitPrompt` · `postToolUse` · `afterAgentResponse` · `stop` · `sessionEnd` |
-| **Hermes**        | Skill at `~/.hermes/skills/hivemind-memory/` | recall via grep on `~/.deeplake/memory/`                                                |
-| **pi**            | `~/.pi/agent/AGENTS.md` + skill    | recall via grep on `~/.deeplake/memory/`                                                |
+Per-agent integration mechanisms (marketplace plugin, hooks, skills, native extension) and monorepo structure: **[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)**.
 
-### Monorepo structure
+## Roadmap
 
-```
-hivemind/
-├── src/                    ← shared core (API client, auth, config, SQL utils)
-│   ├── hooks/              ← Claude Code hooks
-│   ├── hooks/codex/        ← Codex hooks
-│   ├── hooks/cursor/       ← Cursor hooks
-│   ├── hooks/hermes/       ← Hermes shell hooks
-│   ├── hooks/pi/           ← pi wiki-worker (extension lives in pi/extension-source/)
-│   ├── embeddings/         ← nomic embed-daemon + protocol + SQL helpers
-│   ├── mcp/                ← MCP server (used by Hermes; available to any future MCP-aware client)
-│   ├── commands/           ← auth, auth-creds, auth-login, session-prune
-│   └── cli/                ← unified `hivemind install` CLI + per-agent installers
-├── claude-code/            ← Claude Code plugin source (marketplace-distributed)
-├── codex/                  ← Codex plugin build output (npm-distributed)
-├── cursor/                 ← Cursor plugin build output (npm-distributed)
-├── hermes/                 ← Hermes plugin build output (npm-distributed)
-├── mcp/                    ← MCP server build output (shared by Hermes + future MCP clients)
-├── openclaw/               ← OpenClaw plugin source + build output (ClawHub-distributed)
-├── pi/                     ← pi extension source (ships raw .ts; pi compiles at load)
-└── bundle/                 ← unified `hivemind` CLI build output
-```
+- **Trajectory export for fine-tuning.** Because traces are stored in Deeplake's tensor format, they're export-ready as PyTorch datasets. Teams running their own open-source models can fine-tune on their org's accumulated trajectories. A handful of advanced customers are already doing this against the trajectories their Claude Code and Codex agents generated.
+- **GPU-accelerated dense retrieval at scale.** Local CPU embeddings already ship via the optional nomic-embed daemon (see [Semantic search](#semantic-search-optional)). Next: GPU-accelerated vector search over the full trace store, on by default.
+- **Skill versioning and review.** Pre-release human review for codified skills before they propagate org-wide, for teams that want a curation step.
+- **More agents.** If your team uses an agent that isn't on the supported-assistants list above, open an issue.
 
 ## Security
 

package/bundle/cli.js

@@ -4710,9 +4710,9 @@ if (process.argv[1] && process.argv[1].endsWith("auth-login.js")) {
 }
 
 // dist/src/commands/skilify.js
-import { readdirSync as readdirSync3, existsSync as existsSync15, readFileSync as readFileSync12, mkdirSync as mkdirSync7, renameSync as renameSync2 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname2, join as join18 } from "node:path";
+import { readdirSync as readdirSync4, existsSync as existsSync17, readFileSync as readFileSync13, mkdirSync as mkdirSync8, renameSync as renameSync3 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname3, join as join20 } from "node:path";
 
 // dist/src/skilify/scope-config.js
 import { existsSync as existsSync12, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
@@ -4740,9 +4740,9 @@ function saveScopeConfig(cfg) {
 }
 
 // dist/src/skilify/pull.js
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, renameSync } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, renameSync as renameSync2 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join18 } from "node:path";
 
 // dist/src/skilify/skill-writer.js
 import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync10, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
@@ -4805,7 +4805,99 @@ function parseFrontmatter(text) {
   return { fm, body };
 }
 
+// dist/src/skilify/manifest.js
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync11, renameSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname2, join as join17 } from "node:path";
+function emptyManifest() {
+  return { version: 1, entries: [] };
+}
+function manifestPath() {
+  return join17(homedir7(), ".deeplake", "state", "skilify", "pulled.json");
+}
+function loadManifest(path = manifestPath()) {
+  if (!existsSync14(path))
+    return emptyManifest();
+  let raw;
+  try {
+    raw = readFileSync11(path, "utf-8");
+  } catch {
+    return emptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return emptyManifest();
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries))
+      return emptyManifest();
+    const entries = [];
+    for (const e of parsed.entries) {
+      if (!e || typeof e !== "object")
+        continue;
+      if (typeof e.dirName !== "string" || !e.dirName)
+        continue;
+      if (e.dirName.includes("/") || e.dirName.includes("\\") || e.dirName.includes(".."))
+        continue;
+      if (typeof e.name !== "string" || !e.name)
+        continue;
+      if (typeof e.author !== "string")
+        continue;
+      if (typeof e.installRoot !== "string" || !e.installRoot)
+        continue;
+      if (e.install !== "global" && e.install !== "project")
+        continue;
+      entries.push({
+        dirName: e.dirName,
+        name: e.name,
+        author: e.author,
+        projectKey: typeof e.projectKey === "string" ? e.projectKey : "",
+        remoteVersion: typeof e.remoteVersion === "number" ? e.remoteVersion : 1,
+        install: e.install,
+        installRoot: e.installRoot,
+        pulledAt: typeof e.pulledAt === "string" ? e.pulledAt : (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return { version: 1, entries };
+  } catch {
+    return emptyManifest();
+  }
+}
+function saveManifest(m, path = manifestPath()) {
+  mkdirSync6(dirname2(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync8(tmp, JSON.stringify(m, null, 2) + "\n", { mode: 384 });
+  renameSync(tmp, path);
+}
+function recordPull(entry, path = manifestPath()) {
+  const m = loadManifest(path);
+  const idx = m.entries.findIndex((e) => e.install === entry.install && e.installRoot === entry.installRoot && e.dirName === entry.dirName);
+  if (idx >= 0)
+    m.entries[idx] = entry;
+  else
+    m.entries.push(entry);
+  saveManifest(m, path);
+}
+function removePullEntry(install, installRoot, dirName, path = manifestPath()) {
+  const m = loadManifest(path);
+  const before = m.entries.length;
+  m.entries = m.entries.filter((e) => !(e.install === install && e.installRoot === installRoot && e.dirName === dirName));
+  if (m.entries.length !== before)
+    saveManifest(m, path);
+}
+function entriesForRoot(m, install, installRoot) {
+  return m.entries.filter((e) => e.install === install && e.installRoot === installRoot);
+}
+
 // dist/src/skilify/pull.js
+function assertValidAuthor(author) {
+  if (!author)
+    throw new Error("author is empty");
+  if (author.length > 64)
+    throw new Error(`author too long (${author.length}): ${author.slice(0, 32)}\u2026`);
+  if (!/^[A-Za-z0-9_.\-@]+$/.test(author)) {
+    throw new Error(`author contains invalid characters: ${author}`);
+  }
+}
 function esc(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/[\x01-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
 }
@@ -4828,10 +4920,10 @@ function isMissingTableError(message) {
 }
 function resolvePullDestination(install, cwd) {
   if (install === "global")
-    return join17(homedir7(), ".claude", "skills");
+    return join18(homedir8(), ".claude", "skills");
   if (!cwd)
     throw new Error("install=project requires a cwd");
-  return join17(cwd, ".claude", "skills");
+  return join18(cwd, ".claude", "skills");
 }
 function selectLatestPerName(rows) {
   const seen = /* @__PURE__ */ new Set();
@@ -4897,10 +4989,10 @@ function renderFrontmatter(fm) {
   return lines.join("\n");
 }
 function readLocalVersion(path) {
-  if (!existsSync14(path))
+  if (!existsSync15(path))
     return null;
   try {
-    const text = readFileSync11(path, "utf-8");
+    const text = readFileSync12(path, "utf-8");
     const parsed = parseFrontmatter(text);
     if (!parsed)
       return null;
@@ -4953,9 +5045,39 @@ async function runPull(opts) {
       summary.skipped++;
       continue;
     }
-    const projectKey = String(row.project_key ?? "");
-    const skillDir = projectKey ? join17(root, projectKey, name) : join17(root, name);
-    const skillFile = join17(skillDir, "SKILL.md");
+    const author = String(row.author ?? "");
+    if (!author) {
+      summary.entries.push({
+        name,
+        remoteVersion: Number(row.version ?? 1),
+        localVersion: null,
+        action: "skipped",
+        destination: "(empty author \u2014 skipped)",
+        author: "",
+        sourceAgent: String(row.source_agent ?? "")
+      });
+      summary.skipped++;
+      continue;
+    }
+    let dirName;
+    try {
+      assertValidAuthor(author);
+      dirName = `${name}--${author}`;
+    } catch (e) {
+      summary.entries.push({
+        name,
+        remoteVersion: Number(row.version ?? 1),
+        localVersion: null,
+        action: "skipped",
+        destination: `(invalid author '${author}' \u2014 skipped)`,
+        author,
+        sourceAgent: String(row.source_agent ?? "")
+      });
+      summary.skipped++;
+      continue;
+    }
+    const skillDir = join18(root, dirName);
+    const skillFile = join18(skillDir, "SKILL.md");
     const remoteVersion = Number(row.version ?? 1);
     const localVersion = readLocalVersion(skillFile);
     const action = decideAction({
@@ -4964,15 +5086,30 @@ async function runPull(opts) {
       force: opts.force ?? false,
       dryRun: opts.dryRun ?? false
     });
+    let manifestError;
     if (action === "wrote") {
-      mkdirSync6(skillDir, { recursive: true });
-      if (existsSync14(skillFile)) {
+      mkdirSync7(skillDir, { recursive: true });
+      if (existsSync15(skillFile)) {
         try {
-          renameSync(skillFile, `${skillFile}.bak`);
+          renameSync2(skillFile, `${skillFile}.bak`);
         } catch {
         }
       }
-      writeFileSync8(skillFile, renderSkillFile(row));
+      writeFileSync9(skillFile, renderSkillFile(row));
+      try {
+        recordPull({
+          dirName,
+          name,
+          author,
+          projectKey: String(row.project_key ?? ""),
+          remoteVersion,
+          install: opts.install,
+          installRoot: root,
+          pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (e) {
+        manifestError = e?.message ?? String(e);
+      }
     }
     summary.entries.push({
       name,
@@ -4981,7 +5118,8 @@ async function runPull(opts) {
       action,
       destination: skillFile,
       author: String(row.author ?? ""),
-      sourceAgent: String(row.source_agent ?? "")
+      sourceAgent: String(row.source_agent ?? ""),
+      manifestError
     });
     if (action === "wrote")
       summary.wrote++;
@@ -4993,18 +5131,186 @@ async function runPull(opts) {
   return summary;
 }
 
+// dist/src/skilify/unpull.js
+import { existsSync as existsSync16, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync3 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join19 } from "node:path";
+function resolveUnpullRoot(install, cwd) {
+  if (install === "global")
+    return join19(homedir9(), ".claude", "skills");
+  if (!cwd)
+    throw new Error("cwd required when install === 'project'");
+  return join19(cwd, ".claude", "skills");
+}
+function runUnpull(opts) {
+  const root = resolveUnpullRoot(opts.install, opts.cwd);
+  const summary = {
+    scanned: 0,
+    removed: 0,
+    wouldRemove: 0,
+    kept: 0,
+    manifestPruned: 0,
+    entries: []
+  };
+  const userFilter = new Set(opts.users.filter((u) => u.length > 0));
+  const haveUserFilter = userFilter.size > 0;
+  if ((opts.all || opts.legacyCleanup) && (haveUserFilter || opts.notMine)) {
+    const flags = [opts.all && "--all", opts.legacyCleanup && "--legacy-cleanup"].filter(Boolean).join(" / ");
+    const filters = [haveUserFilter && "--user/--users", opts.notMine && "--not-mine"].filter(Boolean).join(" / ");
+    throw new Error(`${flags} cannot be combined with ${filters}: entries removed by ${flags} are not in the manifest and have no author metadata, so the filter would silently fail to apply. Run the filtered unpull first, then ${flags} as a separate invocation.`);
+  }
+  const manifest = loadManifest();
+  const entries = entriesForRoot(manifest, opts.install, root);
+  for (const entry of entries) {
+    summary.scanned++;
+    const path = join19(root, entry.dirName);
+    if (!existsSync16(path)) {
+      if (!opts.dryRun)
+        removePullEntry(opts.install, entry.installRoot, entry.dirName);
+      summary.entries.push({
+        dirName: entry.dirName,
+        kind: "manifest-orphan",
+        author: entry.author,
+        name: entry.name,
+        action: opts.dryRun ? "kept-policy" : "manifest-pruned",
+        reason: opts.dryRun ? "would-prune (orphan, dir missing)" : "directory was already missing",
+        path: ""
+      });
+      if (!opts.dryRun)
+        summary.manifestPruned++;
+      else
+        summary.kept++;
+      continue;
+    }
+    const decision = decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter);
+    const result = {
+      dirName: entry.dirName,
+      kind: "pulled-manifest",
+      author: entry.author,
+      name: entry.name,
+      action: "kept-policy",
+      path
+    };
+    if (!decision.shouldRemove) {
+      result.reason = decision.reason;
+      summary.kept++;
+      summary.entries.push(result);
+      continue;
+    }
+    if (opts.dryRun) {
+      result.action = "would-remove";
+      summary.wouldRemove++;
+    } else {
+      try {
+        rmSync5(path, { recursive: true, force: true });
+        removePullEntry(opts.install, entry.installRoot, entry.dirName);
+        result.action = "removed";
+        summary.removed++;
+      } catch (e) {
+        result.action = "kept-policy";
+        result.reason = `rm failed: ${e?.message ?? e}`;
+        summary.kept++;
+      }
+    }
+    summary.entries.push(result);
+  }
+  if (existsSync16(root) && (opts.all || opts.legacyCleanup)) {
+    const manifestDirNames = new Set(entries.map((e) => e.dirName));
+    for (const dirName of readdirSync3(root)) {
+      if (manifestDirNames.has(dirName))
+        continue;
+      const path = join19(root, dirName);
+      let st;
+      try {
+        st = statSync3(path);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory())
+        continue;
+      const isLegacyProjectKey = /^[0-9a-f]{16}$/.test(dirName);
+      const isLocallyMined = !isLegacyProjectKey && /^[A-Za-z0-9_.-]+$/.test(dirName) && !dirName.includes("--");
+      let kind;
+      let shouldRemove = false;
+      let reason;
+      if (isLegacyProjectKey) {
+        kind = "legacy-projectkey";
+        if (opts.legacyCleanup)
+          shouldRemove = true;
+        else
+          reason = "legacy project_key dir (use --legacy-cleanup)";
+      } else if (isLocallyMined) {
+        kind = "locally-mined";
+        if (opts.all)
+          shouldRemove = true;
+        else
+          reason = "locally-mined (use --all to remove)";
+      } else {
+        continue;
+      }
+      summary.scanned++;
+      const result = {
+        dirName,
+        kind,
+        author: null,
+        name: kind === "locally-mined" ? dirName : null,
+        action: "kept-policy",
+        path,
+        reason
+      };
+      if (!shouldRemove) {
+        summary.kept++;
+        summary.entries.push(result);
+        continue;
+      }
+      if (opts.dryRun) {
+        result.action = "would-remove";
+        summary.wouldRemove++;
+      } else {
+        try {
+          rmSync5(path, { recursive: true, force: true });
+          result.action = "removed";
+          summary.removed++;
+        } catch (e) {
+          result.action = "kept-policy";
+          result.reason = `rm failed: ${e?.message ?? e}`;
+          summary.kept++;
+        }
+      }
+      summary.entries.push(result);
+    }
+  }
+  return summary;
+}
+function decideTargetForManifestEntry(entry, opts, userFilter, haveUserFilter) {
+  if (haveUserFilter && !userFilter.has(entry.author)) {
+    return { shouldRemove: false, reason: `author '${entry.author}' not in filter` };
+  }
+  if (opts.notMine) {
+    if (!opts.myUsername)
+      return { shouldRemove: false, reason: "--not-mine requires myUsername" };
+    if (entry.author === opts.myUsername) {
+      return { shouldRemove: false, reason: "your own pull (--not-mine excludes self)" };
+    }
+  }
+  return { shouldRemove: true };
+}
+
 // dist/src/commands/skilify.js
-var STATE_DIR2 = join18(homedir8(), ".deeplake", "state", "skilify");
+function stateDir() {
+  return join20(homedir10(), ".deeplake", "state", "skilify");
+}
 function showStatus() {
   const cfg = loadScopeConfig();
   console.log(`scope:   ${cfg.scope}`);
   console.log(`team:    ${cfg.team.length === 0 ? "(empty)" : cfg.team.join(", ")}`);
   console.log(`install: ${cfg.install}  (${cfg.install === "global" ? "~/.claude/skills/" : "<project>/.claude/skills/"})`);
-  if (!existsSync15(STATE_DIR2)) {
+  const dir = stateDir();
+  if (!existsSync17(dir)) {
     console.log(`state: (no projects tracked yet)`);
     return;
   }
-  const files = readdirSync3(STATE_DIR2).filter((f) => f.endsWith(".json") && f !== "config.json");
+  const files = readdirSync4(dir).filter((f) => f.endsWith(".json") && f !== "config.json" && f !== "pulled.json");
   if (files.length === 0) {
     console.log(`state: (no projects tracked yet)`);
     return;
@@ -5012,7 +5318,7 @@ function showStatus() {
   console.log(`state: ${files.length} project(s) tracked`);
   for (const f of files) {
     try {
-      const s = JSON.parse(readFileSync12(join18(STATE_DIR2, f), "utf-8"));
+      const s = JSON.parse(readFileSync13(join20(dir, f), "utf-8"));
       const skills = s.skillsGenerated.length === 0 ? "none" : s.skillsGenerated.join(", ");
       console.log(`  - ${s.project} (counter=${s.counter}, last=${s.lastDate ?? "never"}, skills=${skills})`);
     } catch {
@@ -5038,7 +5344,7 @@ function setInstall(loc) {
   }
   const cfg = loadScopeConfig();
   saveScopeConfig({ ...cfg, install: loc });
-  const path = loc === "global" ? join18(homedir8(), ".claude", "skills") : "<cwd>/.claude/skills";
+  const path = loc === "global" ? join20(homedir10(), ".claude", "skills") : "<cwd>/.claude/skills";
   console.log(`Install location set to '${loc}'. New skills will be written to ${path}/<name>/SKILL.md.`);
 }
 function promoteSkill(name, cwd) {
@@ -5046,18 +5352,18 @@ function promoteSkill(name, cwd) {
     console.error("Usage: hivemind skilify promote <skill-name>");
     process.exit(1);
   }
-  const projectPath = join18(cwd, ".claude", "skills", name);
-  const globalPath = join18(homedir8(), ".claude", "skills", name);
-  if (!existsSync15(join18(projectPath, "SKILL.md"))) {
+  const projectPath = join20(cwd, ".claude", "skills", name);
+  const globalPath = join20(homedir10(), ".claude", "skills", name);
+  if (!existsSync17(join20(projectPath, "SKILL.md"))) {
     console.error(`Skill '${name}' not found at ${projectPath}/SKILL.md`);
     process.exit(1);
   }
-  if (existsSync15(join18(globalPath, "SKILL.md"))) {
+  if (existsSync17(join20(globalPath, "SKILL.md"))) {
     console.error(`Skill '${name}' already exists at ${globalPath}/SKILL.md \u2014 refusing to overwrite. Remove it first or rename the project skill.`);
     process.exit(1);
   }
-  mkdirSync7(dirname2(globalPath), { recursive: true });
-  renameSync2(projectPath, globalPath);
+  mkdirSync8(dirname3(globalPath), { recursive: true });
+  renameSync3(projectPath, globalPath);
   console.log(`Promoted '${name}' from ${projectPath} \u2192 ${globalPath}.`);
 }
 function teamAdd(name) {
@@ -5114,6 +5420,15 @@ function usage() {
   console.log("      --all-users               all authors (default \u2014 equivalent to no filter)");
   console.log("      --dry-run                 show what would be written, don't touch disk");
   console.log("      --force                   overwrite even when local version >= remote");
+  console.log("  hivemind skilify unpull [opts]              remove skills previously installed by pull");
+  console.log("    Options for unpull:");
+  console.log("      --to <project|global>     where to scan (default: global)");
+  console.log("      --user <name>             only entries authored by this user");
+  console.log("      --users <a,b,c>           only entries authored by these users");
+  console.log("      --not-mine                remove all pulled entries except your own");
+  console.log("      --dry-run                 show what would be removed");
+  console.log("      --all                     also remove flat-layout (locally-mined) entries");
+  console.log("      --legacy-cleanup          also remove pre-`--author`-layout legacy `<projectKey>/` dirs");
   console.log("  hivemind skilify status                     show per-project state");
 }
 function takeFlagValue(args, flag) {
@@ -5178,7 +5493,7 @@ async function pullSkills(args) {
     console.error(`pull failed: ${e?.message ?? e}`);
     process.exit(1);
   }
-  const dest = toRaw === "global" ? join18(homedir8(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const dest = toRaw === "global" ? join20(homedir10(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
   const filterDesc = users.length === 0 ? "all users" : users.join(", ");
   console.log(`Destination: ${dest}`);
   console.log(`Filter:      ${filterDesc}${skillName ? ` \xB7 skill='${skillName}'` : ""}${dryRun ? " \xB7 dry-run" : ""}${force ? " \xB7 force" : ""}`);
@@ -5187,9 +5502,72 @@ async function pullSkills(args) {
     const tag = e.action === "wrote" ? "\u2713 wrote" : e.action === "dryrun" ? "\u2192 would write" : "\xB7 skipped";
     const ver = e.localVersion === null ? `v${e.remoteVersion} (new)` : `v${e.localVersion} \u2192 v${e.remoteVersion}`;
     console.log(`  ${tag.padEnd(15)} ${e.name.padEnd(40)} ${ver.padEnd(20)} (${e.author}/${e.sourceAgent})`);
+    if (e.manifestError) {
+      console.warn(`    \u26A0 manifest not updated: ${e.manifestError} \u2014 \`unpull\` will not see this entry until a successful repull.`);
+    }
   }
   console.log(`Result: ${summary.wrote} written, ${summary.dryrun} dry-run, ${summary.skipped} skipped.`);
 }
+async function unpullSkills(args) {
+  const work = [...args];
+  const toRaw = takeFlagValue(work, "--to") ?? "global";
+  const userOne = takeFlagValue(work, "--user");
+  const usersMany = takeFlagValue(work, "--users");
+  const notMine = takeBooleanFlag(work, "--not-mine");
+  const dryRun = takeBooleanFlag(work, "--dry-run");
+  const all = takeBooleanFlag(work, "--all");
+  const legacyCleanup = takeBooleanFlag(work, "--legacy-cleanup");
+  if (toRaw !== "project" && toRaw !== "global") {
+    throw new Error(`Invalid --to '${toRaw}'. Use 'project' or 'global'.`);
+  }
+  let users = [];
+  if (userOne)
+    users = [userOne];
+  else if (usersMany)
+    users = usersMany.split(",").map((s) => s.trim()).filter(Boolean);
+  let myUsername;
+  if (notMine) {
+    const config = loadConfig();
+    if (!config) {
+      throw new Error("--not-mine requires a logged-in user. Run: hivemind login");
+    }
+    myUsername = config.userName;
+  }
+  const summary = runUnpull({
+    install: toRaw,
+    cwd: toRaw === "project" ? process.cwd() : void 0,
+    users,
+    myUsername,
+    notMine,
+    dryRun,
+    all,
+    legacyCleanup
+  });
+  const dest = toRaw === "global" ? join20(homedir10(), ".claude", "skills") : `${process.cwd()}/.claude/skills`;
+  const filterParts = [];
+  if (users.length > 0)
+    filterParts.push(`users=${users.join(",")}`);
+  if (notMine)
+    filterParts.push("not-mine");
+  if (all)
+    filterParts.push("all");
+  if (legacyCleanup)
+    filterParts.push("legacy-cleanup");
+  if (dryRun)
+    filterParts.push("dry-run");
+  const filterDesc = filterParts.length ? filterParts.join(" \xB7 ") : "(no filter \u2014 all pulled)";
+  console.log(`Scanning:    ${dest}`);
+  console.log(`Filter:      ${filterDesc}`);
+  console.log(`Scanned ${summary.scanned} dir(s).`);
+  for (const e of summary.entries) {
+    const tag = e.action === "removed" ? "\u2713 removed" : e.action === "would-remove" ? "\u2192 would remove" : e.action === "manifest-pruned" ? "\u26A0 pruned (orphan)" : "\xB7 kept";
+    const id = e.dirName;
+    const note = e.reason ? `  (${e.reason})` : "";
+    console.log(`  ${tag.padEnd(20)} ${id.padEnd(50)} [${e.kind}]${note}`);
+  }
+  const prunedNote = summary.manifestPruned > 0 ? `, ${summary.manifestPruned} manifest-pruned` : "";
+  console.log(`Result: ${summary.removed} removed, ${summary.wouldRemove} dry-run, ${summary.kept} kept${prunedNote}.`);
+}
 function runSkilifyCommand(args) {
   const sub = args[0];
   if (!sub || sub === "status") {
@@ -5215,6 +5593,14 @@ function runSkilifyCommand(args) {
     });
     return;
   }
+  if (sub === "unpull") {
+    unpullSkills(args.slice(1)).catch((e) => {
+      console.error(`unpull error: ${e?.message ?? e}`);
+      process.exit(1);
+    }).catch(() => {
+    });
+    return;
+  }
   if (sub === "team") {
     const action = args[1];
     if (action === "add") {
@@ -5246,13 +5632,13 @@ if (process.argv[1] && process.argv[1].endsWith("skilify.js")) {
 
 // dist/src/cli/update.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync14, realpathSync } from "node:fs";
-import { dirname as dirname4, sep } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, realpathSync } from "node:fs";
+import { dirname as dirname5, sep } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/src/utils/version-check.js
-import { readFileSync as readFileSync13 } from "node:fs";
-import { dirname as dirname3, join as join19 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { dirname as dirname4, join as join21 } from "node:path";
 function isNewer(latest, current) {
   const parse = (v) => v.split(".").map(Number);
   const [la, lb, lc] = parse(latest);
@@ -5271,24 +5657,24 @@ function detectInstallKind(argv1) {
       return argv1 ?? process.argv[1] ?? fileURLToPath2(import.meta.url);
     }
   })();
-  let dir = dirname4(realArgv1);
+  let dir = dirname5(realArgv1);
   let installDir = null;
   for (let i = 0; i < 10; i++) {
     const pkgPath = `${dir}${sep}package.json`;
     try {
-      const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
       if (pkg.name === PKG_NAME || pkg.name === "hivemind") {
         installDir = dir;
         break;
       }
     } catch {
     }
-    const parent = dirname4(dir);
+    const parent = dirname5(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
-  installDir ??= dirname4(realArgv1);
+  installDir ??= dirname5(realArgv1);
   if (realArgv1.includes(`${sep}_npx${sep}`) || realArgv1.includes(`${sep}.npx${sep}`)) {
     return { kind: "npx", installDir };
   }
@@ -5297,10 +5683,10 @@ function detectInstallKind(argv1) {
   }
   let gitDir = installDir;
   for (let i = 0; i < 6; i++) {
-    if (existsSync16(`${gitDir}${sep}.git`)) {
+    if (existsSync18(`${gitDir}${sep}.git`)) {
       return { kind: "local-dev", installDir };
     }
-    const parent = dirname4(gitDir);
+    const parent = dirname5(gitDir);
     if (parent === gitDir)
       break;
     gitDir = parent;
@@ -5459,6 +5845,11 @@ Skill management (mine + share reusable Claude skills across the org):
                                            Options: --user <email>, --users a,b,c,
                                            --all-users, --to <project|global>,
                                            --dry-run, --force.
+  hivemind skilify unpull                  Remove skills previously installed by pull.
+                                           Options: --user, --users, --not-mine,
+                                           --to <project|global>, --dry-run,
+                                           --all (also locally-mined),
+                                           --legacy-cleanup (pre-suffix-author dirs).
   hivemind skilify scope <me|team|org>     Set the sharing scope for newly mined skills.
   hivemind skilify install <project|global>  Set where new skills are written.
   hivemind skilify promote <name>          Move a project skill to the global location.

package/codex/bundle/session-start.js

@@ -140,6 +140,10 @@ SKILLS (skilify) \u2014 mine + share reusable skills across the org:
 - hivemind skilify pull --dry-run          \u2014 preview only
 - hivemind skilify pull --force            \u2014 overwrite local (creates .bak)
 - hivemind skilify pull <skill-name>       \u2014 pull only that skill (combines with --user)
+- hivemind skilify unpull                  \u2014 remove every skill previously installed by pull
+- hivemind skilify unpull --user <email>   \u2014 remove only that author's pulls
+- hivemind skilify unpull --not-mine       \u2014 remove all pulls except your own
+- hivemind skilify unpull --dry-run        \u2014 preview without touching disk
 - hivemind skilify scope <me|team|org>     \u2014 sharing scope for new skills
 - hivemind skilify install <project|global>  \u2014 default install location
 - hivemind skilify team add|remove|list <name>  \u2014 manage team list`;

package/cursor/bundle/session-start.js

@@ -702,6 +702,10 @@ SKILLS (skilify) \u2014 mine + share reusable skills across the org:
 - hivemind skilify pull --dry-run          \u2014 preview only
 - hivemind skilify pull --force            \u2014 overwrite local (creates .bak)
 - hivemind skilify pull <skill-name>       \u2014 pull only that skill (combines with --user)
+- hivemind skilify unpull                  \u2014 remove every skill previously installed by pull
+- hivemind skilify unpull --user <email>   \u2014 remove only that author's pulls
+- hivemind skilify unpull --not-mine       \u2014 remove all pulls except your own
+- hivemind skilify unpull --dry-run        \u2014 preview without touching disk
 - hivemind skilify scope <me|team|org>     \u2014 sharing scope for new skills
 - hivemind skilify install <project|global>  \u2014 default install location
 - hivemind skilify team add|remove|list <name>  \u2014 manage team list`;

package/hermes/bundle/session-start.js

@@ -702,6 +702,10 @@ SKILLS (skilify) \u2014 mine + share reusable skills across the org:
 - hivemind skilify pull --dry-run          \u2014 preview only
 - hivemind skilify pull --force            \u2014 overwrite local (creates .bak)
 - hivemind skilify pull <skill-name>       \u2014 pull only that skill (combines with --user)
+- hivemind skilify unpull                  \u2014 remove every skill previously installed by pull
+- hivemind skilify unpull --user <email>   \u2014 remove only that author's pulls
+- hivemind skilify unpull --not-mine       \u2014 remove all pulls except your own
+- hivemind skilify unpull --dry-run        \u2014 preview without touching disk
 - hivemind skilify scope <me|team|org>     \u2014 sharing scope for new skills
 - hivemind skilify install <project|global>  \u2014 default install location
 - hivemind skilify team add|remove|list <name>  \u2014 manage team list`;

package/openclaw/dist/index.js

@@ -1070,7 +1070,7 @@ function extractLatestVersion(body) {
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 function getInstalledVersion() {
-  return "0.7.14".length > 0 ? "0.7.14" : null;
+  return "0.7.16".length > 0 ? "0.7.16" : null;
 }
 function isNewer(latest, current) {
   const parse = (v) => v.replace(/-.*$/, "").split(".").map(Number);
@@ -1745,7 +1745,7 @@ ${body.slice(0, 500)}`;
         const hook = (event, handler) => {
           pluginApi.on(event, handler);
         };
-        if ('---\nname: hivemind\ndescription: Global team and org memory powered by Activeloop. ALWAYS check BOTH built-in memory AND Hivemind memory when recalling information.\nallowed-tools: hivemind_search, hivemind_read, hivemind_index\n---\n\n# Hivemind Memory\n\nYou have TWO memory sources. ALWAYS check BOTH when the user asks you to recall, remember, or look up ANY information:\n\n1. **Your built-in memory** \u2014 personal per-project notes from the host agent\n2. **Hivemind global memory** \u2014 global memory shared across all sessions, users, and agents in the org, accessed via the tools below\n\n## Memory Structure\n\n```\n/index.md                           \u2190 START HERE \u2014 table of all sessions\n/summaries/\n  <username>/\n    <session-id>.md                 \u2190 AI-generated wiki summary per session\n/sessions/\n  <username>/\n    <user_org_ws_slug>.jsonl        \u2190 raw session data\n```\n\n## How to Search\n\n1. **First**: call `hivemind_index()` \u2014 table of all sessions with dates, projects, descriptions\n2. **If you need details**: call `hivemind_read("/summaries/<username>/<session>.md")`\n3. **If you need raw data**: call `hivemind_read("/sessions/<username>/<file>.jsonl")`\n4. **Keyword search**: call `hivemind_search("keyword")` \u2014 substring search across both summaries and sessions, returns `path:line` hits\n\nDo NOT jump straight to reading raw JSONL files. Always start with `hivemind_index` and summaries.\n\n## Organization Management\n\n- `/hivemind_login` \u2014 sign in via device flow\n- `/hivemind_capture` \u2014 toggle capture on/off (off = no data sent)\n- `/hivemind_whoami` \u2014 show current org and workspace\n- `/hivemind_orgs` \u2014 list organizations\n- `/hivemind_switch_org <name-or-id>` \u2014 switch organization\n- `/hivemind_workspaces` \u2014 list workspaces\n- `/hivemind_switch_workspace <id>` \u2014 switch workspace\n- `/hivemind_version` \u2014 show installed version and check npm for updates\n- `/hivemind_update` \u2014 shows how to install (ask the agent, or run `hivemind update` in your terminal)\n- `/hivemind_autoupdate [on|off]` \u2014 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)\n\n## Skill Management (skilify)\n\nHivemind 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):\n\n- `hivemind skilify` \u2014 show scope/team/install + per-project state\n- `hivemind skilify pull` \u2014 sync skills for the current project from the org table\n- `hivemind skilify pull --user <email>` \u2014 only that author\'s skills\n- `hivemind skilify pull --users a,b,c` \u2014 multiple authors (CSV)\n- `hivemind skilify pull --all-users` \u2014 explicit "no author filter"\n- `hivemind skilify pull --to project|global` \u2014 install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)\n- `hivemind skilify pull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify pull --force` \u2014 overwrite local (creates `.bak`)\n- `hivemind skilify pull <skill-name>` \u2014 pull only that one skill (combines with `--user`)\n- `hivemind skilify scope <me|team|org>` \u2014 set sharing scope for new skills\n- `hivemind skilify install <project|global>` \u2014 default install location\n- `hivemind skilify team add|remove|list <name>` \u2014 manage team list\n\nIf 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.\n\n## Limits\n\nDo NOT delegate to subagents when reading Hivemind memory. If a tool call returns empty after 2 attempts, skip it and move on. Report what you found rather than exhaustively retrying.\n\n## Getting Started\n\nAfter installing the plugin:\n1. Run `/hivemind_login` to authenticate\n2. Run `/hivemind_setup` to enable the memory tools in your openclaw allowlist (one-time, per install)\n3. Start using memory \u2014 ask questions, the agent automatically captures and searches\n\n## Sharing memory\n\nMultiple agents share memory when users are in the same Activeloop organization.\n'.length > 0) {
+        if ('---\nname: hivemind\ndescription: Global team and org memory powered by Activeloop. ALWAYS check BOTH built-in memory AND Hivemind memory when recalling information.\nallowed-tools: hivemind_search, hivemind_read, hivemind_index\n---\n\n# Hivemind Memory\n\nYou have TWO memory sources. ALWAYS check BOTH when the user asks you to recall, remember, or look up ANY information:\n\n1. **Your built-in memory** \u2014 personal per-project notes from the host agent\n2. **Hivemind global memory** \u2014 global memory shared across all sessions, users, and agents in the org, accessed via the tools below\n\n## Memory Structure\n\n```\n/index.md                           \u2190 START HERE \u2014 table of all sessions\n/summaries/\n  <username>/\n    <session-id>.md                 \u2190 AI-generated wiki summary per session\n/sessions/\n  <username>/\n    <user_org_ws_slug>.jsonl        \u2190 raw session data\n```\n\n## How to Search\n\n1. **First**: call `hivemind_index()` \u2014 table of all sessions with dates, projects, descriptions\n2. **If you need details**: call `hivemind_read("/summaries/<username>/<session>.md")`\n3. **If you need raw data**: call `hivemind_read("/sessions/<username>/<file>.jsonl")`\n4. **Keyword search**: call `hivemind_search("keyword")` \u2014 substring search across both summaries and sessions, returns `path:line` hits\n\nDo NOT jump straight to reading raw JSONL files. Always start with `hivemind_index` and summaries.\n\n## Organization Management\n\n- `/hivemind_login` \u2014 sign in via device flow\n- `/hivemind_capture` \u2014 toggle capture on/off (off = no data sent)\n- `/hivemind_whoami` \u2014 show current org and workspace\n- `/hivemind_orgs` \u2014 list organizations\n- `/hivemind_switch_org <name-or-id>` \u2014 switch organization\n- `/hivemind_workspaces` \u2014 list workspaces\n- `/hivemind_switch_workspace <id>` \u2014 switch workspace\n- `/hivemind_version` \u2014 show installed version and check npm for updates\n- `/hivemind_update` \u2014 shows how to install (ask the agent, or run `hivemind update` in your terminal)\n- `/hivemind_autoupdate [on|off]` \u2014 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)\n\n## Skill Management (skilify)\n\nHivemind 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):\n\n- `hivemind skilify` \u2014 show scope/team/install + per-project state\n- `hivemind skilify pull` \u2014 sync skills for the current project from the org table\n- `hivemind skilify pull --user <email>` \u2014 only that author\'s skills\n- `hivemind skilify pull --users a,b,c` \u2014 multiple authors (CSV)\n- `hivemind skilify pull --all-users` \u2014 explicit "no author filter"\n- `hivemind skilify pull --to project|global` \u2014 install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)\n- `hivemind skilify pull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify pull --force` \u2014 overwrite local (creates `.bak`)\n- `hivemind skilify pull <skill-name>` \u2014 pull only that one skill (combines with `--user`)\n- `hivemind skilify unpull` \u2014 remove every skill previously installed by pull\n- `hivemind skilify unpull --user <email>` \u2014 remove only that author\'s pulls\n- `hivemind skilify unpull --not-mine` \u2014 remove all pulls except your own\n- `hivemind skilify unpull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify scope <me|team|org>` \u2014 set sharing scope for new skills\n- `hivemind skilify install <project|global>` \u2014 default install location\n- `hivemind skilify team add|remove|list <name>` \u2014 manage team list\n\nIf 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.\n\n## Limits\n\nDo NOT delegate to subagents when reading Hivemind memory. If a tool call returns empty after 2 attempts, skip it and move on. Report what you found rather than exhaustively retrying.\n\n## Getting Started\n\nAfter installing the plugin:\n1. Run `/hivemind_login` to authenticate\n2. Run `/hivemind_setup` to enable the memory tools in your openclaw allowlist (one-time, per install)\n3. Start using memory \u2014 ask questions, the agent automatically captures and searches\n\n## Sharing memory\n\nMultiple agents share memory when users are in the same Activeloop organization.\n'.length > 0) {
           const setupConfigPromise = loadSetupConfig();
           hook("before_prompt_build", async () => {
             const { detectAllowlistMissing } = await setupConfigPromise;
@@ -1757,7 +1757,7 @@ A newer Hivemind version is available: ${pendingUpdate.current} \u2192 ${pending
 </hivemind-update-available>
 ` : "";
             return {
-              prependSystemContext: allowlistNudge + updateNudge + '\n\n<hivemind-skill>\n---\nname: hivemind\ndescription: Global team and org memory powered by Activeloop. ALWAYS check BOTH built-in memory AND Hivemind memory when recalling information.\nallowed-tools: hivemind_search, hivemind_read, hivemind_index\n---\n\n# Hivemind Memory\n\nYou have TWO memory sources. ALWAYS check BOTH when the user asks you to recall, remember, or look up ANY information:\n\n1. **Your built-in memory** \u2014 personal per-project notes from the host agent\n2. **Hivemind global memory** \u2014 global memory shared across all sessions, users, and agents in the org, accessed via the tools below\n\n## Memory Structure\n\n```\n/index.md                           \u2190 START HERE \u2014 table of all sessions\n/summaries/\n  <username>/\n    <session-id>.md                 \u2190 AI-generated wiki summary per session\n/sessions/\n  <username>/\n    <user_org_ws_slug>.jsonl        \u2190 raw session data\n```\n\n## How to Search\n\n1. **First**: call `hivemind_index()` \u2014 table of all sessions with dates, projects, descriptions\n2. **If you need details**: call `hivemind_read("/summaries/<username>/<session>.md")`\n3. **If you need raw data**: call `hivemind_read("/sessions/<username>/<file>.jsonl")`\n4. **Keyword search**: call `hivemind_search("keyword")` \u2014 substring search across both summaries and sessions, returns `path:line` hits\n\nDo NOT jump straight to reading raw JSONL files. Always start with `hivemind_index` and summaries.\n\n## Organization Management\n\n- `/hivemind_login` \u2014 sign in via device flow\n- `/hivemind_capture` \u2014 toggle capture on/off (off = no data sent)\n- `/hivemind_whoami` \u2014 show current org and workspace\n- `/hivemind_orgs` \u2014 list organizations\n- `/hivemind_switch_org <name-or-id>` \u2014 switch organization\n- `/hivemind_workspaces` \u2014 list workspaces\n- `/hivemind_switch_workspace <id>` \u2014 switch workspace\n- `/hivemind_version` \u2014 show installed version and check npm for updates\n- `/hivemind_update` \u2014 shows how to install (ask the agent, or run `hivemind update` in your terminal)\n- `/hivemind_autoupdate [on|off]` \u2014 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)\n\n## Skill Management (skilify)\n\nHivemind 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):\n\n- `hivemind skilify` \u2014 show scope/team/install + per-project state\n- `hivemind skilify pull` \u2014 sync skills for the current project from the org table\n- `hivemind skilify pull --user <email>` \u2014 only that author\'s skills\n- `hivemind skilify pull --users a,b,c` \u2014 multiple authors (CSV)\n- `hivemind skilify pull --all-users` \u2014 explicit "no author filter"\n- `hivemind skilify pull --to project|global` \u2014 install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)\n- `hivemind skilify pull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify pull --force` \u2014 overwrite local (creates `.bak`)\n- `hivemind skilify pull <skill-name>` \u2014 pull only that one skill (combines with `--user`)\n- `hivemind skilify scope <me|team|org>` \u2014 set sharing scope for new skills\n- `hivemind skilify install <project|global>` \u2014 default install location\n- `hivemind skilify team add|remove|list <name>` \u2014 manage team list\n\nIf 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.\n\n## Limits\n\nDo NOT delegate to subagents when reading Hivemind memory. If a tool call returns empty after 2 attempts, skip it and move on. Report what you found rather than exhaustively retrying.\n\n## Getting Started\n\nAfter installing the plugin:\n1. Run `/hivemind_login` to authenticate\n2. Run `/hivemind_setup` to enable the memory tools in your openclaw allowlist (one-time, per install)\n3. Start using memory \u2014 ask questions, the agent automatically captures and searches\n\n## Sharing memory\n\nMultiple agents share memory when users are in the same Activeloop organization.\n\n</hivemind-skill>\n'
+              prependSystemContext: allowlistNudge + updateNudge + '\n\n<hivemind-skill>\n---\nname: hivemind\ndescription: Global team and org memory powered by Activeloop. ALWAYS check BOTH built-in memory AND Hivemind memory when recalling information.\nallowed-tools: hivemind_search, hivemind_read, hivemind_index\n---\n\n# Hivemind Memory\n\nYou have TWO memory sources. ALWAYS check BOTH when the user asks you to recall, remember, or look up ANY information:\n\n1. **Your built-in memory** \u2014 personal per-project notes from the host agent\n2. **Hivemind global memory** \u2014 global memory shared across all sessions, users, and agents in the org, accessed via the tools below\n\n## Memory Structure\n\n```\n/index.md                           \u2190 START HERE \u2014 table of all sessions\n/summaries/\n  <username>/\n    <session-id>.md                 \u2190 AI-generated wiki summary per session\n/sessions/\n  <username>/\n    <user_org_ws_slug>.jsonl        \u2190 raw session data\n```\n\n## How to Search\n\n1. **First**: call `hivemind_index()` \u2014 table of all sessions with dates, projects, descriptions\n2. **If you need details**: call `hivemind_read("/summaries/<username>/<session>.md")`\n3. **If you need raw data**: call `hivemind_read("/sessions/<username>/<file>.jsonl")`\n4. **Keyword search**: call `hivemind_search("keyword")` \u2014 substring search across both summaries and sessions, returns `path:line` hits\n\nDo NOT jump straight to reading raw JSONL files. Always start with `hivemind_index` and summaries.\n\n## Organization Management\n\n- `/hivemind_login` \u2014 sign in via device flow\n- `/hivemind_capture` \u2014 toggle capture on/off (off = no data sent)\n- `/hivemind_whoami` \u2014 show current org and workspace\n- `/hivemind_orgs` \u2014 list organizations\n- `/hivemind_switch_org <name-or-id>` \u2014 switch organization\n- `/hivemind_workspaces` \u2014 list workspaces\n- `/hivemind_switch_workspace <id>` \u2014 switch workspace\n- `/hivemind_version` \u2014 show installed version and check npm for updates\n- `/hivemind_update` \u2014 shows how to install (ask the agent, or run `hivemind update` in your terminal)\n- `/hivemind_autoupdate [on|off]` \u2014 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)\n\n## Skill Management (skilify)\n\nHivemind 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):\n\n- `hivemind skilify` \u2014 show scope/team/install + per-project state\n- `hivemind skilify pull` \u2014 sync skills for the current project from the org table\n- `hivemind skilify pull --user <email>` \u2014 only that author\'s skills\n- `hivemind skilify pull --users a,b,c` \u2014 multiple authors (CSV)\n- `hivemind skilify pull --all-users` \u2014 explicit "no author filter"\n- `hivemind skilify pull --to project|global` \u2014 install location (`<cwd>/.claude/skills/` vs `~/.claude/skills/`)\n- `hivemind skilify pull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify pull --force` \u2014 overwrite local (creates `.bak`)\n- `hivemind skilify pull <skill-name>` \u2014 pull only that one skill (combines with `--user`)\n- `hivemind skilify unpull` \u2014 remove every skill previously installed by pull\n- `hivemind skilify unpull --user <email>` \u2014 remove only that author\'s pulls\n- `hivemind skilify unpull --not-mine` \u2014 remove all pulls except your own\n- `hivemind skilify unpull --dry-run` \u2014 preview without touching disk\n- `hivemind skilify scope <me|team|org>` \u2014 set sharing scope for new skills\n- `hivemind skilify install <project|global>` \u2014 default install location\n- `hivemind skilify team add|remove|list <name>` \u2014 manage team list\n\nIf 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.\n\n## Limits\n\nDo NOT delegate to subagents when reading Hivemind memory. If a tool call returns empty after 2 attempts, skip it and move on. Report what you found rather than exhaustively retrying.\n\n## Getting Started\n\nAfter installing the plugin:\n1. Run `/hivemind_login` to authenticate\n2. Run `/hivemind_setup` to enable the memory tools in your openclaw allowlist (one-time, per install)\n3. Start using memory \u2014 ask questions, the agent automatically captures and searches\n\n## Sharing memory\n\nMultiple agents share memory when users are in the same Activeloop organization.\n\n</hivemind-skill>\n'
             };
           });
         }

package/openclaw/openclaw.plugin.json

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

package/openclaw/package.json

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

package/openclaw/skills/SKILL.md

@@ -58,6 +58,10 @@ Hivemind also mines reusable Claude skills from agent sessions and stores them i
 - `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

package/package.json

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

package/pi/extension-source/hivemind.ts

@@ -666,6 +666,10 @@ SKILLS (skilify) — mine + share reusable skills across the org. Run these in a
 - 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`;