monomind 1.18.13 → 1.19.0

package/packages/@monomind/cli/.claude/agents/github/swarm-issue.md

@@ -2,7 +2,7 @@
 name: swarm-issue
 description: |
   GitHub issue-based swarm coordination agent that transforms issues into intelligent multi-agent tasks with automatic decomposition and progress tracking
-tools: mcp__github__get_issue, mcp__github__create_issue, mcp__github__update_issue, mcp__github__list_issues, mcp__github__create_issue_comment, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__task_orchestrate, mcp__monomind__memory_usage, TodoWrite, TodoRead, Bash, Grep, Read, Write
+tools: mcp__github__get_issue, mcp__github__create_issue, mcp__github__update_issue, mcp__github__list_issues, mcp__github__create_issue_comment, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__memory_usage, TodoWrite, TodoRead, Bash, Grep, Read, Write
 ---
 
 # Swarm Issue - Issue-Based Swarm Coordination

package/packages/@monomind/cli/.claude/agents/github/swarm-pr.md

@@ -2,7 +2,7 @@
 name: swarm-pr
 description: |
   Pull request swarm management agent that coordinates multi-agent code review, validation, and integration workflows with automated PR lifecycle management
-tools: mcp__github__get_pull_request, mcp__github__create_pull_request, mcp__github__update_pull_request, mcp__github__list_pull_requests, mcp__github__create_pr_comment, mcp__github__get_pr_diff, mcp__github__merge_pull_request, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__task_orchestrate, mcp__monomind__memory_usage, mcp__monomind__coordination_sync, TodoWrite, TodoRead, Bash, Grep, Read, Write, Edit
+tools: mcp__github__get_pull_request, mcp__github__create_pull_request, mcp__github__update_pull_request, mcp__github__list_pull_requests, mcp__github__create_pr_comment, mcp__github__get_pr_diff, mcp__github__merge_pull_request, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__memory_usage, mcp__monomind__coordination_sync, TodoWrite, TodoRead, Bash, Grep, Read, Write, Edit
 ---
 
 # Swarm PR - Managing Swarms through Pull Requests

package/packages/@monomind/cli/.claude/agents/github/sync-coordinator.md

@@ -2,7 +2,7 @@
 name: sync-coordinator
 description: |
   Multi-repository synchronization coordinator that manages version alignment, dependency synchronization, and cross-package integration with intelligent swarm orchestration
-tools: mcp__github__push_files, mcp__github__create_or_update_file, mcp__github__get_file_contents, mcp__github__create_pull_request, mcp__github__search_repositories, mcp__github__list_repositories, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__task_orchestrate, mcp__monomind__memory_store, mcp__monomind__coordination_sync, mcp__monomind__load_balance, TodoWrite, TodoRead, Bash, Read, Write, Edit, MultiEdit
+tools: mcp__github__push_files, mcp__github__create_or_update_file, mcp__github__get_file_contents, mcp__github__create_pull_request, mcp__github__search_repositories, mcp__github__list_repositories, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__memory_store, mcp__monomind__coordination_sync, mcp__monomind__load_balance, TodoWrite, TodoRead, Bash, Read, Write, Edit, MultiEdit
 ---
 
 # GitHub Sync Coordinator

package/packages/@monomind/cli/.claude/agents/github/workflow-automation.md

@@ -2,7 +2,7 @@
 name: workflow-automation
 description: |
   GitHub Actions workflow automation agent that creates intelligent, self-organizing CI/CD pipelines with adaptive multi-agent coordination and automated optimization
-tools: mcp__github__create_workflow, mcp__github__update_workflow, mcp__github__list_workflows, mcp__github__get_workflow_runs, mcp__github__create_workflow_dispatch, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__task_orchestrate, mcp__monomind__memory_usage, mcp__monomind__performance_report, mcp__monomind__bottleneck_analyze, mcp__monomind__workflow_create, mcp__monomind__automation_setup, TodoWrite, TodoRead, Bash, Read, Write, Edit, Grep
+tools: mcp__github__create_workflow, mcp__github__update_workflow, mcp__github__list_workflows, mcp__github__get_workflow_runs, mcp__github__create_workflow_dispatch, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__memory_usage, mcp__monomind__performance_report, mcp__monomind__bottleneck_analyze, mcp__monomind__workflow_create, mcp__monomind__automation_setup, TodoWrite, TodoRead, Bash, Read, Write, Edit, Grep
 ---
 
 # Workflow Automation - GitHub Actions Integration

package/packages/@monomind/cli/.claude/agents/goal/goal-planner.md

@@ -87,7 +87,7 @@ Advanced action definitions with tool groups:
 Action: analyze_codebase
   Preconditions: {repository_accessible: true}
   Effects: {code_analyzed: true, metrics_available: true}
-  Tools: [grep, ast_parser, complexity_analyzer]
+  Tools: [monograph_query, monograph_suggest, grep (fallback), ast_parser, complexity_analyzer]
   Execution: hybrid (LLM for insights, code for metrics)
   Cost: 2
   Fallback: manual_review if tools unavailable

package/packages/@monomind/cli/.claude/agents/specialized/specialized-workflow-architect.md

@@ -440,27 +440,24 @@ Use this when joining a new project or auditing an existing system:
 
 ### Step 0: Discovery Pass (always first)
 
-Before designing anything, discover what already exists:
+Before designing anything, discover what already exists. **Use monograph first** — fall back to grep only if monograph returns 0 results or the DB is not built.
+
+```
+# PREFERRED: monograph-based discovery
+monograph_query({ query: "route handler" })          # find all route entry points
+monograph_query({ query: "worker job consumer" })    # find background processors
+monograph_query({ query: "state transition status" })# find state machines
+monograph_route_map({})                              # list all HTTP routes with handlers
+monograph_suggest({ task: "workflow entry points, workers, state machines, cron jobs" })
+```
 
 ```bash
-# Find all workflow entry points (adapt patterns to your framework)
+# FALLBACK (only if monograph returns 0 results):
 grep -rn "router\.\(post\|put\|delete\|get\|patch\)" src/routes/ --include="*.ts" --include="*.js"
 grep -rn "@app\.\(route\|get\|post\|put\|delete\)" src/ --include="*.py"
-grep -rn "HandleFunc\|Handle(" cmd/ pkg/ --include="*.go"
-
-# Find all background workers / job processors
 find src/ -type f -name "*worker*" -o -name "*job*" -o -name "*consumer*" -o -name "*processor*"
-
-# Find all state transitions in the codebase
 grep -rn "status.*=\|\.status\s*=\|state.*=\|\.state\s*=" src/ --include="*.ts" --include="*.py" --include="*.go" | grep -v "test\|spec\|mock"
-
-# Find all database migrations
 find . -path "*/migrations/*" -type f | head -30
-
-# Find all infrastructure resources
-find . -name "*.tf" -o -name "docker-compose*.yml" -o -name "*.yaml" | xargs grep -l "resource\|service:" 2>/dev/null
-
-# Find all scheduled / cron jobs
 grep -rn "cron\|schedule\|setInterval\|@Scheduled" src/ --include="*.ts" --include="*.py" --include="*.go" --include="*.java"
 ```
 

package/packages/@monomind/cli/.claude/agents/testing/production-validator.md

@@ -245,17 +245,18 @@ describe('Performance Validation', () => {
 
 ### 1. Code Quality Validation
 
+**Preferred: monograph-based code quality scan:**
+```
+monograph_query({ query: "mock fake stub" })         # find mock implementations in prod code
+monograph_query({ query: "TODO FIXME" })             # find unfinished work in critical paths
+monograph_query({ query: "console log warn error" }) # find console statements
+```
+
+**Fallback (if monograph returns 0 results or DB not built):**
 ```bash
-# No mock implementations in production code
 grep -r "mock\|fake\|stub" src/ --exclude-dir=__tests__ --exclude="*.test.*" --exclude="*.spec.*"
-
-# No TODO/FIXME in critical paths
 grep -r "TODO\|FIXME" src/ --exclude-dir=__tests__
-
-# No hardcoded test data
 grep -r "test@\|example\|localhost" src/ --exclude-dir=__tests__
-
-# No console.log statements
 grep -r "console\." src/ --exclude-dir=__tests__
 ```
 

package/packages/@monomind/cli/.claude/agents/testing/testing-evidence-collector.md

@@ -47,7 +47,9 @@ You are **EvidenceQA**, a skeptical QA specialist who requires visual proof for
 # 2. Check what's actually built
 ls -la resources/views/ || ls -la *.html
 
-# 3. Reality check for claimed features  
+# 3. Reality check for claimed features (monograph-first, grep fallback)
+# Preferred: monograph_query({ query: "luxury premium glass morphism" })
+# Fallback:
 grep -r "luxury\|premium\|glass\|morphism" . --include="*.html" --include="*.css" --include="*.blade.php" || echo "NO PREMIUM FEATURES FOUND"
 
 # 4. Review comprehensive test results

package/packages/@monomind/cli/.claude/commands/mastermind/_repeat.md

@@ -326,12 +326,31 @@ RECENT_HIL=$(find . -maxdepth 3 \( -name "humaninloop*.md" -o -name "humaninloop
 
 After each run in tillend mode, evaluate whether this run produced **zero findings and zero actions**. The loop stops only when a complete round finds nothing new and makes no changes — not when the AI predicts there is nothing left.
 
-**You (the AI running the loop) must now assess your own output from this run.** Answer these two questions:
+<EXTREMELY-IMPORTANT>
+**Anti-premature-stop rules:**
+- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
+- "There's nothing more to find" is a PREDICTION, not an observation. Predictions do not stop loops.
+- You MUST run the git verification command below. If git shows changes, the round is non-empty. Period.
+- Only a round where git shows NO changes AND you confirm zero findings AND zero actions qualifies as empty.
+</EXTREMELY-IMPORTANT>
+
+**Step 4a — Machine verification (REQUIRED — run this command before any self-assessment):**
+
+```bash
+GIT_CHANGES=$(git diff --stat HEAD 2>/dev/null; git diff --cached --stat 2>/dev/null; git status --porcelain 2>/dev/null | grep -v '^\?\?' | head -20)
+echo "GIT_CHANGES_DURING_RUN: ${GIT_CHANGES:-NONE}"
+```
+
+If `GIT_CHANGES` is non-empty, files were modified — `TILLEND_EMPTY=false` regardless of self-assessment. Skip directly to "Otherwise" below.
+
+**Step 4b — Self-assessment (only if git shows no changes):**
+
+Only if `GIT_CHANGES` was empty, answer these two questions about this run:
 
 1. **Were any findings produced?** — issues found, problems detected, items identified, things flagged, errors reported, tasks discovered, security vulnerabilities found, etc.
-2. **Were any actions taken?** — files edited, code fixed, tasks created, cards moved, commits made, content written, configs changed, etc.
+2. **Were any actions taken?** — tasks created, content written, configs changed — anything not captured by git diff.
 
-**Set `TILLEND_EMPTY=true` only if BOTH answers are "no" — zero findings AND zero actions this round.**
+**Set `TILLEND_EMPTY=true` only if git shows no changes AND BOTH answers are "no".**
 
 **Important:** If this round found things AND fixed them all, `TILLEND_EMPTY=false`. The loop must run once more to verify the fixes didn't introduce new issues. A "clean" prediction after a productive round is not enough — only an actually empty round stops the loop.
 

package/packages/@monomind/cli/.claude/commands/mastermind/architect.md

@@ -49,4 +49,4 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -d '{"type":"session:complete","session":"<sessionId>","domain":"architect","status":"<status>","domains":["architect"],"ts":'"$(date +%s)"'000}' || true
 ```
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/autodev.md

@@ -25,4 +25,4 @@ Invoke `Skill("mastermind-skills:autodev")` passing: brain_context, count, newfe
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `autodev`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/build.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:build")` passing: brain_context, prompt, projec
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `build`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/code-review.md

@@ -66,10 +66,10 @@ Based on `STACK`, determine which specialist agents to run beyond the always-on
 - `Security Engineer` — injection, auth gaps, secrets exposure, CVE-prone patterns, OWASP Top 10
 - `Reality Checker` — evidence-based assessment: does the code actually do what it claims?
 
-**Run conditionally** — detect by running these checks and adding the agent if exit 0:
-- `Accessibility Auditor` — `find . -maxdepth 5 \( -name "*.html" -o -name "*.jsx" -o -name "*.tsx" \) -not -path "*/node_modules/*" | head -1 | grep -q .`
-- `API Tester` — `find . -maxdepth 5 \( -name "*.route.*" -o -name "openapi.yml" -o -name "openapi.json" -o -name "swagger.*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "express\(|fastify|hono|koa|router\." --include="*.ts" --include="*.js" . 2>/dev/null`
-- `Database Optimizer` — `find . -maxdepth 5 \( -name "*.sql" -o -name "*migration*" -o -name "*schema*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "prisma|typeorm|sequelize|drizzle|knex" --include="*.ts" --include="*.js" . 2>/dev/null`
+**Run conditionally** — use `monograph_query` first to detect stack; fall back to find/grep if monograph returns 0 results:
+- `Accessibility Auditor` — `monograph_query({ query: "html jsx tsx component" })` or `find . -maxdepth 5 \( -name "*.html" -o -name "*.jsx" -o -name "*.tsx" \) -not -path "*/node_modules/*" | head -1 | grep -q .`
+- `API Tester` — `monograph_query({ query: "express fastify hono koa router route openapi swagger" })` or `find . -maxdepth 5 \( -name "*.route.*" -o -name "openapi.yml" -o -name "openapi.json" -o -name "swagger.*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "express\(|fastify|hono|koa|router\." --include="*.ts" --include="*.js" . 2>/dev/null`
+- `Database Optimizer` — `monograph_query({ query: "prisma typeorm sequelize drizzle knex sql migration schema" })` or `find . -maxdepth 5 \( -name "*.sql" -o -name "*migration*" -o -name "*schema*" \) -not -path "*/node_modules/*" | head -1 | grep -q . || grep -rqEl "prisma|typeorm|sequelize|drizzle|knex" --include="*.ts" --include="*.js" . 2>/dev/null`
 - `SRE` — `find . -maxdepth 3 \( -name "Dockerfile" -o -name "docker-compose*" -o -name "*.yml" -path "*/.github/workflows/*" \) | head -1 | grep -q .`
 - `Mobile App Builder` — `find . -maxdepth 3 \( -name "*.swift" -o -name "*.kt" \) | head -1 | grep -q . || grep -q "react-native" package.json 2>/dev/null`
 
@@ -311,4 +311,4 @@ If `ALL_HIL` is empty, omit the HIL section and congratulate:
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/debug.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:debug")` passing: brain_context, problem_descri
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `debug`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/help.md

@@ -97,8 +97,8 @@ mcp__monomind__memory_store({ key: "...", value: "...", namespace: "..." })
 mcp__monomind__memory_search({ query: "...", namespace: "..." })
 
 // Knowledge graph
-mcp__monomind__graphify_suggest({ task: "..." })
-mcp__monomind__graphify_query({ query: "..." })
+mcp__monomind__monograph_suggest({ task: "..." })
+mcp__monomind__monograph_query({ query: "..." })
 
 // Swarm
 mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })

package/packages/@monomind/cli/.claude/commands/mastermind/idea.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:idea")` passing: brain_context, prompt, project
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `idea`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/improve.md

@@ -339,4 +339,4 @@ Skill("mastermind-skills:do", "--monotask --space $SPACE_ID --board $TASK_BOARD_
 
 To repeat this command on a schedule, wrap it with `/mastermind:repeat` or use `--repeat N` / `--tillend` directly.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/okf-export.md

@@ -0,0 +1,14 @@
+<!-- Export the Second Brain knowledge base as a portable OKF (Open Knowledge Format) bundle. -->
+
+Parse `$ARGUMENTS` for:
+- `--output <dir>` or `-o <dir>` → output directory (default: `.monomind/knowledge-export`)
+- `--scope <name>` or `-s <name>` → knowledge scope (default: `shared`)
+- Remaining positional arg → treated as output directory
+
+Run the export:
+
+```bash
+npx monomind doc export -o "<output_dir>" -s "<scope>"
+```
+
+After completion, report what was exported and where. If 0 documents exported, suggest `monomind doc ingest <path>` first.

package/packages/@monomind/cli/.claude/commands/mastermind/okf-import.md

@@ -0,0 +1,15 @@
+<!-- Import an OKF (Open Knowledge Format) bundle into the Second Brain knowledge base. -->
+
+Parse `$ARGUMENTS` for:
+- `--scope <name>` or `-s <name>` → knowledge scope (default: `shared`)
+- Remaining positional arg → bundle directory path (REQUIRED)
+
+If no bundle directory provided, ask: "Which directory contains the OKF bundle to import?"
+
+Run the import:
+
+```bash
+npx monomind doc ingest "<bundle_dir>" -s "<scope>"
+```
+
+After completion, report files processed, chunks indexed, and any errors. If the bundle directory doesn't exist or contains no `.md` files, say so.

package/packages/@monomind/cli/.claude/commands/mastermind/plan.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:plan")` passing: brain_context, params, project
 
 After skill returns: follow `_protocol.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/research.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:research")` passing: brain_context, prompt, pro
 
 After skill returns: follow _protocol.md Brain Write Procedure for domain `research`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/review.md

@@ -18,6 +18,17 @@ Default mode for this command: **auto** (unless `--confirm` flag present or inta
 
 Invoke `Skill("mastermind-skills:review")` passing: brain_context, prompt, project_name, board_id (create if needed), mode.
 
+**After review findings are collected — AUTO-FIX STEP (mode = auto only):**
+
+When `mode = auto` (the default): if the review produced any fixable findings (code issues, bugs, style problems, security vulnerabilities with clear fixes), apply the fixes immediately in this same run. Do not ask the user whether to fix — auto mode means fix without asking. Specifically:
+1. For each fixable finding, edit the file directly to resolve it.
+2. After all fixes are applied, output a summary: `[review] Auto-fixed N issues. Remaining M issues require manual intervention.`
+3. Non-fixable findings (architectural concerns, design questions, trade-off decisions) are reported but not acted on.
+
+When `mode = confirm`: present findings and ask the user which to fix. This is the ONLY mode where asking is appropriate.
+
+**When `--tillend` is active:** auto-fix is especially critical. Without it, the loop finds the same unfixed issues every round and either loops forever or the AI falsely declares an empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
+
 After skill returns: follow _protocol.md Brain Write Procedure for domain `review`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/runorg.md

@@ -133,7 +133,7 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 Follow _protocol.md Brain Write Procedure for domain `ops`.
 
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.
 
 After the REPEAT POSTAMBLE completes, if a loop was started or continued (LOOP_ID is set), write the org name into the loop state file so the dashboard can detect running status:
 ```bash

package/packages/@monomind/cli/.claude/commands/mastermind/taskdev.md

@@ -20,4 +20,4 @@ Invoke `Skill("mastermind-skills:taskdev")` passing: brain_context, plan_file, p
 
 After skill returns: follow `_protocol.md` Brain Write Procedure.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/tdd.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:tdd")` passing: brain_context, feature_or_bug,
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `tdd`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/commands/mastermind/verify.md

@@ -16,4 +16,4 @@ Invoke `Skill("mastermind-skills:verify")` passing: brain_context, claim_or_task
 
 After skill returns: follow `_protocol.md` Brain Write Procedure for domain `verify`.
 
-Invoke `Skill("mastermind-skills:_repeat")` now to execute the REPEAT POSTAMBLE. This is a required tool call — do not skip it.
+**MANDATORY — invoke `Skill("mastermind-skills:_repeat")` now.** This is required regardless of how the skill above completed, regardless of whether you think the work is done, regardless of whether you plan to end your response. For `--repeat N`: the count is non-negotiable — all N runs must happen. For `--tillend`: only a verified empty round (confirmed by git diff) stops the loop. Do not end your response without invoking this skill.

package/packages/@monomind/cli/.claude/helpers/graphify-freshen.cjs

@@ -70,27 +70,23 @@ if (!entryPoint) {
 const dbPath = path.join(projectDir, '.monomind', 'monograph.db');
 if (fs.existsSync(dbPath)) {
   try {
-    const mod = (() => {
-      try { return require(path.join(projectDir, 'packages', '@monomind', 'monograph', 'dist', 'src', 'index.js')); } catch {}
-      try { return require('@monoes/monograph'); } catch {}
-      return null;
-    })();
-    if (mod && mod.openDb) {
-      const db = mod.openDb(dbPath);
-      try {
-        const row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get();
-        if (row && row.value) {
-          const { execSync } = require('child_process');
-          const behind = parseInt(execSync('git rev-list --count ' + row.value + '..HEAD 2>/dev/null', {
-            cwd: projectDir, encoding: 'utf-8', timeout: 2000
-          }).trim(), 10) || 0;
-          if (behind === 0) {
-            console.log('[graph] index is fresh — skipping rebuild');
-            process.exit(0);
-          }
+    const Database = require(require.resolve('better-sqlite3', { paths: [path.dirname(entryPoint)] }));
+    const db = new Database(dbPath, { readonly: true, timeout: 5000 });
+    try {
+      const row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get();
+      if (row && row.value && /^[0-9a-f]{7,40}$/i.test(row.value)) {
+        const { execFileSync } = require('child_process');
+        const out = execFileSync('git', ['rev-list', '--count', row.value + '..HEAD'], {
+          cwd: projectDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        const behind = parseInt(out, 10);
+        if (behind === 0) {
+          console.log('[graph] index is fresh — skipping rebuild');
+          db.close();
+          process.exit(0);
         }
-      } finally { mod.closeDb(db); }
-    }
+      }
+    } finally { try { db.close(); } catch {} }
   } catch { /* can't check — proceed with build */ }
 }
 

package/packages/@monomind/cli/.claude/helpers/handlers/agent-start-handler.cjs

@@ -65,44 +65,19 @@ module.exports = {
       );
     } catch (e) { /* non-fatal — never block a subagent from starting */ }
 
-    // Subagent context inheritance — inject graph god nodes + parent's last
-    // pre-resolved suggestions so the spawned agent inherits spatial map.
+    // monolean: compact single-line graph context instead of multi-line map.
+    // Subagents get task-relevant files only — god nodes are noise for a focused task.
     try {
-      var subDb = _openMonographDb();
-      if (subDb) {
-        try {
-          var godRows = subDb.prepare(
-            "SELECT n.name, n.label, n.file_path AS file, " +
-            "(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg " +
-            "FROM nodes n " +
-            "WHERE n.label NOT IN ('Concept') AND n.file_path IS NOT NULL AND n.file_path != '' " +
-            "ORDER BY deg DESC LIMIT 5"
-          ).all();
-          if (godRows.length > 0) {
-            console.log('[MONOGRAPH_SUBAGENT_CTX] Graph map inherited from parent:');
-            for (var gi = 0; gi < godRows.length; gi++) {
-              var gr = godRows[gi];
-              console.log('  · ' + gr.name + ' [' + gr.label + '] — ' + (gr.file || '') + ' (deg ' + gr.deg + ')');
-            }
-            try {
-              var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
-              if (subAgentDesc && subAgentDesc.length > 8) {
-                var subHints = getMonographSuggestions(subAgentDesc, 3);
-                if (subHints.length > 0) {
-                  console.log('  Top files for this subagent task:');
-                  for (var si2 = 0; si2 < subHints.length; si2++) {
-                    var sh = subHints[si2];
-                    console.log('    · ' + sh.name + ' [' + sh.label + '] — ' + (sh.file || ''));
-                  }
-                }
-              }
-            } catch (_) {}
-            console.log('  Use mcp__monomind__monograph_suggest / monograph_query in this subagent before grepping.');
-          }
-        } catch (e) { /* non-fatal */ }
+      var subAgentDesc = hookInput.description || hookInput.prompt_description || '';
+      if (subAgentDesc && subAgentDesc.length > 8) {
+        var subHints = getMonographSuggestions(subAgentDesc, 3);
+        if (subHints.length > 0) {
+          var parts = subHints.map(function(s) {
+            return s.name + ' [' + s.label + '] — ' + (s.file || '');
+          });
+          console.log('[MONOGRAPH] Top files: ' + parts.join(' · '));
+        }
       }
     } catch (e) { /* non-fatal */ }
-
-    console.log('[OK] Agent registered');
   },
 };

package/packages/@monomind/cli/.claude/helpers/handlers/capture-handler.cjs

@@ -370,6 +370,84 @@ async function handleSubagentStop(hookInput) {
       ts: Date.now(),
     }) + '\n');
   }
+
+  // ── Wire captured interaction into EpisodicStore ────
+  try {
+    var episodicPath = path.join(CWD, '.monomind', 'episodic', 'episodes.jsonl');
+    var episodicDir = path.dirname(episodicPath);
+    if (!fs.existsSync(episodicDir)) fs.mkdirSync(episodicDir, { recursive: true });
+
+    // Append a lightweight episode entry directly (avoid importing @monomind/memory)
+    var episodeEntry = {
+      episodeId: require('crypto').randomUUID(),
+      sessionId: session || '',
+      runIds: [runId || 'unknown'],
+      summary: [
+        '[agent:' + (agentType || 'unknown') + ']',
+        summary ? summary.slice(0, 500) : '',
+        totalTin ? '[memory:write] tokens_in=' + totalTin : '',
+        totalTout ? '[memory:write] tokens_out=' + totalTout : ''
+      ].filter(Boolean).join('\n'),
+      startedAt: snap.ts || Date.now(),
+      endedAt: Date.now(),
+      agentSlugs: [agentType || 'unknown'],
+      taskTypes: [agentType || 'unknown'],
+      tokenEstimate: Math.ceil(((summary || '').length) / 4)
+    };
+    fs.appendFileSync(episodicPath, JSON.stringify(episodeEntry) + '\n', 'utf-8');
+  } catch (e) { /* non-fatal */ }
+
+  // ── Record agent interaction in Monograph SQLite ────────────────────────────
+  try {
+    var mgDbPath = path.join(CWD, '.monomind', 'monograph.db');
+    if (fs.existsSync(mgDbPath)) {
+      var monographMod = null;
+      var mgCandidates = [
+        path.join(CWD, 'node_modules/.pnpm/node_modules/@monoes/monograph'),
+        path.join(CWD, 'packages/node_modules/.pnpm/node_modules/@monoes/monograph'),
+        path.join(CWD, 'node_modules/@monoes/monograph'),
+      ];
+      for (var mi = 0; mi < mgCandidates.length; mi++) {
+        try { if (fs.existsSync(mgCandidates[mi])) { monographMod = require(mgCandidates[mi]); break; } } catch (e2) {}
+      }
+      if (!monographMod) { try { monographMod = require('@monoes/monograph'); } catch (e2) {} }
+      if (monographMod && monographMod.openDb) {
+        var mgDb = monographMod.openDb(mgDbPath);
+        try {
+          mgDb.prepare(
+            'INSERT OR IGNORE INTO agent_interactions ' +
+            '(id, session_id, org_name, agent_type, parent_agent, prompt_summary, result_summary, tokens_in, tokens_out, cost_usd, success, duration_ms, timestamp) ' +
+            'VALUES (@id, @session_id, @org_name, @agent_type, @parent_agent, @prompt_summary, @result_summary, @tokens_in, @tokens_out, @cost_usd, @success, @duration_ms, @timestamp)'
+          ).run({
+            id: require('crypto').randomUUID(),
+            session_id: session || '',
+            org_name: org || null,
+            agent_type: agentType || 'unknown',
+            parent_agent: null,
+            prompt_summary: agentDesc ? agentDesc.slice(0, 500) : null,
+            result_summary: summary ? summary.slice(0, 1000) : null,
+            tokens_in: totalTin || 0,
+            tokens_out: totalTout || 0,
+            cost_usd: costUsd || 0,
+            success: (function() {
+              // Determine success from result summary — errors/failures/exceptions indicate failure
+              if (summary) {
+                var sumLower = summary.toLowerCase();
+                if (sumLower.includes('error') || sumLower.includes('failed') || sumLower.includes('exception') || sumLower.includes('fatal')) {
+                  return 0;
+                }
+              }
+              return 1;
+            })(),
+            duration_ms: snap.ts ? (Date.now() - snap.ts) : 0,
+            timestamp: Date.now(),
+          });
+        } finally {
+          if (monographMod.closeDb) monographMod.closeDb(mgDb);
+        }
+      }
+    }
+  } catch (e) { /* non-fatal — monograph may not be available */ }
 }
 
 // ─── Phase 3: PreToolUse accumulator (Issue 9) ────────────────────────────────
@@ -424,6 +502,38 @@ async function handlePostTool(hookInput) {
 
   const isBash = toolName === 'bash' || toolName === 'shell';
   const isEdit = toolName === 'edit' || toolName === 'write' || toolName === 'multiedit';
+  const isMemoryStore = toolName.includes('memory_store') || toolName.includes('memory_pattern');
+  const isMemorySearch = toolName.includes('memory_search') || toolName.includes('memory_retrieve');
+
+  // Track real memory ops (writes stats to session file)
+  if (isMemoryStore || isMemorySearch) {
+    try {
+      var sessionId = process.env.CLAUDE_SESSION_ID || '';
+      var statsPath = path.join(CWD, '.monomind', 'memory-ops-' + sessionId.slice(0, 16) + '.json');
+      var stats = { writes: 0, searches: 0, redundantWrites: 0, emptySearches: 0 };
+      try { stats = JSON.parse(fs.readFileSync(statsPath, 'utf-8')); } catch {}
+      if (isMemoryStore) {
+        stats.writes++;
+        // Detect duplicate: response contains "already exists" or "duplicate"
+        var respStr = JSON.stringify(toolResponse).toLowerCase();
+        if (respStr.includes('duplicate') || respStr.includes('already exists') || respStr.includes('skip')) {
+          stats.redundantWrites++;
+        }
+      }
+      if (isMemorySearch) {
+        stats.searches++;
+        // Detect empty results
+        var results = toolResponse.results || toolResponse.entries || toolResponse.data;
+        if (Array.isArray(results) && results.length === 0) {
+          stats.emptySearches++;
+        } else if (toolResponse.count === 0 || toolResponse.total === 0) {
+          stats.emptySearches++;
+        }
+      }
+      fs.mkdirSync(path.dirname(statsPath), { recursive: true });
+      fs.writeFileSync(statsPath, JSON.stringify(stats), 'utf-8');
+    } catch (e) { /* non-fatal */ }
+  }
 
   if (!isBash && !isEdit) return;