monomind 1.18.13 → 1.19.0

package/packages/@monomind/cli/.claude/helpers/utils/monograph.cjs

@@ -49,11 +49,28 @@ function _suggestCacheSet(key, value) {
   }
   _suggestCache._map[key] = value;
 }
+function _isValidDb(p) {
+  try { return fs.statSync(p).size >= 100; } catch (_) { return false; }
+}
+
+function _resolveDbPath() {
+  // monolean: try CWD first, then git root, so hooks work from any subdirectory
+  var candidate = path.join(CWD, '.monomind', 'monograph.db');
+  if (_isValidDb(candidate)) return candidate;
+  try {
+    var { execSync } = require('child_process');
+    var root = execSync('git rev-parse --show-toplevel', { cwd: CWD, encoding: 'utf-8', timeout: 2000 }).trim();
+    candidate = path.join(root, '.monomind', 'monograph.db');
+    if (_isValidDb(candidate)) return candidate;
+  } catch (_) {}
+  return null;
+}
+
 function _openMonographDb() {
   if (_cachedMonographDb !== undefined) return _cachedMonographDb;
   try {
-    var dbPath = path.join(CWD, '.monomind', 'monograph.db');
-    if (!fs.existsSync(dbPath)) { _cachedMonographDb = null; return null; }
+    var dbPath = _resolveDbPath();
+    if (!dbPath) { _cachedMonographDb = null; return null; }
     var mod = _requireMonograph();
     if (!mod || !mod.openDb) { _cachedMonographDb = null; return null; }
     _cachedMonographDb = mod.openDb(dbPath);
@@ -189,27 +206,30 @@ function _isGraphFresh() {
   if (_graphFreshnessCache !== undefined) return _graphFreshnessCache;
   try {
     var db = _openMonographDb();
-    if (!db) { _graphFreshnessCache = true; return true; }
+    if (!db) { _graphFreshnessCache = false; return false; }
     var row = null;
     try {
       row = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get() ||
             db.prepare("SELECT value FROM index_meta WHERE key='lastCommit'").get();
     } catch (_) {}
     if (!row || !row.value) {
-      // No commit hash → can't check staleness, but DB may still have useful data
-      var nodeCount = 0;
-      try { nodeCount = db.prepare('SELECT COUNT(*) AS c FROM nodes').get().c; } catch (_) {}
-      _graphFreshnessCache = nodeCount > 0;
-      return _graphFreshnessCache;
+      _graphFreshnessCache = false;
+      return false;
     }
-    var { execSync } = require('child_process');
-    var out = execSync('git rev-list --count ' + row.value + '..HEAD 2>/dev/null', {
-      encoding: 'utf-8', timeout: 1500, stdio: ['pipe', 'pipe', 'pipe']
+    if (!/^[0-9a-f]{7,40}$/i.test(row.value)) {
+      _graphFreshnessCache = false;
+      return false;
+    }
+    var { execFileSync } = require('child_process');
+    var out = execFileSync('git', ['rev-list', '--count', row.value + '..HEAD'], {
+      encoding: 'utf-8', timeout: 1500, stdio: ['pipe', 'pipe', 'pipe'], cwd: CWD
     }).trim();
-    var behind = parseInt(out, 10) || 0;
+    var behind = parseInt(out, 10);
+    if (isNaN(behind)) { _graphFreshnessCache = false; return false; }
     _graphFreshnessCache = behind <= 50;
   } catch(e) {
-    _graphFreshnessCache = true; // can't check → assume fresh
+    // Don't cache transient errors — let next call retry
+    return false;
   }
   return _graphFreshnessCache;
 }
@@ -369,21 +389,18 @@ function injectGodNodesContext(CWD) {
       // Precompute degree via indexed edge lookups to avoid O(N) correlated subquery
       var godNodes = db.prepare(
         "WITH deg AS (" +
-        "  SELECT id, cnt FROM (" +
+        "  SELECT id, SUM(cnt) AS deg FROM (" +
         "    SELECT source_id AS id, COUNT(*) AS cnt FROM edges GROUP BY source_id " +
         "    UNION ALL " +
         "    SELECT target_id AS id, COUNT(*) AS cnt FROM edges GROUP BY target_id" +
         "  ) GROUP BY id" +
-        "  HAVING SUM(cnt) > 0" +
-        "), ranked AS (" +
-        "  SELECT d.id, SUM(d.cnt) AS deg FROM deg d GROUP BY d.id ORDER BY deg DESC LIMIT 50" +
         ") " +
-        "SELECT n.name, n.label, n.file_path, r.deg " +
-        "FROM ranked r JOIN nodes n ON n.id = r.id " +
+        "SELECT n.name, n.label, n.file_path, d.deg " +
+        "FROM deg d JOIN nodes n ON n.id = d.id " +
         "WHERE n.label NOT IN ('Concept') " +
         "AND n.file_path IS NOT NULL AND n.file_path != '' " +
         "AND n.file_path NOT LIKE '%/node_modules/%' AND n.file_path NOT LIKE '%node_modules%' " +
-        "ORDER BY r.deg DESC LIMIT 12"
+        "ORDER BY d.deg DESC LIMIT 12"
       ).all();
 
       // Staleness indicator: compare stored commit hash with current HEAD.

package/packages/@monomind/cli/.claude/skills/mastermind-skills/_repeat.md

@@ -6,6 +6,21 @@ type: protocol-skill
 
 # REPEAT POSTAMBLE
 
+<EXTREMELY-IMPORTANT>
+## MANDATORY EXECUTION — READ THIS FIRST
+
+This postamble is **not optional**. You MUST execute every step below. You MUST call ScheduleWakeup unless a legitimate stop condition is met (stop file, empty round confirmed by git, or count reached).
+
+**Anti-rationalization rules:**
+- "I think the work is done" is NOT a reason to stop. Only the checks below decide.
+- "The skill already handled everything" is NOT a reason to skip this postamble.
+- "There's nothing more to do" is NOT your decision — the tillend check decides.
+- For `--repeat N`: you MUST run all N iterations. The count is non-negotiable. You cannot stop at run 3 of 5 because you think 3 was enough.
+- For `--tillend`: you MUST continue until git AND your assessment BOTH confirm an empty round. Your feeling that "it's probably clean" is not evidence.
+
+If you are about to end your response without calling ScheduleWakeup and you have not hit a legitimate stop condition, **YOU ARE MAKING AN ERROR. Go back and call ScheduleWakeup.**
+</EXTREMELY-IMPORTANT>
+
 **If neither `tillend_mode = true` nor `repeat_count ≥ 2` was active in this invocation, stop immediately — this skill is a no-op.**
 
 Otherwise execute all steps below before ending the response.
@@ -29,12 +44,22 @@ If the stop file exists:
 
 **`LOOP_ASYNC_PENDING` escape hatch:** If the calling skill set `LOOP_ASYNC_PENDING=true` before invoking this postamble (because it spawned background agents whose results have not yet arrived), skip the empty-round check and go directly to Step 4 to schedule the next run. Output: `[tillend] Async work in flight — deferring empty-round check to run <next_rep>.`
 
-Evaluate now whether this run produced **zero findings AND zero actions**:
+**Step 2a — Machine verification (REQUIRED before any self-assessment):**
+
+Run this command to get an objective signal of whether files changed during this run:
+
+```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 your self-assessment. Skip to "Otherwise" below.
+
+**Step 2b — Self-assessment (only if git shows no changes):**
 
-- **Findings**: issues found, problems detected, items flagged, security vulnerabilities, tasks discovered, errors reported
-- **Actions**: files edited, code fixed, commits made, tasks created, configs changed, content written
+Only if `GIT_CHANGES` was empty, evaluate whether this run produced findings (issues identified, problems flagged) or actions (tasks created, content written, configs changed — anything not captured by git diff).
 
-Set `TILLEND_EMPTY=true` **only if BOTH are zero for this round**.
+Set `TILLEND_EMPTY=true` **only if git shows no changes AND your self-assessment confirms zero findings and zero actions**.
 
 **Important**: If this round found things AND fixed them, `TILLEND_EMPTY=false` — the loop must continue to verify the fixes didn't introduce new issues.
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/architect.md

@@ -251,22 +251,21 @@ _entry=${_entry:-.}
   npx --yes madge --circular "$_entry/" 2>/dev/null; } | head -20
 
 # 6. Find god files (imported by many others)
-# NOTE: This step covers JS/TS/Vue and Python only.
-# For Go, Rust, Java, and other stacks, use mcp__monomind__monograph_god_nodes instead.
-# JS/TS/Vue: skip comment lines; perl extracts module name from from '...' or from "..."
-# --exclude-dir applied at grep level so exclusions work before -h strips filenames
+# PREFERRED: use monograph (pre-computed graph index, faster and more accurate)
+# Call mcp__monomind__monograph_god_nodes({}) first.
+# Only fall back to grep below if monograph returns 0 results or the DB is not built.
+#
+# FALLBACK (grep-based, JS/TS/Vue and Python only):
 grep -rh "^[^/]*from ['\"]" . \
   --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" --include="*.vue" \
   --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=.git \
   2>/dev/null \
   | perl -ne 'if (/from\s+['"'"'"]([^'"'"'"\s]+)['"'"'"]/) { print "$1\n" }' \
   | sort | uniq -c | sort -rn | head -20
-# Python: count imports separately (no quotes in Python import syntax)
 grep -rh "^from \|^import " . --include="*.py" \
   --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=.git \
   2>/dev/null \
   | awk '{print $2}' | sed 's/,.*//' | sed 's/\..*//' | grep -v '^$' | sort | uniq -c | sort -rn | head -20
-# Note: if monograph is built, prefer mcp__monomind__monograph_god_nodes — it uses the pre-computed graph index
 ```
 
 For each finding, produce a **Deduplication Action Table**:

package/packages/@monomind/cli/.claude/skills/mastermind-skills/autodev.md

@@ -48,19 +48,22 @@ Default `count = 1`.
 
 ```bash
 git log --oneline -30
-find . -maxdepth 3 -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.md" \) \
-  ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" | head -80
 cat package.json 2>/dev/null || cat pyproject.toml 2>/dev/null || cat go.mod 2>/dev/null || true
 head -120 README.md 2>/dev/null || true
-grep -rn "<PATTERNS>" --include="*.ts" --include="*.js" --include="*.py" --include="*.go" --include="*.md" \
-  . 2>/dev/null | grep -v node_modules | grep -v dist | head -40
 ```
 
-Plus these MCP calls (also parallel):
+Plus these MCP calls (also parallel — **preferred over grep for symbol/pattern search**):
+- `mcp__monomind__monograph_query` — search for `<PATTERNS>` (see mode table below); replaces grep for symbol lookup
 - `mcp__monomind__monograph_god_nodes` — high-centrality modules (hotspots / where new features plug in)
 - `mcp__monomind__monograph_suggest` — query per mode below
 - `mcp__monomind__memory_search` — namespace `"mastermind:autodev"`, to exclude already-built work
 
+**Fallback only** (if monograph returns 0 results or DB not built):
+```bash
+grep -rn "<PATTERNS>" --include="*.ts" --include="*.js" --include="*.py" --include="*.go" --include="*.md" \
+  . 2>/dev/null | grep -v node_modules | grep -v dist | head -40
+```
+
 Mode-specific values:
 
 | | Improvement loop | Feature pipeline |

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

@@ -148,11 +148,14 @@ Run the test suite and adversarial probes against the live monofence-ai detector
 ```
 MONOFENCE INPUT BOUNDARY SCAN (monofence_deep flag):
 
-Step 1 — Find LLM input boundary files using these patterns:
-  grep -rl "detect\|isSafe\|prompt\|chat\|completion\|message" src/ --include="*.ts" --include="*.js"
-  find . -name "*.ts" -path "*/routes/*" -o -name "*.ts" -path "*/handlers/*" \
-         -o -name "*.ts" -path "*/controllers/*" -o -name "*.ts" -path "*/api/*" \
-         -o -name "prompt*.ts" -o -name "*chat*.ts" -o -name "*completion*.ts"
+Step 1 — Find LLM input boundary files:
+  PREFERRED: monograph_query({ query: "detect isSafe prompt chat completion message" })
+             monograph_neighbors({ name: "detect" })  // trace call chains into LLM boundaries
+  FALLBACK (if monograph returns 0 results):
+    grep -rl "detect\|isSafe\|prompt\|chat\|completion\|message" src/ --include="*.ts" --include="*.js"
+    find . -name "*.ts" -path "*/routes/*" -o -name "*.ts" -path "*/handlers/*" \
+           -o -name "*.ts" -path "*/controllers/*" -o -name "*.ts" -path "*/api/*" \
+           -o -name "prompt*.ts" -o -name "*chat*.ts" -o -name "*completion*.ts"
 
 Step 2 — For each boundary file found, extract string literals and template literals
   that flow into LLM calls (look for openai/anthropic/fetch calls).
@@ -171,8 +174,15 @@ Step 4 — Report:
 
 Also run /mastermind:do --board <board_id> to track execution.
 
-STEP 4 — COLLECT AND RETURN
-Synthesize all review findings. Return to caller:
+STEP 4 — AUTO-FIX (mode = auto only, skip for mode = confirm)
+When mode is auto: for each fixable finding from the review (code bugs, style issues, security vulnerabilities with clear fixes), apply the fix directly by editing the file. Do NOT ask the user for permission — auto mode means fix without asking. After fixing, output:
+  [review] Auto-fixed N issues. M issues remain (require manual intervention or are architectural).
+Non-fixable findings (design questions, trade-offs, architectural concerns) are reported but left untouched.
+
+When --tillend is active, this step is critical: without auto-fixing, the loop either finds the same issues every round (infinite loop) or falsely declares empty round. The tillend contract is: find → fix → verify (next round) → stop when clean.
+
+STEP 5 — COLLECT AND RETURN
+Synthesize all review findings and fixes applied. Return to caller:
 
 domain: review
 status: complete | partial | blocked
@@ -183,12 +193,14 @@ decisions:
   - what: [critical findings and recommended actions]
     why: [evidence from review]
     confidence: [0.0-1.0]
-    outcome: pending
+    outcome: fixed | pending | manual
 lessons:
   - what_worked: [which review angles surfaced the most value]
   - what_didnt: [gaps in review coverage]
+fixes_applied: [count of auto-fixed issues]
+fixes_remaining: [count of issues needing manual intervention]
 next_actions:
-  - [e.g. "run mastermind:build to fix critical issues found"]
+  - [e.g. "re-run review to verify fixes" if tillend is active]
   - [e.g. "run mastermind:release after fixes are confirmed"]
 board_url: monotask://<project_name>/review
 run_id: <ISO8601-timestamp>`,
@@ -203,8 +215,10 @@ run_id: <ISO8601-timestamp>`,
 For simple tasks (single reviewer, single artifact):
 
 1. Spawn one Task agent with the review request as a self-contained briefing
-2. Collect output
-3. Return unified output schema with `status: complete`
+2. Collect findings
+3. **If mode = auto**: apply fixes for all fixable findings directly (do NOT ask the user). Output: `[review] Auto-fixed N issues.`
+4. **If mode = confirm**: present findings and ask which to fix
+5. Return unified output schema with `status: complete`
 
 ---
 

package/packages/@monomind/cli/.claude/skills/mastermind-skills/techport.md

@@ -75,8 +75,17 @@ find .claude -name "*.md" \
 
 ### 0B — Naming Convention Extraction (from actual monomind code)
 
-Extract the real conventions — not the stated ones — from the codebase itself:
+Extract the real conventions — not the stated ones — from the codebase itself.
 
+**Step 1 — monograph-based extraction (preferred):**
+```
+# Use monograph for exported symbol discovery
+monograph_query({ query: "export class interface" })    # all exported types
+monograph_god_nodes({})                                  # high-centrality files (naming exemplars)
+monograph_stats({})                                      # node counts by type
+```
+
+**Step 2 — grep fallback (only if monograph returns 0 results or DB not built):**
 ```bash
 BASE=packages/@monomind/cli/src
 
@@ -143,10 +152,20 @@ Domain vocab:       Agent, Memory, Swarm, Config, Node, Graph, Session, Task, Wo
 
 ### 0C — Dependency Direction Constraints
 
+**Preferred: monograph-based dependency analysis:**
+```
+# Use monograph for dependency direction mapping
+monograph_community({})                              # module clusters with import directions
+monograph_context({ name: "types" })                 # 360° view: importers vs imports
+monograph_context({ name: "utils" })
+monograph_context({ name: "core" })
+monograph_context({ name: "commands" })
+monograph_context({ name: "services" })
+```
+
+**Fallback (only if monograph unavailable):**
 ```bash
 BASE=packages/@monomind/cli/src
-
-# Map import directions by directory layer
 for dir in types utils core commands services; do
   count=$(grep -rn "^import" "$BASE/$dir" --include="*.ts" 2>/dev/null | wc -l)
   refs=$(grep -rn "from.*/$dir/" "$BASE" --include="*.ts" 2>/dev/null | wc -l)
@@ -160,6 +179,13 @@ Extract the implied layering from the import ratio. High `imported_by` → leaf/
 
 ### 0D — Build Monomind Vocabulary Name Set (for collision detection)
 
+**Preferred: monograph-based symbol enumeration:**
+```
+monograph_query({ query: "export class interface function const type enum" })
+# Extract names from results for collision checking
+```
+
+**Fallback (only if monograph unavailable):**
 ```bash
 grep -rhn "^export" packages/@monomind/cli/src \
   --include="*.ts" | grep -v dist | \
@@ -200,6 +226,14 @@ Set `source_brand` to the PascalCase result (e.g., `Monomind`, `ClaudeFlow`, `So
 
 ### 1B — Repo-Map (Structural Index)
 
+**If source project has a monograph index** (check with `monograph_health` against source_path):
+```
+monograph_query({ query: "export class interface function" })  # all exported symbols
+monograph_god_nodes({})                                         # high-centrality files
+monograph_community({})                                         # module structure
+```
+
+**Otherwise (foreign project without monograph — grep is expected here):**
 ```bash
 # File tree
 find "{source_path}" -maxdepth 4 \

package/packages/@monomind/cli/.claude/skills/monodesign/document.md

@@ -16,15 +16,18 @@ Read `reference/document.md` from the monodesign skill directory for the full pr
 
 ## Discovery
 
-**Extract from codebase:**
+**Extract from codebase (monograph-first):**
+```
+# Preferred: monograph for design token discovery
+monograph_query({ query: "CSS custom properties variables tokens" })
+monograph_query({ query: "font-family font-face typography" })
+monograph_query({ query: "color theme palette" })
+```
+
+**Fallback (if monograph returns 0 results or DB not built):**
 ```bash
-# Find CSS custom properties
 grep -r "^--" src/ --include="*.css" --include="*.scss" -h | sort -u
-
-# Find font declarations
 grep -r "font-family\|@font-face\|@import.*font" src/ -h | sort -u
-
-# Find color values
 grep -rE "#[0-9a-fA-F]{3,8}|oklch\(|rgb\(|hsl\(" src/ -h | sort -u | head -50
 ```
 

package/packages/@monomind/cli/.claude/skills/monodesign/extract.md

@@ -17,7 +17,7 @@ Every codebase with more than a few pages has an implicit design system — inco
 ## Discovery Phase
 
 **Color inventory**
-- Collect all color values used in the codebase (grep for `#`, `rgb`, `hsl`, `oklch`)
+- Collect all color values used in the codebase (use `monograph_query({ query: "color rgb hsl oklch" })` first; fall back to grep for `#`, `rgb`, `hsl`, `oklch` if monograph returns 0 results)
 - Group by apparent purpose (backgrounds, text, accents, borders, shadows)
 - Identify the brand anchor color(s)
 - Spot inconsistencies (5 slightly different grays)

package/packages/@monomind/cli/.claude/skills/monodesign/reference/document.md

@@ -81,7 +81,7 @@ Decide by scanning first (Scan mode Step 1). If the scan finds no tokens, no com
 
 Search the codebase in priority order:
 
-1. **CSS custom properties**: grep for `--color-`, `--font-`, `--spacing-`, `--radius-`, `--shadow-`, `--ease-`, `--duration-` declarations in CSS files (usually `src/styles/`, `public/css/`, `app/globals.css`, etc.). Record name, value, and the file it's defined in.
+1. **CSS custom properties**: use `monograph_query({ query: "color font spacing radius shadow ease duration CSS custom property" })` first; fall back to grep for `--color-`, `--font-`, `--spacing-`, `--radius-`, `--shadow-`, `--ease-`, `--duration-` declarations in CSS files if monograph returns 0 results. Record name, value, and the file it's defined in.
 2. **Tailwind config**: if `tailwind.config.{js,ts,mjs}` exists, read the `theme.extend` block for colors, fontFamily, spacing, borderRadius, boxShadow.
 3. **CSS-in-JS theme files**: styled-components, emotion, vanilla-extract, stitches; look for `theme.ts`, `tokens.ts`, or equivalent.
 4. **Design token files**: `tokens.json`, `design-tokens.json`, Style Dictionary output, W3C token community group format.

package/packages/@monomind/cli/.claude/skills/monodesign/reference/live.md

@@ -364,7 +364,7 @@ The goal is the same: give the user three variants to choose from AND persist th
 
 Use the error payload:
 
-- `element_not_in_source` with `generatedMatch: "public/docs/foo.html"`: the served HTML is generated. Find the generator (grep for writers of that path, e.g. `scripts/build-sub-pages.js`, an Astro/Next template) and locate the template or partial that emits this element.
+- `element_not_in_source` with `generatedMatch: "public/docs/foo.html"`: the served HTML is generated. Find the generator (use `monograph_query({ query: "build generate template" })` or `monograph_neighbors` to trace writers of that path; fall back to grep if monograph returns 0 results, e.g. `scripts/build-sub-pages.js`, an Astro/Next template) and locate the template or partial that emits this element.
 - `element_not_found`: the element is runtime-injected. Look for the component that renders it (React/Vue/Svelte), the JS that assembles it, or the data source that feeds it.
 - `file_is_generated` with `file: "..."`: user pointed at a generated file explicitly. Same resolution as `element_not_in_source`.
 

package/packages/@monomind/cli/.claude/skills/monolean/SKILL.md

@@ -45,7 +45,7 @@ take the higher one and move on. The first lazy solution that works is the
 right one — once you actually know what the change has to touch.
 
 **Bug fix = root cause, not symptom.** A report names a symptom. Before you
-edit, grep every caller of the function you're about to touch. The lazy fix IS
+edit, find every caller of the function you're about to touch (use `monograph_neighbors` or `monograph_impact` first; fall back to grep only if monograph returns 0 results). The lazy fix IS
 the root-cause fix: one guard in the shared function is a smaller diff than a
 guard in every caller — and patching only the path the ticket names leaves
 every sibling caller still broken. Fix it once, where all callers route through.

package/packages/@monomind/cli/bin/mcp-server.js

@@ -97,7 +97,16 @@ async function handleMessage(message) {
 
   try {
     switch (message.method) {
-      case 'initialize':
+      case 'initialize': {
+        const roots = params.roots ?? params.workspaceFolders ?? [];
+        if (roots.length > 0 && !process.env.MONOMIND_CWD) {
+          const rootUri = typeof roots[0] === 'string' ? roots[0] : (roots[0].uri ?? roots[0].path ?? '');
+          const rootPath = rootUri.startsWith('file://') ? decodeURIComponent(rootUri.slice(7)) : rootUri;
+          if (rootPath) {
+            process.env.MONOMIND_CWD = rootPath;
+            console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] Project root set to ${rootPath}`);
+          }
+        }
         return {
           jsonrpc: '2.0',
           id: message.id,
@@ -110,6 +119,7 @@ async function handleMessage(message) {
             },
           },
         };
+      }
 
       case 'tools/list': {
         const tools = listMCPTools();

package/packages/@monomind/cli/dist/src/commands/agent-ops.d.ts

@@ -1,9 +1,8 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import type { Command } from '../types.js';
 export declare const metricsCommand: Command;
 export declare const poolCommand: Command;
 export declare const healthCommand: Command;
-export declare const logsCommand: Command;
 //# sourceMappingURL=agent-ops.d.ts.map

package/packages/@monomind/cli/dist/src/commands/agent-ops.js

@@ -1,5 +1,5 @@
 /**
- * Agent operational commands — metrics, pool, health, logs
+ * Agent operational commands — metrics, pool, health
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -268,62 +268,4 @@ export const healthCommand = {
         }
     },
 };
-// ─── logs subcommand ─────────────────────────────────────────────────────────
-function formatLogLevel(level) {
-    switch (level) {
-        case 'debug': return output.dim('[DEBUG]');
-        case 'info': return '[INFO] ';
-        case 'warn': return output.warning('[WARN] ');
-        case 'error': return output.error('[ERROR]');
-        default: return `[${level.toUpperCase()}]`;
-    }
-}
-export const logsCommand = {
-    name: 'logs',
-    description: 'Show agent activity logs',
-    options: [
-        { name: 'id', short: 'i', description: 'Agent ID', type: 'string' },
-        { name: 'tail', short: 'n', description: 'Number of recent entries', type: 'number', default: 50 },
-        { name: 'level', short: 'l', description: 'Minimum log level', type: 'string', choices: ['debug', 'info', 'warn', 'error'], default: 'info' },
-        { name: 'follow', short: 'f', description: 'Follow log output', type: 'boolean', default: false },
-        { name: 'since', description: 'Show logs since (e.g., "1h", "30m")', type: 'string' },
-    ],
-    examples: [
-        { command: 'monomind agent logs -i agent-001', description: 'Show agent logs' },
-        { command: 'monomind agent logs -i agent-001 -f', description: 'Follow agent logs' },
-        { command: 'monomind agent logs -l error --since 1h', description: 'Show errors from last hour' },
-    ],
-    action: async (ctx) => {
-        const agentId = ((ctx.args[0] || ctx.flags.id) ?? '').slice(0, 128);
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level?.slice(0, 32);
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', { agentId, tail, level, since: ctx.flags.since });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                output.writeln(`${output.dim(time)} ${formatLogLevel(entry.level)} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            output.printError(error instanceof MCPClientError ? `Logs error: ${error.message}` : `Unexpected error: ${String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
 //# sourceMappingURL=agent-ops.js.map

package/packages/@monomind/cli/dist/src/commands/agent.js

@@ -4,11 +4,11 @@
  */
 import { output } from '../output.js';
 import { spawnCommand, listCommand, statusCommand, stopCommand } from './agent-lifecycle.js';
-import { metricsCommand, poolCommand, healthCommand, logsCommand } from './agent-ops.js';
+import { metricsCommand, poolCommand, healthCommand } from './agent-ops.js';
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand],
     options: [],
     examples: [
         { command: 'monomind agent spawn -t coder', description: 'Spawn a coder agent' },
@@ -30,7 +30,6 @@ export const agentCommand = {
             `${output.highlight('metrics')}       - Show agent metrics`,
             `${output.highlight('pool')}          - Manage agent pool`,
             `${output.highlight('health')}        - Show agent health`,
-            `${output.highlight('logs')}          - Show agent logs`,
         ]);
         output.writeln();
         output.writeln('Run "monomind agent <subcommand> --help" for subcommand help');

package/packages/@monomind/cli/dist/src/commands/analyze-diff.js

@@ -236,7 +236,7 @@ export const diffCommand = {
         }
     },
 };
-// Code subcommand (placeholder for future code analysis)
+// Code subcommand
 export const codeCommand = {
     name: 'code',
     description: 'Static code analysis and quality assessment',