@monoes/monomindcli 2.10.9 → 2.10.13

package/.claude/commands/mastermind/brain.md

@@ -1,4 +1,4 @@
-<!-- Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (LanceDB + Monograph) -->
+<!-- Mastermind brain management — inspect, compact, refresh, and control the three-tier business memory (memory store + Monograph) -->
 
 **First — extract repeat flags:** Follow the REPEAT PREAMBLE from `mastermind-repeat/SKILL.md`. Extracts `--repeat`, `--tillend`, `--maxruns`, `--wait`, `--rep`, `--loop` from `$ARGUMENTS` before all other parsing.
 
@@ -11,9 +11,9 @@ Parse `$ARGUMENTS` to determine the sub-command and flags.
 Show the current state of all brain tiers across all domains.
 
 For each domain that has data, call:
-- `mcp__monomind__lancedb_health` on namespace `mastermind:<domain>:raw` → Tier 1 entry count, last write date, archived count
-- `mcp__monomind__lancedb_health` on namespace `mastermind:<domain>:weekly` → Tier 2 summary count, last compaction date
-- `mcp__monomind__lancedb_health` on namespace `mastermind:principles` → Tier 3 principle count
+- `mcp__monomind__memory_health` on namespace `mastermind:<domain>:raw` → Tier 1 entry count, last write date, archived count
+- `mcp__monomind__memory_health` on namespace `mastermind:<domain>:weekly` → Tier 2 summary count, last compaction date
+- `mcp__monomind__memory_health` on namespace `mastermind:principles` → Tier 3 principle count
 
 Display as a table:
 
@@ -39,9 +39,9 @@ Avg memory score: 0.64 | Entries below archive threshold: 3
 Force immediate weekly distillation across all domains (or `--domain <name>` for one domain).
 
 For each domain (or the specified domain):
-1. Retrieve all Tier 1 raw entries since last compaction via `mcp__monomind__lancedb_hierarchical-recall` (namespace `mastermind:<domain>:raw`)
+1. Retrieve all Tier 1 raw entries since last compaction via `mcp__monomind__memory_hierarchical-recall` (namespace `mastermind:<domain>:raw`)
 2. Produce per-domain weekly summary: synthesize decisions, patterns, and lessons into ≤300 words
-3. Store to Tier 2 via `mcp__monomind__lancedb_hierarchical-store` (namespace `mastermind:<domain>:weekly`)
+3. Store to Tier 2 via `mcp__monomind__memory_hierarchical-store` (namespace `mastermind:<domain>:weekly`)
 4. Archive Tier 1 entries with score < 0.1 (update metadata: `{ archived: true }`)
 5. Report: "Compacted <domain>: <N> entries → <M> summary, <K> archived"
 
@@ -53,8 +53,8 @@ Re-cluster the knowledge graph for a specific domain and rebuild Tier 3 principl
 
 1. Call `mcp__monomind__monograph_community` for nodes matching `mastermind:<domain>`
 2. For any cluster of 3+ similar nodes: merge into a single principle (LLM synthesis)
-3. Store merged principle: `mcp__monomind__lancedb_hierarchical-store` namespace `mastermind:principles`
-4. For conflicting nodes: add `EXCEPTION` edge via `mcp__monomind__monograph_add_fact`
+3. Store merged principle: `mcp__monomind__memory_hierarchical-store` namespace `mastermind:principles`
+4. For conflicting nodes: add the exception relation via `mcp__monomind__memory_kg_ingest`
 5. Report: "Refreshed <domain>: <N> clusters found, <M> principles updated, <K> exceptions noted"
 
 ---
@@ -63,9 +63,9 @@ Re-cluster the knowledge graph for a specific domain and rebuild Tier 3 principl
 
 Show raw contents of a specific brain tier.
 
-- Tier 1: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:<domain>:raw`, display each entry with its score and date.
-- Tier 2: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:<domain>:weekly`, display summaries with dates.
-- Tier 3: Call `mcp__monomind__lancedb_hierarchical-recall` on `mastermind:principles`, display all principles.
+- Tier 1: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:<domain>:raw`, display each entry with its score and date.
+- Tier 2: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:<domain>:weekly`, display summaries with dates.
+- Tier 3: Call `mcp__monomind__memory_hierarchical-recall` on `mastermind:principles`, display all principles.
 
 Default limit: 10. Use `--limit N` to override.
 
@@ -75,7 +75,7 @@ Default limit: 10. Use `--limit N` to override.
 
 Find and archive all brain entries semantically matching the query.
 
-1. Call `mcp__monomind__lancedb_pattern-search` with query text across all mastermind namespaces
+1. Call `mcp__monomind__memory_pattern-search` with query text across all mastermind namespaces
 2. Display matching entries with their scores and domains
 3. Ask: "Archive these N entries? (yes/no)"
 4. If yes: update each entry's metadata to `{ archived: true }`
@@ -88,8 +88,8 @@ Find and archive all brain entries semantically matching the query.
 **Destructive.** Wipes all brain data for a specific domain. Requires `--confirm` flag explicitly — refuse if missing.
 
 If `--confirm` is present:
-1. Delete all Tier 1 entries: `mcp__monomind__memory_delete` on namespace `mastermind:<domain>:raw`
-2. Delete all Tier 2 entries: `mcp__monomind__memory_delete` on namespace `mastermind:<domain>:weekly`
+1. Delete all Tier 1 entries: `npx monomind@latest memory delete --namespace mastermind:<domain>:raw`
+2. Delete all Tier 2 entries: `npx monomind@latest memory delete --namespace mastermind:<domain>:weekly`
 3. Remove domain nodes from Monograph graph
 4. Report: "Reset complete for domain <name>. All memory wiped."
 

package/.claude/commands/mastermind/help.md

@@ -119,8 +119,8 @@ mcp__monomind__monograph_suggest({ task: "..." })
 mcp__monomind__monograph_query({ query: "..." })
 
 // Swarm
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
-mcp__monomind__swarm_status({})
+mcp__monomind__monoswarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__monoswarm_status({})
 
 // System
 mcp__monomind__system_health({})

package/.claude/commands/mastermind/master.md

@@ -91,19 +91,19 @@ digraph mastermind_routing {
 | Situation | Skill to invoke |
 |---|---|
 | Debug a bug, test failure, unexpected behavior | `Skill("mastermind-debug")` |
-| Verify a claim — tests pass, feature works, fix resolved | `Skill("mastermind-verify")` |
-| Write tests first, enforce Red-Green-Refactor | `Skill("mastermind-tdd")` |
+| Verify a claim — tests pass, feature works, fix resolved | `Skill("mastermind-review")` |
+| Write tests first, enforce Red-Green-Refactor | `Skill("mastermind-debug")` (Phase 4 covers the failing-test-first loop) |
 | Write a structured implementation plan (no placeholders) | `Skill("mastermind-plan")` |
 | Execute a written plan step-by-step with stop-on-blocker | `Skill("mastermind-execute")` |
-| Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind-taskdev")` |
-| Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-taskdev")` for plan-driven parallel work |
+| Execute a plan via fresh subagents with 2-stage review | `Skill("mastermind-execute")` |
+| Fix or investigate 2+ independent problems concurrently (different files, subsystems, or bugs) | dispatch parallel subagents in one message — one per independent domain; use `Skill("mastermind-execute")` for plan-driven parallel work |
 | Ingest a prompt/spec/folder and generate agent-optimized tasks | `Skill("mastermind-createtask")` |
 | Execute tasks from a task file or monotask board (parallel/sequential/minimal modes, review cycles, loop) | `Skill("mastermind-do")` |
 | Design first — spec, approaches, approval gate before code | `Skill("mastermind-design")` |
-| Build a feature, fix a bug, implement anything | `Skill("mastermind-build")` |
+| Build a feature, fix a bug, implement anything | `Skill("mastermind-plan")` then `Skill("mastermind-execute")` |
 | Code review, content critique, strategy audit | `Skill("mastermind-review")` |
 | Receive a code review and apply it correctly | `Skill("mastermind-receive-review")` |
-| System architecture, DDD, technical design | `Skill("mastermind-architect")` |
+| System architecture, DDD, technical design | `Skill("mastermind-design")` |
 | Market research, competitive analysis, user insights | `Skill("mastermind-research")` |
 | Ideas, feature generation, opportunity framing | `Skill("mastermind-idea")` |
 | Research ideas, evaluate with PM lens, decompose into subtasks | `Skill("mastermind-ideate")` |
@@ -112,14 +112,13 @@ digraph mastermind_routing {
 | Sales outreach, proposals, pipeline | `Skill("mastermind-sales")` |
 | Blog, docs, newsletters, threads | `Skill("mastermind-content")` |
 | Versioning, changelogs, deployment | `Skill("mastermind-release")` |
-| Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind-finish")` |
+| Finish a branch — tests, options menu, merge/PR/discard | `Skill("mastermind-review")` |
 | Workflow, process, reporting | `Skill("mastermind-ops")` |
 | Invoicing, forecasting, cost | `Skill("mastermind-finance")` |
 | Inspect or manage brain memory | `Skill("mastermind-brain")` |
 | Technical portfolio, project state assessment | `Skill("mastermind-techport")` |
 | Define/run an agent organization | `Skill("mastermind-createorg")` / `Skill("mastermind-runorg")` |
-| Review and action pending agent approval requests | `Skill("mastermind-approvev1")` (v1 orgs only — v2 approvals arrive in the dashboard Human Input tab) |
-| Autonomous build + review until clean | `Skill("mastermind-autodev")` |
+| Autonomous build + review until clean | `Skill("mastermind-execute")` |
 | Isolate work in a git worktree | `Skill("mastermind-worktree")` |
 | Write or improve a mastermind skill | `Skill("mastermind-skill-builder")` |
 
@@ -182,7 +181,7 @@ These sequences are non-negotiable in all modes:
 - **When fixing bugs**: `mastermind:debug` first (root cause) → write failing test via `mastermind:tdd` → fix → `mastermind:verify`
 - **After building**: `mastermind:review` — at minimum one pass before reporting complete
 - **Consuming a review**: `mastermind:receive-review` — verify before implementing, clarify unclear items first
-- **After any run**: Brain Write Procedure — score decisions, append to LanceDB
+- **After any run**: Brain Write Procedure — score decisions, append to the memory store
 - **Before releasing**: `mastermind:review --tillend --auto` → `mastermind:verify` → `mastermind:finish`
 - **Isolated work**: `mastermind:worktree` before making changes to avoid contaminating main
 - **Before claiming complete**: Run `mastermind:verify` — never claim completion based on agent reports, linter passes, or partial checks
@@ -292,8 +291,8 @@ project_name="${project_name:-$(basename "$PWD")}"
 
 Follow the Brain Load Procedure from `mastermind-protocol/SKILL.md`:
 
-1. Call `mcp__monomind__lancedb_hierarchical-recall` namespace `mastermind:principles` (limit 20)
-2. For each domain that appears relevant to the prompt, call `mcp__monomind__lancedb_context-synthesize` namespace `mastermind:<domain>:weekly`
+1. Call `mcp__monomind__memory_hierarchical-recall` namespace `mastermind:principles` (limit 20)
+2. For each domain that appears relevant to the prompt, call `mcp__monomind__memory_context-synthesize` namespace `mastermind:<domain>:weekly`
 3. Call `mcp__monomind__monograph_query` with 3-5 keywords from the prompt
 
 Assemble the BRAIN CONTEXT block from results.
@@ -658,9 +657,15 @@ pick_domain_manager() {
        | {name: .name,
           score: (
             (.name | ascii_downcase) as $n |
-            # Score on ANY keyword match, not just the first
+            (.description // "" | ascii_downcase) as $desc |
+            # Score keyword matches against both name (weight 2) and description (weight 1) —
+            # name match is a stronger signal. Bind each word to $w before contains(): piping
+            # into contains(.) rebinds "." to the piped value, which would silently match everything.
             (if ($kw | length) > 0
-             then ([$kw | split(" ")[] | select(length > 0) | if ($n | contains(.)) then 1 else 0 end] | add // 0)
+             then ([$kw | split(" ")[] | select(length > 0) | . as $w |
+                    (if ($n | contains($w)) then 2 else 0 end) +
+                    (if ($desc | contains($w)) then 1 else 0 end)
+                   ] | add // 0)
              else 0 end) +
             (if $n | test("manager|director|coordinator") then 1 else 0 end)
           )}
@@ -761,7 +766,7 @@ Each Task call must include a complete briefing following the Monotask Task Brie
 - Instruction to create monotask cards directly using `monotask card create $BOARD_ID $COL_TODO_ID "<title>" --json` for all sub-tasks
 - Instruction to use `Skill("mastermind-do")` to execute tasks (Task agents have Skill tool access — do NOT use slash command syntax)
 - Instruction to spawn specialized agents using the domain-appropriate swarm topology
-- **For the `build` domain only:** include `build_exec_mode` (value: `"taskdev"` or `"execute"`) and instruct the manager: "Use `Skill("mastermind-taskdev")` if build_exec_mode is `taskdev`, or `Skill("mastermind-execute")` if `execute`. This was resolved in the Step 3.6 Plan Gate (or Step 5)." If `build_plan` is set in `current.json`, include the plan path and instruct the manager to execute THAT plan task-by-task rather than re-deriving tasks from the goal.
+- **For the `build` domain only:** instruct the manager: "Use `Skill("mastermind-execute")`. This was resolved in the Step 3.6 Plan Gate (or Step 5)." If `build_plan` is set in `current.json`, include the plan path and instruct the manager to execute THAT plan task-by-task rather than re-deriving tasks from the goal.
 - Instruction to return the unified output schema when done
 
 Example Task call for Development Manager. Substitute all **pre-known** `<…>` placeholders (project_name, SESSION_ID, board/col IDs, goals, manager name) before calling Task. Placeholders like `<status>`, `<path1>`, `<action1>` are filled at runtime by the spawned agent — do not attempt to substitute them. `subagent_type` is the **string value** of `$domain_manager_build` (e.g. `"Backend Architect"`), not a variable reference.
@@ -931,7 +936,7 @@ Monotask boards:
 
 Follow the Brain Write Procedure from `mastermind-protocol/SKILL.md` for each domain that ran:
 1. Score all decisions from this run
-2. Append to Tier 1 raw log (LanceDB)
+2. Append to Tier 1 raw log (the memory store)
 3. Check and trigger weekly compaction if threshold met
 4. Check and trigger graph consolidation if cluster detected
 
@@ -1085,11 +1090,11 @@ Log this as a decision in the cycle's output schema with `confidence` set accord
 
 Execute the chosen activity by invoking the appropriate domain skill via the `Skill` tool (Steps 4–10 of the main flow, condensed). Use `Skill("mastermind-<domain>")` — do NOT use slash command syntax (`/<name>`), which only works when typed interactively in the Claude Code CLI, not within an executing command or skill:
 
-- Test → `Skill("mastermind-tdd")` with the untested artifacts as prompt (enforce Red-Green-Refactor)
+- Test → `Skill("mastermind-debug")` Phase 4 with the untested artifacts as prompt (write the failing test first, enforce Red-Green-Refactor)
 - Debug/Fix → `Skill("mastermind-debug")` with the failing test or error as prompt (root-cause first, then fix)
 - Review → `Skill("mastermind-review")` with scope = artifacts from last run
-- Improve/Refactor → `Skill("mastermind-build")` with refactor prompt
-- Add feature → `Skill("mastermind-build")` with the next feature from the `next_actions` array printed by the Step 12a output above
+- Improve/Refactor → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with refactor prompt
+- Add feature → `Skill("mastermind-plan")` then `Skill("mastermind-execute")` with the next feature from the `next_actions` array printed by the Step 12a output above
 - Research → `Skill("mastermind-research")` with the open question as prompt
 - Content/Docs → `Skill("mastermind-content")` with scope = new artifacts
 - Release → `Skill("mastermind-release")` with project scope

package/.claude/commands/mastermind/memory.md

@@ -193,17 +193,17 @@ mcp__monomind__memory_pattern-store({ key: "pattern/auth", value: "JWT + refresh
 // Search
 mcp__monomind__memory_pattern-search({ query: "authentication", namespace: "patterns" })
 
-// Retrieve
-mcp__monomind__memory_retrieve({ key: "pattern/auth", namespace: "patterns" })
+// Retrieve (CLI only — no MCP tool)
+// npx monomind@latest memory retrieve --key "pattern/auth" --namespace patterns
 
-// List
-mcp__monomind__memory_list({ namespace: "patterns" })
+// List (CLI only — no MCP tool)
+// npx monomind@latest memory list --namespace patterns
 
-// Delete
-mcp__monomind__memory_delete({ key: "pattern/auth", namespace: "patterns" })
+// Delete (CLI only — no MCP tool)
+// npx monomind@latest memory delete --key "pattern/auth" --namespace patterns
 
-// Stats
-mcp__monomind__memory_stats({})
+// Stats (CLI only — no MCP tool)
+// npx monomind@latest memory stats
 ```
 
 ## Common Workflows

package/.claude/commands/mastermind/monoswarm.md

@@ -113,16 +113,16 @@ npx monomind monoswarm scale swarm-abc123 --agents 8 --type coder
 
 ```javascript
 // Initialize swarm
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+mcp__monomind__monoswarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
 
 // Check status
-mcp__monomind__swarm_status({})
+mcp__monomind__monoswarm_status({})
 
 // Health check
-mcp__monomind__swarm_health({})
+mcp__monomind__monoswarm_health({})
 
 // Shutdown swarm
-mcp__monomind__swarm_shutdown({})
+mcp__monomind__monoswarm_shutdown({})
 ```
 
 ## Agent Team Routing

package/.claude/commands/mastermind.md

@@ -47,14 +47,14 @@ Match the intent against this catalog. Pick ONE primary route, plus supporting s
 | Intent | Primary route |
 |---|---|
 | Fix a bug, test failure, unexpected behavior | `Skill("mastermind-debug")` → root cause first, then fix |
-| Build a feature / implement anything | `Skill("mastermind-design")` → spec, then `Skill("mastermind-build")` |
-| Plan before coding | `Skill("mastermind-plan")` (write) / `Skill("mastermind-execute")` or `Skill("mastermind-taskdev")` (run) |
-| TDD workflow | `Skill("mastermind-tdd")` |
-| Refactor / architecture / DDD / dedup | `Skill("mastermind-architect")` |
+| Build a feature / implement anything | `Skill("mastermind-design")` → spec, then `Skill("mastermind-plan")` → `Skill("mastermind-execute")` |
+| Plan before coding | `Skill("mastermind-plan")` (write) / `Skill("mastermind-execute")` (run) |
+| TDD workflow | `Skill("mastermind-debug")` (Phase 4 covers the failing-test-first loop) |
+| Refactor / architecture / DDD / dedup | `Skill("mastermind-design")` |
 | Code review, audit quality | `Skill("mastermind-review")`; apply one received: `Skill("mastermind-receive-review")` |
-| Verify a claim ("it works", "tests pass") | `Skill("mastermind-verify")` |
-| Autonomous improve-loop | `Skill("mastermind-autodev")` (`--tillend` for until-clean) |
-| Finish/merge/PR a branch | `Skill("mastermind-finish")`; release/versioning: `Skill("mastermind-release")` |
+| Verify a claim ("it works", "tests pass") | `Skill("mastermind-review")` |
+| Autonomous improve-loop | `Skill("mastermind-execute")`, re-invoking `Skill("mastermind-review")` between passes until clean |
+| Finish/merge/PR a branch | `Skill("mastermind-review")`; release/versioning: `Skill("mastermind-release")` |
 | Isolate risky work | `Skill("mastermind-worktree")` |
 | Spec → agent task file/board | `Skill("mastermind-createtask")`, execute with `Skill("mastermind-do")` |
 

package/.claude/commands/truth/start.md

@@ -74,8 +74,8 @@ mcp__monomind__hooks_intelligence_stats({})
 mcp__monomind__task_summary({})
 mcp__monomind__progress_summary({})
 
-// LanceDB health (memory integrity)
-mcp__monomind__lancedb_health({})
+// Memory store health (memory integrity)
+mcp__monomind__memory_health({})
 ```
 
 ### Performance
@@ -105,7 +105,7 @@ When invoked, run these checks in parallel:
 mcp__monomind__system_health({})
 mcp__monomind__agent_health({})
 mcp__monomind__neural_status({ verbose: true })
-mcp__monomind__lancedb_health({})
+mcp__monomind__memory_health({})
 mcp__monomind__performance_report({ format: "detailed" })
 ```
 

package/.claude/settings.json

@@ -326,10 +326,6 @@
       }
     ]
   },
-  "attribution": {
-    "commit": "Co-Authored-By: nokhodian <nokhodian@gmail.com>",
-    "pr": "\ud83e\udd16 Generated with [monomind](https://github.com/monoes/monomind)"
-  },
   "monomind": {
     "version": "3.5.2",
     "enabled": true,

package/.claude/skills/mastermind/SKILL.md

@@ -7,30 +7,21 @@ description: Use when a request may need a Mastermind workflow such as planning,
 
 Load only the workflow that matches the request:
 
+- `mastermind-idea` to shape a raw prompt into a stated problem and options.
+- `mastermind-design` before building a feature — this is a gate, not a suggestion.
 - `mastermind-plan` before multi-file implementation.
+- `mastermind-execute` for a written plan.
 - `mastermind-review` for audits and critiques.
 - `mastermind-debug` for failures or unexpected behavior.
 - `mastermind-research` for open questions.
-- `mastermind-execute` for a written plan.
 - `mastermind-org` for organization lifecycle work.
 - `mastermind-memory` for persistent knowledge.
 
+**For build/feature work, the gates are mandatory and ordered:** idea → design → plan →
+execute → review. The full routing table for the other 20+ Mastermind workflows lives in
+`.claude/commands/mastermind-master.md`; consult it before concluding that no workflow applies.
+
 Use Monograph before broad repository search when the platform exposes the
 Monomind MCP server. Without native skills, run
 `monomind mastermind run <skill> --print` and follow the printed procedure.
 Platform tool mappings are in [references/](references/).
-# monomind:start skills:claude:mastermind
-# Mastermind
-
-Load only the workflow that matches the current task:
-- `mastermind` — Route a request to the relevant Mastermind workflow.
-- `mastermind-plan` — Write a detailed implementation plan before changing code.
-- `mastermind-review` — Review code, content, strategy, or security work.
-- `mastermind-debug` — Investigate a failure or unexpected behavior before fixing it.
-- `mastermind-research` — Research an open question before making a decision.
-- `mastermind-execute` — Execute a written implementation plan step by step.
-- `mastermind-org` — Create, run, inspect, and manage a Mastermind organization.
-- `mastermind-memory` — Store, retrieve, and maintain persistent organization knowledge.
-
-If skills cannot be loaded natively, run `monomind mastermind run <skill> --print`.
-# monomind:end skills:claude:mastermind

package/.claude/skills/mastermind/references/antigravity-tools.md

@@ -58,65 +58,3 @@ Put multiple entries in a single `invoke_subagent` call's `Subagents` array to r
 Antigravity has **no todo / `TodoWrite` tool** (`manage_task` manages background processes — it is *not* a checklist). When a skill says to create a todo list or track tasks, maintain a **task artifact**: a markdown checklist saved with `write_to_file` (`IsArtifact: true`, `ArtifactMetadata.ArtifactType: "task"`), edited with `replace_file_content` / `multi_replace_file_content` as you go.
 
 At the start of any multi-step task, create the task artifact listing every step of your plan. As you complete each step, edit the artifact to mark it done (`- [x]`). If the plan changes, update the checklist. Keep it current — it is your source of truth for what remains; once the conversation gets long, re-read it before starting each step.
-# monomind:start skills:claude:mastermind:references/antigravity-tools.md
-# Antigravity CLI (`agy`) Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On the Antigravity CLI (`agy`) these resolve to the tools below.
-
-| Action skills request | Antigravity CLI equivalent |
-|----------------------|----------------------|
-| Read a file | `view_file` |
-| Create a new file | `write_to_file` |
-| Edit a file | `replace_file_content` |
-| Edit a file in several places at once | `multi_replace_file_content` |
-| Run a shell command | `run_command` |
-| Search file contents | `grep_search` |
-| Find files by name / list a directory | `list_dir` (no dedicated glob tool — combine `list_dir` with `grep_search`) |
-| Fetch a URL | `read_url_content` |
-| Search the web | `search_web` |
-| Pose a structured question to your human partner | `ask_question` |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | `invoke_subagent` with a built-in `TypeName` — `self` for full-capability work, `research` for read-only (see [Subagent support](#subagent-support)) |
-| Multiple parallel dispatches | Multiple entries in one `invoke_subagent` call's `Subagents` array |
-| Task tracking ("create a todo", "mark complete") | a **task artifact** — `write_to_file` with `IsArtifact: true` and `ArtifactType: "task"` (see [Task tracking](#task-tracking)). **Not** `manage_task`, which manages background processes. |
-
-## Invoking a skill — read its `SKILL.md`
-
-Antigravity surfaces every installed skill's `name` + `description` to you at the start of each session, but it has **no `Skill`/`activate_skill` tool**. To load a skill, **read its `SKILL.md` with `view_file`, setting `IsSkillFile: true`** when the skill applies — e.g. `view_file` on `.../mastermind/skills/<skill-name>/SKILL.md` with `IsSkillFile: true`.
-
-(`IsSkillFile` is agy's own signal that you're reading a file to *execute its instructions*, not to edit or preview it — set it whenever you load a skill.)
-
-This is the blessed skill-loading mechanism on this harness. The general rule "never read skill files manually" means "don't bypass your platform's skill-loading mechanism" — and on Antigravity, reading `SKILL.md` *is* that mechanism. Reading it honors the rule rather than breaking it.
-
-You already know which skills exist and what they're for: their names and descriptions are in front of you at session start. When a description matches what you're about to do, read that skill's `SKILL.md` before acting.
-
-## Subagent support
-
-Antigravity dispatches subagents with `invoke_subagent`, passing each one a `TypeName` in the `Subagents` array. Two `TypeName`s are **built in** — use them directly, no `define_subagent` needed:
-
-- **`self`** — a full clone of you, with every tool you have (including `write_to_file`/`replace_file_content`/`run_command`). The safe default for general-purpose work: implementing, fixing, anything that edits files or runs commands.
-- **`research`** — read-only (file reading, `grep_search`, web/URL fetch; no write or command access). Use it when you specifically want a subagent that can't make changes — investigation and read-only review.
-
-Call `define_subagent` only for a custom system prompt or capability mix: set `enable_write_tools: true` to grant file edits **and** `run_command`, `enable_subagent_tools` for nested dispatch, `enable_mcp_tools` for MCP. Then invoke it by the name you gave it.
-
-Skills dispatch with `Subagent (general-purpose):` and either reference a prompt-template file or supply an inline prompt. On Antigravity:
-
-| Skill dispatch form | Antigravity equivalent |
-|---------------------|----------------------|
-| An implementer-style template (writes code, runs tests) | Fill the template, then `invoke_subagent` with `TypeName: "self"` and the filled prompt |
-| A read-only reviewer template (`mastermind:review`) | `invoke_subagent` with `TypeName: "research"` and the filled review template |
-| Inline prompt (no template referenced) | `invoke_subagent` with `TypeName: "self"` (or `"research"` if the task only reads) and your inline prompt |
-
-### Prompt filling
-
-Skills provide prompt templates with placeholders like `{WHAT_WAS_IMPLEMENTED}` or `[FULL TEXT of task]`. Fill all placeholders before passing the complete prompt to `invoke_subagent`. The prompt template itself contains the agent's role, review criteria, and expected output format — the subagent will follow it.
-
-### Parallel dispatch
-
-Put multiple entries in a single `invoke_subagent` call's `Subagents` array to run independent subagent work in parallel. Keep dependent tasks sequential, but do not serialize independent subagent tasks just to preserve a simpler history.
-
-## Task tracking
-
-Antigravity has **no todo / `TodoWrite` tool** (`manage_task` manages background processes — it is *not* a checklist). When a skill says to create a todo list or track tasks, maintain a **task artifact**: a markdown checklist saved with `write_to_file` (`IsArtifact: true`, `ArtifactMetadata.ArtifactType: "task"`), edited with `replace_file_content` / `multi_replace_file_content` as you go.
-
-At the start of any multi-step task, create the task artifact listing every step of your plan. As you complete each step, edit the artifact to mark it done (`- [x]`). If the plan changes, update the checklist. Keep it current — it is your source of truth for what remains; once the conversation gets long, re-read it before starting each step.
-# monomind:end skills:claude:mastermind:references/antigravity-tools.md

package/.claude/skills/mastermind/references/claude-code-tools.md

@@ -48,55 +48,3 @@ For path-scoped rules and larger-project organization, see `.claude/rules/` (rul
 ## Personal skills directory
 
 User-level skills live at **`~/.claude/skills/`**. Each skill is a subdirectory containing a `SKILL.md` (with `name` and `description` frontmatter) plus any supporting files. Claude Code does not currently recognize the cross-runtime `~/.agents/skills/` path that Codex, Copilot CLI, and Gemini CLI read; if you're relying on cross-runtime support in the future, verify against the official skills docs.
-# monomind:start skills:claude:mastermind:references/claude-code-tools.md
-# Claude Code Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Claude Code these resolve to the tools below.
-
-## Tools
-
-| Action skills request | Claude Code tool |
-|----------------------|------------------|
-| Read a file | `Read` |
-| Create a new file | `Write` |
-| Edit a file | `Edit` |
-| Run a shell command | `Bash` |
-| Search file contents | `Grep` |
-| Find files by name | `Glob` |
-| Fetch a URL | `WebFetch` |
-| Search the web | `WebSearch` |
-| Invoke a skill | `Skill` |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | `Agent` (older releases named this `Task`) |
-| Multiple parallel dispatches | Multiple `Agent` calls in one response |
-| Task tracking ("create a todo", "mark complete") | `TaskCreate`, `TaskUpdate`, `TaskList`, `TaskGet`; `TodoWrite` in `claude -p` / Agent SDK unless `CLAUDE_CODE_ENABLE_TASKS=1` is set |
-| Background-process / subagent lifecycle (read output, cancel) | `TaskOutput`, `TaskStop` — these are distinct from the todo tools above and apply to running shells, agents, and remote sessions |
-
-## Instructions file
-
-When a skill mentions "your instructions file", on Claude Code this is **`CLAUDE.md`**. Claude Code walks up the directory tree from the current working directory and concatenates every `CLAUDE.md` and `CLAUDE.local.md` it finds along the way. Standard locations:
-
-| Scope | Location |
-|-------|----------|
-| Project (team-shared) | `./CLAUDE.md` or `./.claude/CLAUDE.md` |
-| User global | `~/.claude/CLAUDE.md` |
-| Local-private (gitignored) | `./CLAUDE.local.md` |
-| Managed policy (org-wide) | `/Library/Application Support/ClaudeCode/CLAUDE.md` (macOS), `/etc/claude-code/CLAUDE.md` (Linux/WSL), `C:\Program Files\ClaudeCode\CLAUDE.md` (Windows) |
-
-CLAUDE.md files can pull in additional content with `@path/to/file` imports (relative or absolute, max five hops deep). Subdirectory `CLAUDE.md` files are also discovered automatically and loaded on-demand when Claude Code reads files in those subdirectories.
-
-Claude Code does **not** read `AGENTS.md` directly. If a project already maintains `AGENTS.md` for other agents, import it from `CLAUDE.md` so both runtimes share the same instructions:
-
-```markdown
-@AGENTS.md
-
-## Claude Code
-
-(Claude-Code-specific instructions go here.)
-```
-
-For path-scoped rules and larger-project organization, see `.claude/rules/` (rules can be scoped to specific files via `paths` frontmatter and load on demand).
-
-## Personal skills directory
-
-User-level skills live at **`~/.claude/skills/`**. Each skill is a subdirectory containing a `SKILL.md` (with `name` and `description` frontmatter) plus any supporting files. Claude Code does not currently recognize the cross-runtime `~/.agents/skills/` path that Codex, Copilot CLI, and Gemini CLI read; if you're relying on cross-runtime support in the future, verify against the official skills docs.
-# monomind:end skills:claude:mastermind:references/claude-code-tools.md

package/.claude/skills/mastermind/references/codex-tools.md

@@ -62,69 +62,3 @@ When the sandbox blocks branch/push operations (detached HEAD in an externally m
 - **"Hand off to local"** — transfers work to the user's local checkout
 
 The agent can still run tests, stage files, and output suggested branch names, commit messages, and PR descriptions for the user to copy.
-# monomind:start skills:claude:mastermind:references/codex-tools.md
-# Codex Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Codex these resolve to the tools below.
-
-| Action skills request | Codex equivalent |
-|----------------------|------------------|
-| Read a file | `shell` (e.g., `cat`, `head`, `tail`) — Codex reads files via shell |
-| Create / edit / delete a file | `apply_patch` (structured diff for create, update, delete) |
-| Run a shell command | `shell` |
-| Search file contents | `shell` (e.g., `grep`, `rg`) |
-| Find files by name | `shell` (e.g., `find`, `ls`) |
-| Fetch a URL | `shell` with `curl` / `wget` — Codex has no native fetch tool |
-| Search the web | `web_search` (enabled by default; configurable in `config.toml` via the top-level `web_search` setting — `live`, `cached`, or `disabled`) |
-| Invoke a skill | Skills load natively — just follow the instructions |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | `spawn_agent` (see [Subagent dispatch requires multi-agent support](#subagent-dispatch-requires-multi-agent-support)) |
-| Multiple parallel dispatches | Multiple `spawn_agent` calls in one response |
-| Wait for subagent result | `wait_agent` |
-| Free up subagent slot when done | `close_agent` |
-| Task tracking ("create a todo", "mark complete") | `update_plan` |
-
-## Instructions file
-
-When a skill mentions "your instructions file", on Codex this is **`AGENTS.md`** at the project root. Codex also reads `~/.codex/AGENTS.md` for global context, and an `AGENTS.override.md` (in the project tree or `~/.codex/`) takes precedence when present. Codex walks from the project root down to the current working directory, concatenating `AGENTS.md` files it finds along the way, up to `project_doc_max_bytes` (32 KiB by default).
-
-## Personal skills directory
-
-User-level skills live at **`$CODEX_HOME/skills/`** (default `~/.codex/skills/`). Codex also reads the cross-runtime path **`~/.agents/skills/`** (shared with Copilot CLI and Gemini CLI). When both directories exist at the same scope, Codex loads them both as separate skill catalogs. Each skill is a subdirectory containing a `SKILL.md` (with `name` and `description` frontmatter).
-
-## Subagent dispatch requires multi-agent support
-
-Add to your Codex config (`~/.codex/config.toml`):
-
-```toml
-[features]
-multi_agent = true
-```
-
-This enables `spawn_agent`, `wait_agent`, and `close_agent` for skills like `mastermind:taskdev` and `mastermind:review`.
-
-Legacy note: Codex builds before `rust-v0.115.0` exposed spawned-agent waiting as `wait`. Current Codex uses `wait_agent` for spawned agents. The `wait` name now belongs to code-mode `exec/wait`, which resumes a yielded exec cell by `cell_id`; it is not the spawned-agent result tool.
-
-## Environment Detection
-
-Skills that create worktrees or finish branches should detect their environment with read-only git commands before proceeding:
-
-```bash
-GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
-GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
-BRANCH=$(git branch --show-current)
-```
-
-- `GIT_DIR != GIT_COMMON` → already in a linked worktree (skip creation)
-- `BRANCH` empty → detached HEAD (cannot branch/push/PR from sandbox)
-
-See `mastermind:worktree` Step 0 and `mastermind:finish` Step 1 for how each skill uses these signals.
-
-## Codex App Finishing
-
-When the sandbox blocks branch/push operations (detached HEAD in an externally managed worktree), the agent commits all work and informs the user to use the App's native controls:
-
-- **"Create branch"** — names the branch, then commit/push/PR via App UI
-- **"Hand off to local"** — transfers work to the user's local checkout
-
-The agent can still run tests, stage files, and output suggested branch names, commit messages, and PR descriptions for the user to copy.
-# monomind:end skills:claude:mastermind:references/codex-tools.md

package/.claude/skills/mastermind/references/copilot-tools.md

@@ -47,54 +47,3 @@ Copilot CLI supports persistent async shell sessions:
 | `sql` | Query the session's SQLite database (todos, metadata) |
 | `fetch_copilot_cli_documentation` | Look up Copilot CLI documentation |
 | GitHub MCP tools (`github-mcp-server-*`) | Native GitHub API access (issues, PRs, code search) |
-# monomind:start skills:claude:mastermind:references/copilot-tools.md
-# Copilot CLI Tool Mapping
-
-Skills speak in actions ("dispatch a subagent", "create a todo", "read a file"). On Copilot CLI these resolve to the tools below.
-
-| Action skills request | Copilot CLI equivalent |
-|----------------------|----------------------|
-| Read a file | `view` |
-| Create / edit / delete a file | `apply_patch` (Copilot CLI has no separate create/edit/write tools) |
-| Run a shell command | `bash` |
-| Search file contents | `rg` (ripgrep; Copilot CLI does not expose a `grep` tool) |
-| Find files by name | `glob` |
-| Fetch a URL | `web_fetch` |
-| Search the web | `web_search` |
-| Invoke a skill | `skill` |
-| Dispatch a subagent (`Subagent (general-purpose):` template) | `task` with `agent_type: "general-purpose"` (other accepted types: `explore`, `task`, `code-review`, `research`, `configure-copilot`) |
-| Multiple parallel dispatches | Multiple `task` calls in one response |
-| Subagent status/output/control | `read_agent`, `list_agents`, `write_agent` |
-| Task tracking ("create a todo", "mark complete") | `update_todo` |
-| Enter / exit plan mode | No equivalent — stay in the main session |
-
-## Instructions file
-
-When a skill mentions "your instructions file", on Copilot CLI this is **`AGENTS.md`** at the repository root. If both `AGENTS.md` and `.github/copilot-instructions.md` are present, Copilot reads both.
-
-## Personal skills directory
-
-User-level skills live at **`~/.copilot/skills/`**. Copilot CLI also recognizes the cross-runtime alias **`~/.agents/skills/`**, which is shared with Codex and Gemini CLI. Each skill is a subdirectory containing a `SKILL.md` (with `name` and `description` frontmatter).
-
-## Async shell sessions
-
-Copilot CLI supports persistent async shell sessions:
-
-| Tool | Purpose |
-|------|---------|
-| `bash` with `mode: "async"` (and optionally `detach: true`) | Start a long-running command in the background; returns a `shellId` |
-| `write_bash` | Send input to a running async session |
-| `read_bash` | Read output from an async session |
-| `stop_bash` | Terminate an async session |
-| `list_bash` | List all active shell sessions |
-
-## Additional Copilot CLI tools
-
-| Tool | Purpose |
-|------|---------|
-| `store_memory` | Persist facts about the codebase for future sessions |
-| `report_intent` | Update the UI status line with current intent |
-| `sql` | Query the session's SQLite database (todos, metadata) |
-| `fetch_copilot_cli_documentation` | Look up Copilot CLI documentation |
-| GitHub MCP tools (`github-mcp-server-*`) | Native GitHub API access (issues, PRs, code search) |
-# monomind:end skills:claude:mastermind:references/copilot-tools.md