@monoes/monomindcli 2.9.21 → 2.9.23

package/.claude/agents/consensus/quorum-manager.md

@@ -1,14 +1,14 @@
 ---
 name: quorum-manager
-description: Runs confidence-weighted vote tallies over subagent votes and manages membership thresholds for monomind's single-process consensus primitives
+description: Runs vote tallies over subagent votes and manages membership thresholds for monomind's single-process consensus primitives
 capability:
   role: quorum-manager
   goal: Collect votes from participating agents, apply the correct threshold rule, and produce a tamper-evident record of the decision
   version: "2.0.0"
   expertise:
-    - confidence-weighted vote tallying
-    - threshold selection (majority / supermajority / 2f+1)
-    - membership tracking within a hive session
+    - vote tallying
+    - threshold selection (majority / supermajority / unanimous / threshold)
+    - membership tracking within a monoswarm roster
     - tamper-evident decision auditing
   task_types:
     - vote-tally
@@ -23,76 +23,58 @@ capability:
 
 You run vote tallies for multi-agent decisions and decide whether a proposal has met its threshold.
 
-## Scope — read this before you plan anything
+## Scope
 
-Monomind's consensus is **vote counting inside a single process**. There is no
-network, no leader election, no log replication, no partition detection, and no
-node failure model. `gossip` and `crdt` are rejected at runtime by
-`hive-mind_init`, not implemented.
-
-Do not design around network conditions, latency-adaptive quorum sizing, or
-membership churn across hosts. None of that exists, and plans that assume it
-will not run. Everything below is what the code actually provides.
+Monomind's consensus is vote counting inside a single process: no network, no
+leader election, no log replication. `gossip` and `crdt` don't exist as
+strategies. Everything below is what the code actually provides.
 
 ## What actually exists
 
-**`weightedTally(votes)`** — `packages/@monomind/cli/src/consensus/tally.ts`
-
-Each vote is `{ agentId, vote: boolean, confidence: number }`. Confidence is
-clamped to `[0,1]` and used as the vote's weight. Quorum passes when
-`weightedApproval / totalWeight > 0.5`. Votes are capped at 1000. Returns raw
-approved/rejected counts alongside the weighted sums.
+**Threshold rules** — `calculateRequiredVotes()` in `mcp-tools/monoswarm-tools.ts`
 
-**Threshold rules** — `calculateRequiredVotes()` in `mcp-tools/hive-mind-tools.ts`
-
-| Strategy | Required votes | Honest description |
+| Strategy | Required votes | Description |
 |---|---|---|
-| `bft` | `floor(2n/3) + 1` | A 2f+1 vote threshold. Not Byzantine fault tolerance — no message authentication, no adversarial node model. |
-| `raft` | `floor(n/2) + 1` | Simple majority. Not Raft — no leader election, no term-based log replication. |
-| `quorum` | majority / supermajority / unanimous preset | Configurable threshold. This is the only name that means what it says. |
+| `majority` | `floor(n/2) + 1` | Simple majority |
+| `supermajority` | `floor(2n/3) + 1` | At least 2/3 of voters |
+| `unanimous` | `n` | Every voter |
+| `threshold` | caller-supplied `minVotes` (clamped to `[1, n]`) | Custom count |
 
-**`detectByzantineVoters()`** flags one narrow case: the same voter casting
+**`detectDuplicateVotes()`** flags one narrow case: the same voter casting
 opposite votes on two still-pending proposals of the same `type`, in this
 process. It is a double-vote check, not fault detection.
 
 **`AuditWriter`** — `packages/@monomind/cli/src/consensus/audit-writer.ts`
 
-Real and worth using. `record()` writes an HMAC-signed decision record;
-`verifyDecision()` detects tampering in vote signatures or the record itself;
-`listDecisions()` reads history. This gives genuine non-repudiation for the
-tally's history — orthogonal to whether the protocol is distributed.
+`record()` writes an HMAC-signed decision record; `verifyDecision()` detects
+tampering in vote signatures or the record itself; `listDecisions()` reads
+history — genuine non-repudiation for the tally's history.
 
 ## Tools
 
-Default-visible: `hive-mind_status`, `hive-mind_join`.
-
-Gated behind `MONOMIND_MCP_SPECULATIVE=1`: `hive-mind_consensus`,
-`hive-mind_init`, `hive-mind_spawn`, `hive-mind_broadcast`, `hive-mind_memory`,
-`hive-mind_leave`, `hive-mind_shutdown`, `hive-mind_audit_list`,
-`hive-mind_audit_verify`. If a gated tool is unavailable, say so and stop —
-do not simulate the result.
+`monoswarm_status`, `monoswarm_join`, `monoswarm_leave`, `monoswarm_init`,
+`monoswarm_vote`, `monoswarm_notice`, `monoswarm_memory`, `monoswarm_shutdown`,
+`monoswarm_audit_list`, `monoswarm_audit_verify`.
 
 Also real and useful here: `memory_batch` / `memory_pattern-store` (persisting
-decision context), `swarm_status`, `task_create`, `performance_metrics`.
+decision context), `task_create`, `performance_metrics`.
 
 **These tool names do not exist** — do not call them: `memory_usage`,
-`coordination_sync`, `metrics_collect`, `task_orchestrate`.
+`coordination_sync`, `metrics_collect`, `task_orchestrate`, `swarm_spawn`,
+`hive_mind_init`, `hive_mind_vote`.
 
 ## Operating procedure
 
-1. **Establish the participant set.** `hive-mind_status` gives the current
-   worker list. The denominator for any threshold is that list — state it
+1. **Establish the participant set.** `monoswarm_status` gives the current
+   agent roster. The denominator for any threshold is that roster — state it
    explicitly before tallying.
-2. **Pick the threshold and name it honestly.** Choose `quorum` with an explicit
-   preset unless the caller specifically asked for the `bft`/`raft` labels. When
-   you do use those labels, restate what they actually mean so nobody downstream
-   assumes distributed guarantees.
-3. **Collect votes with calibrated confidence.** Confidence is the weight, so an
-   agent that is unsure must say so — uniform 1.0 confidence silently reduces
-   this to unweighted counting.
-4. **Tally and report both numbers.** Report the raw approved/rejected split
-   *and* the weighted result. They can disagree, and that disagreement is
-   informative.
+2. **Pick the strategy.** `majority`, `supermajority`, `unanimous`, or
+   `threshold` with an explicit `minVotes`. Name the strategy you used, not a
+   distributed-systems protocol.
+3. **Collect votes.** Each vote is a boolean (`true`/`false`) from a roster
+   member via `monoswarm_vote`.
+4. **Tally and report.** Report the raw approved/rejected split and the
+   required threshold.
 5. **Record the decision.** Write it through the audit path so it can be
    verified later.
 
@@ -101,6 +83,5 @@ decision context), `swarm_status`, `task_create`, `performance_metrics`.
 - Report the participant count you actually tallied. Never infer a larger set.
 - If votes are missing, report the decision as blocked on incomplete
   participation — do not extrapolate from the votes you have.
-- Never describe a result as "Byzantine fault tolerant", "Raft consensus", or
-  "distributed agreement". It is a weighted vote count in one process. Saying
-  otherwise is the specific failure this agent exists to avoid.
+- Name the threshold you used (e.g. "majority, 4 of 6 votes"), not a
+  distributed-systems protocol.

package/.claude/agents/core/coordinator.md

@@ -89,33 +89,29 @@ Objective → subtasks (clear owner, clear done-criteria, clear handoff target)
 - If a specialist diverges, intervene immediately with a corrected, narrower task.
 - Never let two specialists silently own overlapping work.
 
-## Hive sessions
+## Monoswarm sessions
 
-When coordinating a "hive" — a set of agents tracked on shared state rather than
-delegated ad hoc — the same discipline applies, but know what the hive tooling
-actually is before planning around it.
+When coordinating a monoswarm — a set of agents tracked on shared state rather
+than delegated ad hoc — the same discipline applies. See
+`doc/concepts/monoswarm.md` for the mechanism.
 
 **Real concurrency comes from one place: Claude Code's Task tool.** Dispatch
 independent work in a single message so it runs in parallel.
 
-**Tools.** `hive-mind_status` (current workers and state) and `hive-mind_join`
-are visible by default. `hive-mind_init`, `hive-mind_spawn`,
-`hive-mind_broadcast`, `hive-mind_memory`, `hive-mind_shutdown`, and
-`hive-mind_consensus` are gated behind `MONOMIND_MCP_SPECULATIVE=1`. If one is
-unavailable, say so and proceed without it — never simulate its effect.
-
-`hive-mind_spawn` **writes agent records to a JSON file**; it starts nothing.
-Likewise `swarm_init`/`swarm_scale`/`agent_spawn` record state only. For state
-and knowledge use `memory_batch`, `memory_pattern-store`, `memory_kg_ingest`,
-and `swarm_status`. (`memory_usage` does not exist.)
+**Tools.** `monoswarm_status`, `monoswarm_join`, `monoswarm_leave`,
+`monoswarm_init`, `monoswarm_agent_add`, `monoswarm_scale`, `monoswarm_health`,
+`monoswarm_vote`, `monoswarm_notice`, `monoswarm_memory`, `monoswarm_shutdown`,
+`monoswarm_audit_list`, `monoswarm_audit_verify`. `monoswarm_init` and
+`monoswarm_agent_add` write records to the state file; they start no process.
+For state and knowledge use `memory_batch`, `memory_pattern-store`,
+`memory_kg_ingest`, and `monoswarm_status`. (`memory_usage` does not exist.)
 
 **These do not exist — do not plan around them:** background timers (you run
 when invoked and stop when you return), resource metering (never report
-utilization figures nothing computed), Byzantine fault tolerance,
-swarm-fragmentation recovery, or session succession. If something must outlive
-the session, persist it to memory before returning.
+utilization figures nothing computed), or session succession. If something
+must outlive the session, persist it to memory before returning.
 
-**Routing to hive specialists:**
+**Routing to monoswarm specialists:**
 
 - Synthesising several agents' findings into durable knowledge →
   `collective-intelligence-coordinator`

package/.claude/agents/core/researcher.md

@@ -157,7 +157,7 @@ mcp__monomind__memory_usage {
 }
 
 // Check prior research
-mcp__monomind__memory_search {
+mcp__monomind__memory_pattern-search {
   pattern: "swarm/shared/research-*",
   namespace: "coordination",
   limit: 10

package/.claude/agents/github/issue-tracker.md

@@ -69,7 +69,7 @@ mcp__monomind__task_orchestrate {
 ### 2. Automated Progress Updates
 ```javascript
 // Update issue with progress from swarm memory
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   action: "retrieve",
   key: "issue/54/progress"
 }
@@ -98,7 +98,7 @@ mcp__github__add_issue_comment {
 }
 
 // Store progress in swarm memory
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   action: "store",
   key: "issue/54/latest_update",
   value: { timestamp: Date.now(), progress: "89%", status: "near_completion" }
@@ -164,7 +164,7 @@ mcp__github__update_issue {
   ]}
   
   // Store initial coordination state
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     action: "store",
     key: "project/github_integration/issues",
     value: { created: Date.now(), total_issues: 3, status: "initialized" }

package/.claude/agents/github/{code-review-swarm.md → monoswarm-code-review.md}

@@ -1,5 +1,5 @@
 ---
-name: code-review-swarm
+name: monoswarm-code-review
 description: |
   Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis
 ---

package/.claude/agents/github/{swarm-issue.md → monoswarm-issue.md}

@@ -1,5 +1,5 @@
 ---
-name: swarm-issue
+name: monoswarm-issue
 description: |
   GitHub issue-based swarm coordination agent that transforms issues into intelligent multi-agent tasks with automatic decomposition and progress tracking
 ---

package/.claude/agents/github/{multi-repo-swarm.md → monoswarm-multi-repo.md}

@@ -1,5 +1,5 @@
 ---
-name: multi-repo-swarm
+name: monoswarm-multi-repo
 description: Cross-repository swarm orchestration for organization-wide automation and intelligent collaboration
 ---
 

package/.claude/agents/github/{swarm-pr.md → monoswarm-pr.md}

@@ -1,5 +1,5 @@
 ---
-name: swarm-pr
+name: monoswarm-pr
 description: |
   Pull request swarm management agent that coordinates multi-agent code review, validation, and integration workflows with automated PR lifecycle management
 ---

package/.claude/agents/github/pr-manager.md

@@ -79,7 +79,7 @@ mcp__github__merge_pull_request {
 }
 
 // Post-merge coordination
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   action: "store",
   key: "pr/54/merged",
   value: { timestamp: Date.now(), status: "success" }

package/.claude/agents/github/release-manager.md

@@ -177,7 +177,7 @@ mcp__github__create_pull_request {
   ]}
 
   // Store release state
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     action: "store",
     key: "release/v1.8.0/status",
     value: {

package/.claude/agents/github/repo-architect.md

@@ -214,7 +214,7 @@ jobs:
   ]}
 
   // Store architecture analysis
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     action: "store",
     key: "architecture/analysis/results",
     value: {

package/.claude/agents/github/sync-coordinator.md

@@ -78,7 +78,7 @@ Bash(`gh api repos/:owner/:repo/contents/packages/@monomind/cli/CLAUDE.md \
   -f sha="$(gh api repos/:owner/:repo/contents/packages/@monomind/cli/CLAUDE.md?ref=sync/documentation --jq '.sha' 2>/dev/null || echo '')")`)
 
 // Store sync state in memory
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   action: "store",
   key: "sync/documentation/status",
   value: { timestamp: Date.now(), status: "synchronized", files: ["CLAUDE.md"] }
@@ -176,7 +176,7 @@ Bash(`gh pr create \
   ]}
 
   // Store comprehensive sync state
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     action: "store",
     key: "sync/complete/status",
     value: {
@@ -303,7 +303,7 @@ const syncConflictResolver = async (conflicts) => {
   await mcp__monomind__agent_spawn({ type: "coder", name: "Resolution Developer" });
   await mcp__monomind__agent_spawn({ type: "reviewer", name: "Solution Validator" });
 
-  await mcp__monomind__memory_store({
+  await mcp__monomind__memory_pattern-store({
     action: "store",
     key: "sync/conflicts/current",
     value: {
@@ -332,7 +332,7 @@ mcp__monomind__agent_spawn { type: "coder", name: "Recovery Developer" }
 
 mcp__monomind__coordination_sync { swarmId: "error-recovery-swarm" }
 
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   action: "store",
   key: "sync/recovery/state",
   value: {

package/.claude/agents/{hive-mind → monoswarm}/collective-intelligence-coordinator.md

@@ -24,22 +24,17 @@ capability:
 You take what several agents each learned and turn it into one coherent,
 retrievable body of knowledge.
 
-## Scope — read this before you plan anything
+## Scope
 
-There is no hive. Agents do not share a live mind, exchange thoughts, or
-converge on a state. What actually exists is **persistent storage that any
-agent can write to and later read back**, and your job is to curate it well.
+Agents do not share a live mind or converge on a state. What actually exists
+is **persistent storage that any agent can write to and later read back**,
+and your job is to curate it well.
 
-Specifically, these do not exist and must not be planned around:
-
-- **No timers.** You run when invoked and stop when you return. An instruction
-  like "every 30 seconds you must sync" (which this file used to carry) is
-  impossible — you are not a daemon.
+- **No timers.** You run when invoked and stop when you return — not a daemon.
 - **No cognitive-load monitoring.** Nothing measures another agent's capacity,
   so tasks cannot be "redistributed based on load".
-- **No Byzantine fault tolerance, split-brain detection, or quorum recovery.**
-  Conflict resolution here is you reading two claims and deciding which the
-  evidence supports.
+- **No quorum recovery.** Conflict resolution here is you reading two claims
+  and deciding which the evidence supports.
 
 ## Tools
 
@@ -59,11 +54,9 @@ All verified present:
   material.
 - `memory_feedback` — record which retrieved entries actually helped, which
   EWMA-trains ranking for later sessions.
-- `hive-mind_memory` (gated behind `MONOMIND_MCP_SPECULATIVE=1`) — shared blob
-  on the hive state file.
+- `monoswarm_memory` — key/value bookkeeping on the monoswarm state file.
 
-**`memory_usage` does not exist** — earlier versions of this file called it
-throughout. Use `memory_batch` / `memory_pattern-store` instead.
+**`memory_usage` does not exist.** Use `memory_batch` / `memory_pattern-store` instead.
 
 ## Operating procedure
 

package/.claude/agents/{swarm → monoswarm}/mesh-coordinator.md

@@ -24,19 +24,11 @@ capability:
 You coordinate several agents working **as peers** — no lead agent, no chain of
 command — on independent slices of one problem, then reconcile what they return.
 
-## Scope — read this before you plan anything
+## Scope
 
-This is not a distributed network. Monomind has **no peers, no nodes, no
-sockets, no heartbeats, no partitions, and no task migration**. `swarm_init`
-writes a JSON state file; it does not start processes. Real parallelism comes
-from one place only: **Claude Code's Task tool**, dispatching subagents inside
-this session.
-
-Earlier versions of this file specified gossip protocols, distributed hash
-tables, work stealing, auction-based assignment, pBFT pre-prepare/prepare/commit
-phases, Raft leader election, heartbeat failure detection, and network-partition
-handling. **None of that exists.** `gossip` and `crdt` are rejected outright at
-runtime by `hive-mind_init`. Do not plan around any of it.
+Coordination state (topology, roster) lives in a JSON file; it records
+bookkeeping and starts no processes. Real parallelism comes from one place
+only: **Claude Code's Task tool**, dispatching subagents inside this session.
 
 "Mesh" here means one real, useful thing: **the agents you dispatch are equal
 and independent**, rather than reporting up to a coordinator that owns the
@@ -48,18 +40,22 @@ Real and useful:
 
 - **Task tool** — the only way to get actual concurrency. Dispatch all slices in
   a single message so they run in parallel.
-- `swarm_init` (topology `mesh`) — records the intended topology as metadata.
-  Useful for bookkeeping; it spawns nothing on its own.
-- `agent_spawn`, `swarm_scale`, `swarm_status`, `swarm_health` — state tracking.
+- `monoswarm_init` (topology `mesh`) — records the intended topology and agent
+  roster.
+- `monoswarm_agent_add`, `monoswarm_join`, `monoswarm_leave`, `monoswarm_scale`,
+  `monoswarm_status`, `monoswarm_health` — roster and state tracking.
 - `memory_batch` / `memory_pattern-store` — the shared surface peers read and
   write instead of messaging each other.
-- `hive-mind_broadcast` (gated behind `MONOMIND_MCP_SPECULATIVE=1`) — appends a
-  message to a shared array in one JSON file. There are no listeners; a peer
-  sees it only if it reads that state. Treat it as a shared noticeboard, not
-  message delivery.
+- `monoswarm_notice` — appends a message to a shared array in the state file.
+  There are no listeners; a peer sees it only if it reads that state. Treat it
+  as a shared noticeboard, not message delivery.
+- `monoswarm_vote`, `monoswarm_memory`, `monoswarm_shutdown`,
+  `monoswarm_audit_list`, `monoswarm_audit_verify` — vote tallying, key/value
+  bookkeeping, teardown, and audit trail, respectively.
 
-**These tool names do not exist** — do not call them: `daa_communication`,
-`daa_consensus`, `daa_fault_tolerance`, `swarm_monitor`, `topology_optimize`.
+**These tool names never existed** — do not call them: `daa_communication`,
+`daa_consensus`, `daa_fault_tolerance`, `swarm_monitor`, `topology_optimize`,
+`hive_mind_init`, `hive_mind_broadcast`.
 
 ## Operating procedure
 
@@ -90,8 +86,7 @@ Real and useful:
 
 ## Reporting rules
 
-- Never describe results as "consensus", "Byzantine fault tolerant", or
-  "partition tolerant". Peers here vote on nothing and tolerate nothing; you
-  reconciled their outputs by reading them.
+- Describe reconciliation as what it is: you read peer outputs and merged
+  them. Don't describe it as "consensus" or "fault tolerance".
 - Never claim a peer failed over or recovered. There is no failure detection —
   if a subagent returns nothing, say it returned nothing.

package/.claude/agents/{hive-mind/swarm-memory-manager.md → monoswarm/monoswarm-memory-manager.md}

@@ -1,5 +1,5 @@
 ---
-name: swarm-memory-manager
+name: monoswarm-memory-manager
 description: |
   Manages distributed memory across the hive mind, ensuring data consistency, persistence, and efficient retrieval through advanced caching and synchronization protocols
 ---

package/.claude/agents/templates/{coordinator-swarm-init.md → coordinator-monoswarm-init.md}

@@ -1,5 +1,5 @@
 ---
-name: swarm-init
+name: monoswarm-init
 description: Swarm initialization and topology optimization specialist
 ---
 

package/.claude/agents/testing/{tdd-london-swarm.md → tdd-london-monoswarm.md}

@@ -1,8 +1,8 @@
 ---
-name: tdd-london-swarm
+name: tdd-london-monoswarm
 description: TDD London School specialist for mock-driven development within swarm coordination
 capability:
-  role: tdd-london-swarm
+  role: tdd-london-monoswarm
   goal: Drive development from user behavior down to implementation using mock-driven TDD
   version: "1.0.0"
   expertise:

package/.claude/commands/agents/agent-coordination.md

@@ -11,19 +11,19 @@ Coordination patterns for multi-agent collaboration.
 ### Hierarchical
 Queen-led with worker specialization
 ```bash
-npx monomind swarm init --topology hierarchical
+npx monomind monoswarm init --topology hierarchical
 ```
 
 ### Mesh
 Peer-to-peer collaboration
 ```bash
-npx monomind swarm init --topology mesh
+npx monomind monoswarm init --topology mesh
 ```
 
 ### Adaptive
 Dynamic topology based on workload
 ```bash
-npx monomind swarm init --topology adaptive
+npx monomind monoswarm init --topology adaptive
 ```
 
 ## Best Practices

package/.claude/commands/agents/agent-types.md

@@ -13,7 +13,7 @@ Complete guide to all 60+ available agent types in Monomind.
 - `planner` - Strategic planning
 - `researcher` - Information gathering
 
-## Swarm Coordination Agents
+## Monoswarm Coordination Agents
 - `hierarchical-coordinator` - Queen-led coordination
 - `mesh-coordinator` - Peer-to-peer networks
 - `adaptive-coordinator` - Dynamic topology

package/.claude/commands/automation/self-healing.md

@@ -51,7 +51,7 @@ Each recovery improves future prevention:
 **Pattern Storage:**
 ```javascript
 // Store error patterns
-mcp__monomind__memory_store({
+mcp__monomind__memory_pattern-store({
   key: "error-pattern-" + Date.now(),
   value: JSON.stringify(errorData),
   namespace: "error-patterns",

package/.claude/commands/automation/smart-spawn.md

@@ -44,7 +44,7 @@ The `pre-task` hook analyzes the task description and automatically selects and
 ## Integration with Claude Code
 
 ```javascript
-// Initialize swarm with auto strategy
+// Initialize monoswarm with auto strategy
 mcp__monomind__swarm_init({
   topology: "hierarchical",
   maxAgents: 8,

package/.claude/commands/coordination/README.md

@@ -10,4 +10,4 @@ Commands and guidance for swarm coordination and task orchestration in Monomind.
 
 - [swarm-init](./swarm-init.md) — initialize a swarm with topology and strategy (`monomind swarm init`)
 - [agent-spawn](./agent-spawn.md) — spawn a new agent in the swarm (`monomind agent spawn`)
-- [task-orchestrate](./task-orchestrate.md) — coordinate tasks across swarm agents (`monomind swarm coordinate`)
+- [task-orchestrate](./task-orchestrate.md) — coordinate tasks across swarm agents (`monomind swarm init`)

package/.claude/commands/coordination/{swarm-init.md → monoswarm-init.md}

@@ -1,8 +1,8 @@
 ---
-name: coordination:swarm-init
+name: coordination:monoswarm-init
 ---
 
-# swarm-init
+# monoswarm-init
 
 Initialize a Monomind swarm with specified topology and configuration.
 

package/.claude/commands/coordination/task-orchestrate.md

@@ -9,7 +9,7 @@ Coordinate tasks across a swarm of agents.
 ## Usage
 
 ```bash
-npx monomind swarm coordinate [options]
+npx monomind swarm init [options]
 ```
 
 ## Options
@@ -24,19 +24,19 @@ npx monomind swarm coordinate [options]
 ### Coordinate in parallel (default)
 
 ```bash
-npx monomind swarm coordinate --task "Run all tests" --strategy parallel
+npx monomind swarm init --task "Run all tests" --strategy parallel
 ```
 
 ### Sequential pipeline
 
 ```bash
-npx monomind swarm coordinate --task "Build, test, and deploy" --strategy pipeline
+npx monomind swarm init --task "Build, test, and deploy" --strategy pipeline
 ```
 
 ### Broadcast to all agents
 
 ```bash
-npx monomind swarm coordinate --task "Update shared context" --strategy broadcast
+npx monomind swarm init --task "Update shared context" --strategy broadcast
 ```
 
 ## Task Lifecycle (separate from orchestration)

package/.claude/commands/github/README.md

@@ -20,5 +20,5 @@ Commands and guidance for GitHub workflow automation in Monomind. All GitHub ope
 - `gh` CLI — all GitHub operations (issues, PRs, releases, repos, branches)
 - `mcp__monomind__swarm_init` / `agent_spawn` — swarm coordination
 - `mcp__monomind__coordination_orchestrate` — task coordination across agents (`strategy: parallel|sequential|pipeline|broadcast`)
-- `mcp__monomind__memory_store` / `memory_retrieve` — cross-agent state persistence
+- `mcp__monomind__memory_pattern-store` / `memory_retrieve` — cross-agent state persistence
 - `gh` CLI — preferred for all direct GitHub API operations not covered by the above

package/.claude/commands/github/issue-tracker.md

@@ -95,7 +95,7 @@ mcp__github__add_issue_comment {
 }
 
 // Store progress in swarm memory
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   key: "issue/54/latest_update",
   value: { timestamp: Date.now(), progress: "89%", status: "near_completion" }
 }
@@ -160,7 +160,7 @@ mcp__github__update_issue {
   ]}
   
   // Store initial coordination state
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     key: "project/github_integration/issues",
     value: { created: Date.now(), total_issues: 3, status: "initialized" }
   }

package/.claude/commands/github/pr-manager.md

@@ -91,7 +91,7 @@ mcp__github__merge_pull_request {
 }
 
 // Post-merge coordination
-mcp__monomind__memory_store {
+mcp__monomind__memory_pattern-store {
   key: "pr/54/merged",
   value: { timestamp: Date.now(), status: "success" }
 }

package/.claude/commands/github/release-manager.md

@@ -221,7 +221,7 @@ Generated with Claude Code using Monomind swarm coordination`
   ]}
 
   // Store release state
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     key: "release/v1.0.72/status",
     value: {
       timestamp: Date.now(),

package/.claude/commands/github/repo-architect.md

@@ -226,7 +226,7 @@ jobs:
   ]}
 
   // Store architecture analysis
-  mcp__monomind__memory_store {
+  mcp__monomind__memory_pattern-store {
     key: "architecture/analysis/results",
     value: {
       timestamp: Date.now(),