@monoes/monomindcli 1.10.57 → 1.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.57",
+  "version": "1.11.1",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -51,13 +51,13 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
-    "./ruvector": {
-      "types": "./dist/src/ruvector/index.d.ts",
-      "import": "./dist/src/ruvector/index.js"
+    "./monovector": {
+      "types": "./dist/src/monovector/index.d.ts",
+      "import": "./dist/src/monovector/index.js"
     },
-    "./ruvector/*": {
-      "types": "./dist/src/ruvector/*.d.ts",
-      "import": "./dist/src/ruvector/*.js"
+    "./monovector/*": {
+      "types": "./dist/src/monovector/*.d.ts",
+      "import": "./dist/src/monovector/*.js"
     },
     "./mcp-tools": {
       "types": "./dist/src/mcp-tools/index.d.ts",
@@ -89,6 +89,10 @@
     "ws": "^8.18.0",
     "@noble/ed25519": "^2.1.0",
     "@monoes/monograph": "^1.1.0",
+    "@monomind/aidefence": "workspace:*",
+    "@monomind/embeddings": "workspace:*",
+    "@monomind/guidance": "workspace:*",
+    "@monomind/mcp": "workspace:*",
     "graphology": "^0.25.4",
     "graphology-communities-louvain": "^2.0.1",
     "graphology-metrics": "^2.4.0",
@@ -99,18 +103,14 @@
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
+    "sql.js": "^1.14.1",
+    "@monoes/memory": "workspace:*",
     "@monomind/plugin-gastown-bridge": "^0.1.3",
     "agentic-flow": "^3.0.0-alpha.1",
-    "@ruvector/attention": "^0.1.4",
-    "@ruvector/learning-wasm": "^0.1.29",
-    "@ruvector/router": "^0.1.27",
-    "@ruvector/rvagent-wasm": "^0.1.0",
-    "@ruvector/ruvllm-wasm": "^2.0.2",
-    "@ruvector/sona": "^0.1.5",
     "@anthropic-ai/sdk": "*"
   },
   "publishConfig": {
     "access": "public",
     "tag": "latest"
   }
-}
+}

package/scripts/publish-registry.ts

@@ -196,7 +196,6 @@ async function generateRegistry(): Promise<PluginRegistry> {
     '@monomind/security',
     '@monomind/claims',
     '@monomind/embeddings',
-    '@monomind/neural',
     '@monomind/performance',
     '@monomind/plugins',
   ];

package/.claude/commands/monomind/adr.md

@@ -1,11 +0,0 @@
----
-description: Draft an Architecture Decision Record from accumulated decision markers in this session's prompts
----
-
-Run the hook handler's adr-draft action to scan `.monomind/decisions.jsonl` for the last 7 days of decision markers (e.g. "let's go with X", "we chose Y", "decision: Z") and produce an ADR template in `docs/adrs/`.
-
-```bash
-node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" adr-draft
-```
-
-After running, open the generated `docs/adrs/ADR-NNNN-YYYY-MM-DD-session-decisions.md`, fill in the Context and Consequences sections, and change Status to Accepted/Rejected.

package/.claude/commands/monomind/budget.md

@@ -1,7 +0,0 @@
----
-description: Show current budget status — today, month, limits, autotuned flag
----
-
-```bash
-node "$CLAUDE_PROJECT_DIR/.claude/helpers/hook-handler.cjs" budget-status
-```

package/.claude/commands/monomind/createtask.md

@@ -1,277 +0,0 @@
----
-name: monomind:createtask
-description: "Monomind — Ingest a prompt, file, or folder, deeply understand it, generate agent-optimized tasks on monotask with smart grouping, prerequisites, and session memory"
-version: 1.0.0
-triggers:
-  - /monomind:createtask
-  - create tasks from spec
-  - decompose into tasks
-  - turn this into tasks
-  - break this down into tasks
-  - create implementation tasks
----
-
-If `$ARGUMENTS` is empty, output this and STOP:
-
-> **Usage:** `/monomind:createtask <prompt | path-to-file | path-to-folder>`
->
-> Examples:
-> - `/monomind:createtask Build a webhook delivery system with retries and dead-letter queue`
-> - `/monomind:createtask docs/superpowers/specs/2026-04-27-swarm-tab-redesign-design.md`
-> - `/monomind:createtask docs/superpowers/specs/`
->
-> This command deeply analyzes your input, generates an implementation plan, and creates **agent-optimized** tasks on monotask — grouped so each agent gets full context, with prerequisites ensuring execution order.
-
-Do NOT proceed further if no arguments were provided.
-
----
-
-## Step 0: Verify monotask CLI
-
-```bash
-command -v monotask || (command -v cargo && cargo install monotask)
-```
-If neither exists, tell user to install Rust + monotask and STOP.
-
----
-
-## Step 1: Classify and Ingest Input
-
-Parse `$ARGUMENTS`:
-- `test -f` → file: read with Read tool, store as `RAW_CONTENT`, store filename as `INPUT_LABEL`
-- `test -d` → folder: `find "$ARGUMENTS" -maxdepth 2 -type f ! -name '.*' | head -30`, read each, concatenate with `--- FILE: <path> ---` separators as `RAW_CONTENT`
-- Otherwise → prompt: store text directly as `RAW_CONTENT`
-
----
-
-## Step 2: Enrich with Project Context
-
-Run ALL in parallel (skip errors):
-1. `mcp__monomind__monograph_suggest` with first 200 chars of `RAW_CONTENT`
-2. `mcp__monomind__monograph_query` for module/component names found in `RAW_CONTENT` (up to 5)
-3. `mcp__monomind__memory_search` with input summary
-4. Read `README.md` (first 200 lines)
-5. Read first found: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`
-6. Repo name from `git remote get-url origin` (strip path, strip `.git`) — store as `REPO_NAME`
-
-Bundle everything into `FULL_CONTEXT`.
-
----
-
-## Step 3: Setup Monotask Space and Board
-
-**Space**: Find or create space named `$REPO_NAME`. Store `SPACE_ID`.
-
-**Board**: Retrieve stored board ID first: `npx monomind@latest memory search "monomind-task board_id"`. If found, use it as `TASK_BOARD_ID`. Otherwise, list boards in the space via `monotask space boards list $SPACE_ID` and check each via `monotask column list <ID> --json` for a `Backlog` column. If still not found, create:
-```bash
-monotask board create "monomind-task" --json   # captures TASK_BOARD_ID from .id
-monotask space boards add $SPACE_ID $TASK_BOARD_ID
-npx monomind@latest memory store --key "monomind-task board_id" --value "$TASK_BOARD_ID" --namespace monomind
-```
-Create columns in order: `Backlog` → `Todo` → `In Progress` → `Review` → `Human in Loop` → `Done`
-
-Store all column IDs mapped by name. Store `TASK_BOARD_ID`.
-
----
-
-## Step 4: Deep Analysis
-
-Spawn a `Software Architect` agent. Provide `FULL_CONTEXT` + `$ARGUMENTS`.
-
-Required output:
-```json
-{
-  "summary": "2-3 sentence overview",
-  "goals": ["high-level goals"],
-  "components": [
-    {
-      "name": "component name",
-      "description": "what it does",
-      "dependencies": ["other components"],
-      "files_likely_affected": ["paths from monograph or educated guesses"]
-    }
-  ],
-  "technical_constraints": ["stack requirements, limitations"],
-  "acceptance_criteria": ["testable conditions for when the whole thing is done"],
-  "risks": ["pitfalls, ambiguities, unknowns"]
-}
-```
-
-Store as `ANALYSIS`.
-
----
-
-## Step 5: Generate Professional Tasks
-
-Spawn a `planner` agent. Provide analysis + `FULL_CONTEXT`.
-
-### Task Grouping Rules (enforce all 7)
-
-1. **Context Affinity**: Work sharing the same files, types, or domain model goes in ONE task. Tests always travel with their implementation.
-2. **Size Limit**: If a context group exceeds 30 minutes, split into a prerequisite chain.
-3. **Independence**: Work touching different modules with no shared types should be separate (parallelizable).
-4. **Test Colocation**: Never create standalone "write tests" tasks — only exception is integration/e2e tests spanning multiple components.
-5. **Prerequisite Chains**: Use `prerequisites` to enforce ordering. Same agent picks up the chain in sequence.
-6. **Chain Size Limit**: Max 4 tasks per chain. Split larger chains into two sub-chains linked by prerequisite.
-7. **Agent Capability**: Agent type must match the domain (no frontend agent on DB migrations, no backend-dev on CSS).
-
-### Task Card Format
-
-For each task, produce:
-```json
-{
-  "title": "Action-oriented title (verb + noun + context)",
-  "description": "## What\nExact deliverable.\n\n## Why\nMotivation.\n\n## Where\nFile paths, module boundaries.\n\n## Patterns\nExisting conventions to follow.",
-  "context": "All relevant context: patterns, related files, API shapes, data models. Include file paths from monograph.",
-  "definition_of_done": ["Specific, binary, verifiable condition"],
-  "testing_criteria": {
-    "unit_tests": ["function(input) → expected outcome"],
-    "integration_tests": ["endpoint + method → status + response shape"],
-    "edge_cases": ["boundary condition → expected behavior"]
-  },
-  "checklist": [
-    "Write failing test for [specific behavior]",
-    "Implement [function/class] in [file path]",
-    "Run tests — verify green",
-    "Commit: '[type]: [description]'"
-  ],
-  "agent_type": "best-fit agent from 230+ roster",
-  "priority": "critical | high | medium | low",
-  "effort": "1-10",
-  "prerequisites": ["titles of tasks that MUST complete first"],
-  "parallel_safe": true,
-  "context_group": "name of context chain, or 'independent'"
-}
-```
-
-Store as `TASKS` array.
-
----
-
-## Step 6: Create Cards on Monotask
-
-For each task, in prerequisite order:
-
-1. **Create card** in `Todo` (no prerequisites) or `Backlog` (has prerequisites):
-   ```bash
-   monotask card create $TASK_BOARD_ID $COLUMN_ID "<title>" --json
-   ```
-
-2. **Set description**:
-   ```bash
-   monotask card set-description $TASK_BOARD_ID $CARD_ID "<description>\n\n## Context\n<context>\n\n## Context Group\n<context_group>"
-   ```
-
-3. **Add DOD comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Definition of Done\n- [ ] <condition 1>\n..."
-   ```
-
-4. **Add testing criteria comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Testing Criteria\n\n### Unit Tests\n- <test 1>\n\n### Integration Tests\n- <test 1>\n\n### Edge Cases\n- <case 1>"
-   ```
-
-5. **Add agent assignment + metadata**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Assigned agent: <agent_type>\nContext group: <context_group>\nParallel safe: <true|false>\nPriority: <priority>\nEffort: <effort>/10\nPrerequisites: <task titles or none>\nSource: monomind:createtask"
-   ```
-
-6. **Set priority**: Extract priority from the current task, map to integer, then call:
-   ```bash
-   PRIORITY="<current task's priority field — one of: critical, high, medium, low>"
-   case "$PRIORITY" in
-     critical) PNUM=1 ;; high) PNUM=2 ;; medium) PNUM=3 ;; *) PNUM=4 ;;
-   esac
-   monotask card set-priority $TASK_BOARD_ID $CARD_ID $PNUM
-   ```
-
-7. **Create checklist**: Create the checklist, capture each item's ID from stdout, and store all IDs in a comment for `/monomind:do` to use when marking items complete:
-   ```bash
-   checklist_result=$(monotask checklist add $TASK_BOARD_ID $CARD_ID "Implementation Steps" --json)
-   CHECKLIST_ID=$(echo "$checklist_result" | jq -r '.id // empty')
-   ITEM_IDS=""
-   # For each checklist step <step>:
-   item_out=$(monotask checklist item-add $TASK_BOARD_ID $CARD_ID $CHECKLIST_ID "<step>")
-   ITEM_ID=$(echo "$item_out" | grep -oE '[0-9a-f-]{36}$')
-   ITEM_IDS="${ITEM_IDS:+$ITEM_IDS,}$ITEM_ID"
-   # (repeat for each step)
-   # After all items added, persist IDs:
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "CHECKLIST_ID: $CHECKLIST_ID"
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "ITEM_IDS: $ITEM_IDS"
-   ```
-
----
-
-## Step 7: Store Session Memory
-
-Call `mcp__monomind__memory_store` with:
-```json
-{
-  "key": "task-strategy:<REPO_NAME>:<timestamp>",
-  "content": {
-    "source": "monomind:createtask: <first 100 chars of $ARGUMENTS>",
-    "total_tasks": "N",
-    "context_groups": [
-      { "name": "group name", "task_titles": ["..."], "recommended_agent": "agent type", "sequential": true }
-    ],
-    "independent_tasks": ["titles of parallel-safe tasks"],
-    "recommended_execution_mode": "parallel | minimal | sequential",
-    "reasoning": "Why this mode fits"
-  },
-  "tags": ["task-strategy", "monomind:createtask"]
-}
-```
-
-Mode selection: **parallel** = mostly independent tasks; **minimal** = mixed; **sequential** = heavy shared state.
-
----
-
-## Step 8: Final Dependency Review
-
-Spawn a fresh `Code Reviewer` agent. Provide the complete `TASKS` array and `REPO_NAME`.
-
-The agent MUST check:
-- **Prerequisite integrity**: all referenced prerequisites exist, no circular deps, no orphans
-- **Context group consistency**: compatible agent types per group, no group >4 tasks, tasks in group are chained
-- **Critical path**: identify longest chain, flag if >6 tasks or any single task >effort 7
-- **Parallel safety**: `parallel_safe: true` tasks don't share modified files
-- **Agent assignment**: no frontend agent on backend tasks, no agent in >5 context groups
-
-**If APPROVED**: present summary and proceed to execution offer.
-**If NEEDS_FIXES**: auto-fix blockers (update card comments), present warnings to user, max 2 fix cycles.
-
----
-
-## Step 9: Gap Analysis
-
-Spawn a fresh `Software Architect` agent as critical reviewer. Provide `ANALYSIS` + all created tasks.
-
-Identify:
-- **Missing pieces**: testing gaps, error handling holes, security oversights, missing migrations
-- **Follow-ups**: natural extensions, performance optimizations
-
-Present as tables. Ask user which to add (`numbers`, `all`, or `none`). Selected missing pieces → `Todo`; follow-ups → `Backlog`.
-
----
-
-## Step 10: Summary and Execution Offer
-
-Output:
-```
-## Task Creation Complete
-
-**Source:** <input>
-**Space:** $REPO_NAME | **Board:** monomind-task
-
-| # | Title | Agent | Priority | Effort | Column | Deps |
-|---|-------|-------|----------|--------|--------|------|
-| 1 | ...   | ...   | high     | 3      | Todo   | —    |
-
-**Total:** N tasks (X in Todo, Y in Backlog)
-```
-
-If there are tasks in Todo:
-> **N tasks ready.** Start `/monomind:do` to execute them autonomously?
-
-If yes: `Skill("monomind:do", "--space $SPACE_ID --board $TASK_BOARD_ID")`