@monoes/monomindcli 1.12.0 → 1.14.0

package/.claude/helpers/utils/monograph.cjs

@@ -25,6 +25,30 @@ function _requireMonograph() {
 // Memoized at module scope — opening monograph.db can take 7-10s.
 // Callers MUST NOT close the returned handle.
 var _cachedMonographDb = undefined;
+
+// LRU cache for getMonographSuggestions: avoids re-querying the DB for
+// the same task text within a single hook execution process lifetime.
+// Max 20 entries; evicts the least-recently-used on overflow.
+var _suggestCache = { _map: Object.create(null), _order: [], _max: 20 };
+function _suggestCacheGet(key) {
+  if (key in _suggestCache._map) {
+    // Move to end (most recently used)
+    var idx = _suggestCache._order.indexOf(key);
+    if (idx !== -1) { _suggestCache._order.splice(idx, 1); _suggestCache._order.push(key); }
+    return _suggestCache._map[key];
+  }
+  return undefined;
+}
+function _suggestCacheSet(key, value) {
+  if (!(key in _suggestCache._map)) {
+    if (_suggestCache._order.length >= _suggestCache._max) {
+      var evict = _suggestCache._order.shift();
+      delete _suggestCache._map[evict];
+    }
+    _suggestCache._order.push(key);
+  }
+  _suggestCache._map[key] = value;
+}
 function _openMonographDb() {
   if (_cachedMonographDb !== undefined) return _cachedMonographDb;
   try {
@@ -39,6 +63,10 @@ function _openMonographDb() {
 
 function getMonographSuggestions(taskText, limit) {
   if (!taskText || typeof taskText !== 'string') return [];
+  // Fast path: return cached result for repeated identical queries.
+  var cacheKey = taskText.slice(0, 200) + '|' + (limit || 5);
+  var cached = _suggestCacheGet(cacheKey);
+  if (cached !== undefined) return cached;
   var db = _openMonographDb();
   if (!db) return [];
   try {
@@ -56,7 +84,7 @@ function getMonographSuggestions(taskText, limit) {
     var rows = [];
     try {
       rows = db.prepare(
-        'SELECT n.id, n.name, n.label, n.file_path AS file, ' +
+        'SELECT n.id, n.name, n.label, n.file_path AS file, n.start_line AS startLine, ' +
         'bm25(nodes_fts) AS bm25_score, ' +
         '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg, ' +
         'CASE n.label WHEN \'File\' THEN 3 WHEN \'Function\' THEN 3 WHEN \'Class\' THEN 3 ' +
@@ -72,7 +100,7 @@ function getMonographSuggestions(taskText, limit) {
       var likeFrag = keys.map(function(){ return 'lower(n.name) LIKE ?'; }).join(' OR ');
       var likeArgs = keys.map(function(k){ return '%' + k + '%'; });
       var stmt = db.prepare(
-        'SELECT n.id, n.name, n.label, n.file_path AS file, ' +
+        'SELECT n.id, n.name, n.label, n.file_path AS file, n.start_line AS startLine, ' +
         '(SELECT COUNT(*) FROM edges WHERE source_id=n.id OR target_id=n.id) AS deg ' +
         'FROM nodes n WHERE (' + likeFrag + ') AND n.file_path IS NOT NULL AND n.file_path != \'\' ' +
         'AND n.label NOT IN (\'Concept\') ' +
@@ -80,7 +108,9 @@ function getMonographSuggestions(taskText, limit) {
       );
       rows = stmt.all.apply(stmt, likeArgs.concat([lim]));
     }
-    return rows || [];
+    var result = rows || [];
+    _suggestCacheSet(cacheKey, result);
+    return result;
   } catch (e) { return []; }
   finally { /* db is shared/cached; do not close */ }
 }
@@ -287,8 +317,13 @@ function injectGodNodesContext(CWD) {
       // Staleness indicator: compare stored commit hash with current HEAD.
       var staleIndicator = '';
       try {
+        // The orchestrator writes 'last_commit_hash'; fall back to legacy keys.
         var lastCommitRow = null;
-        try { lastCommitRow = db.prepare("SELECT value FROM index_meta WHERE key='ua_last_commit'").get(); } catch (_) {}
+        try {
+          lastCommitRow = db.prepare("SELECT value FROM index_meta WHERE key='last_commit_hash'").get() ||
+                          db.prepare("SELECT value FROM index_meta WHERE key='lastCommit'").get() ||
+                          db.prepare("SELECT value FROM index_meta WHERE key='ua_last_commit'").get();
+        } catch (_) {}
         if (lastCommitRow && lastCommitRow.value) {
           var { execFileSync: execSync } = require('child_process');
           var currentHead = '';

package/.claude/helpers/utils/telemetry.cjs

@@ -10,14 +10,14 @@ const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 function _recordRecentEdit(filePath) {
   if (!filePath) return;
   try {
-    var relPath = path.isAbsolute(filePath) ? path.relative(CWD, filePath) : filePath;
+    var storedPath = filePath;
     var f = path.join(CWD, '.monomind', 'metrics', 'recent-edits.json');
     fs.mkdirSync(path.dirname(f), { recursive: true });
     var d = { edits: [] };
     try { d = JSON.parse(fs.readFileSync(f, 'utf-8')); } catch (_) {}
     if (!Array.isArray(d.edits)) d.edits = [];
-    d.edits = d.edits.filter(function(e) { return e.file !== relPath; });
-    d.edits.unshift({ file: relPath, editedAt: Date.now() });
+    d.edits = d.edits.filter(function(e) { return e.file !== storedPath; });
+    d.edits.unshift({ file: storedPath, editedAt: Date.now() });
     if (d.edits.length > 10) d.edits = d.edits.slice(0, 10);
     fs.writeFileSync(f, JSON.stringify(d));
   } catch (e) { /* non-fatal */ }

package/.claude/skills/mastermind/createorg.md

@@ -67,12 +67,14 @@ Reject any `org_name` that does not match `^[a-z0-9][a-z0-9-]{0,63}$`.
 
 Parse `roles_desc` (if provided) into a list of role titles. If not provided, derive a set of roles from `prompt` by identifying the human functions needed to achieve the goal.
 
-**Required roles to always include** (if the prompt implies a team):
+**Required roles to always include** (if the prompt implies a team — **skip this rule for persona-based orgs** where the characters themselves define the structure; do not inject a generic coordinator into a celebrity panel):
 - A coordinator/boss role that owns the goal and makes final decisions
 - At least one executor role that does the primary work
 - A reviewer or QA role if quality output is implied
 - A communication layer (middle manager) if team size ≥ 4
 
+> ⚠ **Check Step 2.3 (Persona / Character Detection) BEFORE applying this table.** If the org is persona-based (roles are named real people, celebrities, or fictional characters), skip this table for those roles and follow Step 2.3 instead.
+
 **Role → Agent Type mapping table** (use exact `subagent_type` slug for Task tool):
 
 | User role keyword | Agent type slug | Specialty |
@@ -92,12 +94,56 @@ Parse `roles_desc` (if provided) into a list of role titles. If not provided, de
 
 If a role doesn't match any keyword **and the org's domain is far from software** (legal, medical, finance, creative, etc.), do NOT force a mismatched generic type whose instructions are about the wrong domain (e.g. a court reporter mapped to the code `reviewer`). Instead coin a role-specific `agent_type` slug from the role title (slugify: `Court Reporter` → `court-reporter`, `Prosecutor` → `prosecutor`) and generate a fitting definition for it in Step 2.5. Only fall back to `general-purpose` when no sensible slug applies.
 
+**For technical/engineering orgs** (DevBot, code quality, CI/CD, data pipelines, etc.), coin a precise domain slug for every specialized role rather than forcing it into a generic category:
+- `Churn Analyst` → `churn-analyst` (git churn analysis, not a financial analyst)
+- `Complexity Scanner` → `complexity-scanner` (static analysis, cyclomatic complexity)
+- `Impact Assessor` → `impact-assessor` (code change blast-radius scoring)
+- `Validator` → `code-validator` (applies patches, runs tests, enforces kill switch)
+- `Orchestrator` (in a devbot) → `devbot-orchestrator` (4-phase pipeline boss, not generic coordinator)
+
+The coined slug + a generated definition at `.claude/agents/generated/<slug>.md` is always better than a generic type whose system prompt talks about a completely different job.
+
+---
+
+## Step 2.3 — Persona / Character Detection (run BEFORE the mapping table above)
+
+**Before applying the mapping table above, detect whether this org is persona-based:**
+
+A role is **persona-based** if its title is:
+- A named real person (e.g. "Donald Trump", "Elon Musk", "Steve Jobs")
+- A well-known fictional character (e.g. "Sherlock Holmes", "Tony Stark")
+- A celebrity, historical figure, or public persona referred to by name
+
+An org is **persona-based** if ≥ 50% of its roles are character names, OR the goal/prompt contains keywords like: `panel`, `debate`, `simulation`, `roleplay`, `celebrity`, `character`, `virtual [name]`, `impersonate`, `as [name]`.
+
+**If persona-based:**
+
+1. **Ignore the mapping table entirely for these roles.** Do NOT map "Donald Trump" → `coder`, "Elon Musk" → `researcher`, etc.
+
+2. **Coin a character-specific `agent_type` slug** from the character's name:
+   - `Donald Trump` → `donald-trump`
+   - `Sherlock Holmes` → `sherlock-holmes`
+   - `Steve Jobs` → `steve-jobs`
+
+3. **Derive skills and expertise from what is publicly known about that person**, not from generic software roles. Use your knowledge of the person's career, public persona, communication style, known positions, and characteristic behaviors. For example:
+   - Donald Trump: negotiation, real-estate dealmaking, brand promotion, confrontational rhetoric, media manipulation, self-promotion, political populism
+   - Elon Musk: first-principles engineering, disruptive product vision, risk-taking, rapid iteration, social media provocation, space/EV technology
+   - A fictional detective: deductive reasoning, observation, criminal psychology, pattern recognition
+
+4. **The generated agent definition** (written in Step 2.5) must read as that character — their voice, stance, known views, communication style. It is a character simulation, not a generic role.
+
+5. **Non-character roles in the same org** (e.g. "Moderator", "Audience") should use the standard mapping table or a role-coined slug as appropriate.
+
+**If NOT persona-based:** proceed normally with the mapping table.
+
 ---
 
 ## Step 2.5 — Complete Every Agent's Specification (generate what's missing)
 
 **This is the step that makes each created agent actually work.** A role is only usable if it has: skills, an instruction document (system prompt), an input contract, and an output contract. Most of these are missing from a bare role description — **generate them, tailored to the specific agent, rather than leaving them blank.**
 
+**For persona/character roles** (identified in Step 2.3): the generated definition must embody the character. The system prompt should open with "You are [Character Name]" and describe their personality, known views, communication style, and behavioral quirks drawn from public knowledge. Skills must reflect their real-world expertise and traits, not generic software capabilities. If the character is a living public figure, base the portrayal on documented public behavior and statements — do not invent positions they haven't taken.
+
 For **each** role, do the following:
 
 **1. Check whether a usable agent definition already exists.**
@@ -159,6 +205,35 @@ The dashboard agent drawer and `runorg` both read these definitions (matched by
 
 ---
 
+## Step 2.6 — COMPLETENESS GATE (BLOCKING — do not proceed to Step 3 until all checks pass)
+
+This gate prevents saving an org where the dashboard will show "No instruction document" or blank skills. **Run these checks now — one Bash call per role:**
+
+For each role in the org:
+
+```bash
+# Check 1 — agent_type is set
+role_id="<role_id>"
+agent_type="<agent_type>"
+[ -z "$agent_type" ] && echo "FAIL: role '$role_id' has no agent_type" && exit 1
+
+# Check 2 — definition file exists on disk
+def_file=".claude/agents/generated/${agent_type}.md"
+# Also check non-generated paths
+fallback=$(find .claude/agents -iname "${agent_type}.md" 2>/dev/null | head -1)
+if [ ! -f "$def_file" ] && [ -z "$fallback" ]; then
+  echo "FAIL: no agent definition file for '$agent_type' — generate it now before continuing"
+  exit 1
+fi
+echo "OK: $role_id → $agent_type ✓"
+```
+
+If any check fails: go back to Step 2.5 and generate the missing file before proceeding. Do not skip this check.
+
+**Also verify the `skills` array for each role is non-empty (≥3 items).** If `skills: []` for any role, pull the expertise from the generated definition file and populate it now.
+
+---
+
 ## Step 3 — Suggest Communication Topology
 
 Determine topology from team size:
@@ -201,6 +276,32 @@ A role that ends up with no inbound or no outbound edge is a bug — re-examine
 
 ---
 
+## Step 3.5 — TOPOLOGY VALIDATION GATE (BLOCKING — do not proceed to Step 4 until all checks pass)
+
+Build the communication array now, then validate it with these checks:
+
+```bash
+# Check 1 — at least one edge exists
+edges='<communication_json_array>'
+edge_count=$(echo "$edges" | jq 'length')
+[ "$edge_count" -eq 0 ] && echo "FAIL: communication array is empty — define edges now" && exit 1
+
+# Check 2 — every role has at least one inbound OR outbound edge
+role_ids=("<id1>" "<id2>" ... )  # all role IDs
+for rid in "${role_ids[@]}"; do
+  has_edge=$(echo "$edges" | jq --arg r "$rid" '[.[] | select(.from==$r or .to==$r)] | length')
+  [ "$has_edge" -eq 0 ] && echo "FAIL: role '$rid' has no communication edges — it is an orphan" && exit 1
+done
+
+# Check 3 — every non-boss executor role has at least one inbound edge (receives work)
+# and at least one outbound edge (delivers output)
+echo "OK: topology validated — $edge_count edges, all roles wired"
+```
+
+If any check fails: go back to Step 3 and add the missing edges. **The `communication` array must be non-empty in the saved JSON** — the dashboard Chart tab draws its arrows from this array; an empty array means a blank chart with isolated nodes and no connection lines.
+
+---
+
 ## Step 4 — Build Org Config
 
 Produce an org config object using the resolved topology (not hardcoded to `hierarchical`).
@@ -222,7 +323,7 @@ Ask the user (or infer from prompt) for the optional Paperclip-style fields:
     {
       "id": "<slug>",
       "title": "<display title>",
-      "agent_type": "<subagent_type slug from mapping table>",
+      "agent_type": "<subagent_type slug — from Step 2.3 character slug for persona roles, or from mapping table for functional roles>",
       "responsibilities": ["<1-3 bullet responsibilities>"],
       "reports_to": "<role id or null>",
       "skills": ["<populated from the generated def's expertise in Step 2.5 — never left empty>"],
@@ -290,27 +391,32 @@ Render the org plan in a clear human-readable format:
 ║  GOAL: <goal>                                    ║
 ╚══════════════════════════════════════════════════╝
 
-ROLES
+ROLES  (N roles — all must have agent_type + skills before "go")
 ─────
 • [boss] CEO / Boss
-    Agent: coordinator
-    Reports to: (none — top of hierarchy)
+    Agent type:      coordinator
+    Skills:          strategic oversight, decision-making, org management
+    Reports to:      (none — top of hierarchy)
     Responsibilities: Strategic oversight, final approval
+    Definition file: .claude/agents/coordinator.md ✓
 
 • [middle_manager] Middle Manager
-    Agent: Project Shepherd
-    Reports to: boss
+    Agent type:      project-shepherd
+    Skills:          sprint planning, cross-team coordination, status tracking
+    Reports to:      boss
     Responsibilities: Sprint planning, cross-team coordination
+    Definition file: .claude/agents/generated/project-shepherd.md ✓
 
-  ... (all roles)
+  ... (all roles — each showing agent_type, skills, and definition file status)
 
-COMMUNICATION TOPOLOGY
+COMMUNICATION TOPOLOGY  (N edges — must be non-zero)
 ──────────────────────
-boss → middle_manager  (command)
-middle_manager → content_writer  (command)
-content_writer → content_reviewer  (handoff)
-content_reviewer → middle_manager  (report)
-  ... (all edges)
+boss → middle_manager           (command)
+middle_manager → content_writer (command)
+content_writer → content_reviewer (handoff)
+content_reviewer → middle_manager (report)
+middle_manager → boss           (report)
+  ... (all edges — every role must appear here at least once)
 
 SETTINGS
 ────────
@@ -427,6 +533,39 @@ jq --arg board_id "$board_id" \
    "$orgJson" > "$tmp" && mv "$tmp" "$orgJson"
 ```
 
+**POST-SAVE VALIDATION (run immediately after saving — abort if either check fails):**
+
+```bash
+# Check 1 — communication array is non-empty (dashboard Chart tab requires this for arrows)
+comm_count=$(jq '.communication | length' "$orgJson" 2>/dev/null || echo 0)
+if [ "$comm_count" -eq 0 ]; then
+  echo "ERROR: Saved org has empty communication array — dashboard Chart will show isolated nodes with no arrows."
+  echo "Fix: go back to Step 3 and Step 3.5, define edges, then re-save."
+  exit 1
+fi
+echo "✓ Communication: $comm_count edges saved"
+
+# Check 2 — every role has agent_type set
+bad_roles=$(jq -r '.roles[] | select((.agent_type // "") == "") | .id' "$orgJson" 2>/dev/null)
+if [ -n "$bad_roles" ]; then
+  echo "ERROR: These roles have no agent_type — dashboard will show '?' for each:"
+  echo "$bad_roles"
+  echo "Fix: go back to Step 2 / Step 2.5 and set agent_type for each role, then re-save."
+  exit 1
+fi
+echo "✓ All roles have agent_type set"
+
+# Check 3 — every role has skills (non-empty array)
+empty_skills=$(jq -r '.roles[] | select((.skills // []) | length == 0) | .id' "$orgJson" 2>/dev/null)
+if [ -n "$empty_skills" ]; then
+  echo "WARNING: These roles have empty skills arrays — dashboard Skills tab will show nothing:"
+  echo "$empty_skills"
+  echo "Fix: populate skills from each role's generated agent definition."
+fi
+
+echo "✓ Org config validated — org is ready to run"
+```
+
 ---
 
 ## Step 6.7 — Generate Loop Prompt File (scheduled orgs only)
@@ -472,10 +611,33 @@ tmp="${ORG_FILE}.tmp"
 jq '.loop.last_run = (now|todate)' "$ORG_FILE" > "$tmp" && mv "$tmp" "$ORG_FILE"
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
 CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
+# Unique run ID — used to thread all events in the Chat tab under one session
+RUN_ID="run-$(date -u +%Y%m%dT%H%M%S)"
+# Capture Claude project dir for per-agent token tracking
+CLAUDE_PROJECT_DIR="$HOME/.claude/projects/$(echo "$REPO_ROOT" | tr '/' '-' | sed 's/^-//')"
+
+# Comm helper — emits org:comms so Chat tab shows agent-to-agent messages
+_comm() {
+  local _from="$1" _to="$2" _msg="$3"
+  curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+    -H "Content-Type: application/json" \
+    -d "$(jq -cn \
+      --arg org "<org_name>" \
+      --arg runId "$RUN_ID" \
+      --arg from "$_from" \
+      --arg to "$_to" \
+      --arg msg "$_msg" \
+      '{type:"org:comms",org:$org,runId:$runId,from:$from,to:$to,msg:$msg,ts:(now*1000|floor)}')" || true
+}
+
+# Register this run with the server — creates run file and enables Chat tab dropdown
 curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
   -H "Content-Type: application/json" \
-  -d "$(jq -cn --arg org "<org_name>" --arg proj "$REPO_ROOT" \
-    '{type:"org:loop:start",org:$org,project:$proj,ts:(now*1000|floor)}')" || true
+  -d "$(jq -cn \
+    --arg org "<org_name>" \
+    --arg runId "$RUN_ID" \
+    --arg goal "<goal>" \
+    '{type:"run:start",org:$org,runId:$runId,goal:$goal,ts:(now*1000|floor)}')" || true
 ```
 
 ---
@@ -488,6 +650,55 @@ curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
 <For a content org, these would be: check content calendar, assign writers, review drafts, publish.>
 <Derive from orgConfig.goal and orgConfig.roles[].responsibilities — be specific.>
 
+**REQUIRED — include these patterns at every agent handoff:**
+
+1. **Before spawning each agent**, snapshot the Claude project JSONL files and emit a `_comm` from the dispatching role to the receiving role describing the task:
+   ```bash
+   JSONL_SNAP_<N>=$(ls -t "$CLAUDE_PROJECT_DIR"/*.jsonl 2>/dev/null | head -20 | sort)
+   _comm "<dispatcher-role-id>" "<agent-role-id>" "Task: <what the agent is being asked to do>"
+   ```
+
+2. **After the agent returns**, emit a `_comm` from that agent back to its caller with the result summary, then emit its token usage:
+   ```bash
+   JSONL_SNAP_<N+1>=$(ls -t "$CLAUDE_PROJECT_DIR"/*.jsonl 2>/dev/null | head -20 | sort)
+   NEW_JSONL=$(comm -13 <(echo "$JSONL_SNAP_<N>") <(echo "$JSONL_SNAP_<N+1>") | head -1)
+   _comm "<agent-role-id>" "<dispatcher-role-id>" "Result: <one-sentence summary of what the agent returned>"
+   if [ -n "$NEW_JSONL" ] && [ -f "$NEW_JSONL" ]; then
+     USAGE=$(python3 -c "
+   import json, sys
+   tin=tout=0
+   for l in open(sys.argv[1]):
+     try:
+       d=json.loads(l)
+       u=d.get('message',{}).get('usage',{})
+       tin+=u.get('input_tokens',0); tout+=u.get('output_tokens',0)
+     except: pass
+   cost=tin*3e-6+tout*15e-6
+   print(json.dumps({'tokens_in':tin,'tokens_out':tout,'cost_usd':round(cost,6)}))
+   " "$NEW_JSONL" 2>/dev/null || echo '{"tokens_in":0,"tokens_out":0,"cost_usd":0}')
+     curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+       -H "Content-Type: application/json" \
+       -d "$(echo "$USAGE" | jq \
+         --arg org "<org_name>" \
+         --arg role "<agent-role-id>" \
+         --arg runId "$RUN_ID" \
+         '. + {type:"agent:usage",org:$org,role:$role,runId:$runId,ts:(now*1000|floor|tostring|tonumber)}')" || true
+   fi
+   ```
+
+3. Use the actual content from the agent's return value in the `_comm` `msg` field — not a generic placeholder. The Chat tab shows this text verbatim.
+
+4. At cycle end (before Schedule Next), emit the completion comms and event:
+   ```bash
+   _comm "<boss-role-id>" "sys" "Cycle complete: <one-line summary of what was accomplished>"
+   curl -s -X POST "${CTRL_URL}/api/mastermind/event" \
+     -H "Content-Type: application/json" \
+     -d "$(jq -cn \
+       --arg org "<org_name>" \
+       --arg runId "$RUN_ID" \
+       '{type:"org:cycle:complete",org:$org,runId:$runId,ts:(now*1000|floor)}')" || true
+   ```
+
 ---
 
 ## Schedule Next (ONLY if status is active or paused)

package/.claude/skills/mastermind/idea.md

@@ -1064,9 +1064,21 @@ Follow _protocol.md Brain Write Procedure (namespace: `idea`).
 
 ```bash
 REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
-SESSION_ID=$(jq -r '.sessionId // empty' "$REPO_ROOT/.monomind/sessions/current.json" 2>/dev/null)
+_get_mono_dir() {
+  local w="${1:-$(pwd)}"
+  if [ -d "$w/.git" ]; then echo "$w/.git/monomind"; return; fi
+  if [ -f "$w/.git" ]; then
+    local m; m=$(grep '^gitdir:' "$w/.git" | sed 's/gitdir: *//')
+    [ -z "$m" ] && { echo "$w/.monomind"; return; }
+    [[ "$m" != /* ]] && m="$w/$m"
+    echo "$(dirname "$(dirname "$m")")/monomind"; return
+  fi
+  echo "$w/.monomind"
+}
+MONO_DIR=$(_get_mono_dir "$REPO_ROOT")
+SESSION_ID=$(jq -r '.sessionId // empty' "$MONO_DIR/sessions/current.json" 2>/dev/null)
 if [ -n "$SESSION_ID" ]; then
-  mkdir -p "$REPO_ROOT/.monomind/sessions/${SESSION_ID}"
+  mkdir -p "$MONO_DIR/sessions/${SESSION_ID}"
   CTRL_URL=$(jq -r '.url // "http://localhost:4242"' "$REPO_ROOT/.monomind/control.json" 2>/dev/null || echo "http://localhost:4242")
   # LLM: substitute <status>: complete (all steps ran), partial (some skipped), blocked (critical error)
   # LLM: substitute next_actions with actual suggestions derived from this run's top ideas
@@ -1076,7 +1088,7 @@ if [ -n "$SESSION_ID" ]; then
     --argjson artifacts '[]' \
     --argjson next_actions '["<next_action_1>","<next_action_2>"]' \
     '{domain:$domain,status:$status,artifacts:$artifacts,next_actions:$next_actions}' \
-    > "$REPO_ROOT/.monomind/sessions/${SESSION_ID}/idea.json"
+    > "$MONO_DIR/sessions/${SESSION_ID}/idea.json"
   curl -s -o /dev/null -X POST "${CTRL_URL}/api/mastermind/event" \
     -H "Content-Type: application/json" \
     -d "$(jq -cn --arg sid "$SESSION_ID" --arg status "<status>" \

package/.claude/skills/mastermind/runorg.md

@@ -526,7 +526,8 @@ OPERATING LOOP:
    jq -cn --arg runId "${runId}" --arg org "${orgName}" --argjson pend "${pending_count:-0}" \
      '{type:"run:cycle:complete",runId:$runId,org:$org,pending:$pend,ts:(now*1000|floor)}' >> "${runFile}" || true
    activityFile=".monomind/orgs/${orgName}-activity.jsonl"
-   echo "{\"type\":\"run:cycle:complete\",\"org\":\"${orgName}\",\"runId\":\"${runId}\",\"ts\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",\"pending\":${pending_count:-0}}" >> "$activityFile" 2>/dev/null || true
+   jq -cn --arg org "${orgName}" --arg runId "${runId}" --argjson pend "${pending_count:-0}" \
+     '{type:"run:cycle:complete",org:$org,runId:$runId,ts:(now*1000|floor),pending:$pend}' >> "$activityFile" 2>/dev/null || true
 
 8. REQUIRED — emit org:checkpoint with a one-sentence progress summary (include runId):
    curl -s -X POST "${CTRL_URL}/api/mastermind/event" -H "Content-Type: application/json" \

package/dist/src/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AA6xB1E,eAAO,MAAM,aAAa,EAAE,OA6M3B,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAg2B1E,eAAO,MAAM,aAAa,EAAE,OA0N3B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/src/commands/doctor.js

@@ -436,6 +436,84 @@ async function checkMonograph() {
         };
     }
 }
+// Check monograph graph freshness (is the graph built? how stale?)
+async function checkMonographFreshness() {
+    try {
+        const cwd = process.cwd();
+        const dbPath = join(cwd, '.monomind', 'monograph.db');
+        const lockPath = join(cwd, '.monomind', 'graph', '.rebuild-lock');
+        const statsPath = join(cwd, '.monomind', 'graph', 'stats.json');
+        // Check if graph exists at all
+        const hasDb = existsSync(dbPath);
+        const hasLock = existsSync(lockPath);
+        const hasStats = existsSync(statsPath);
+        if (!hasDb && !hasStats) {
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: 'No monograph graph built yet',
+                fix: 'mcp__monomind__monograph_build codeOnly:true  — or run npx monomind@latest hooks graph-status',
+            };
+        }
+        // Determine last build time
+        let buildMs = 0;
+        if (hasDb) {
+            try {
+                buildMs = Math.max(buildMs, statSync(dbPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (hasLock) {
+            try {
+                buildMs = Math.max(buildMs, statSync(lockPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (hasStats) {
+            try {
+                buildMs = Math.max(buildMs, statSync(statsPath).mtimeMs);
+            }
+            catch { /* ignore */ }
+        }
+        if (buildMs === 0) {
+            return { name: 'Graph freshness', status: 'warn', message: 'Graph exists but build time unknown' };
+        }
+        // Count commits since last build
+        const buildIso = new Date(buildMs).toISOString();
+        let commitsBehind = 0;
+        try {
+            const out = execSync(`git rev-list --count --since='${buildIso}' HEAD 2>/dev/null`, {
+                encoding: 'utf8', timeout: 2000, cwd,
+            }).trim();
+            commitsBehind = parseInt(out, 10) || 0;
+        }
+        catch { /* git not available or not a git repo */ }
+        const ageMinutes = Math.floor((Date.now() - buildMs) / 60000);
+        const ageStr = ageMinutes < 60 ? `${ageMinutes}m ago` : `${Math.floor(ageMinutes / 60)}h ago`;
+        if (commitsBehind === 0) {
+            return { name: 'Graph freshness', status: 'pass', message: `FRESH — built ${ageStr}, 0 commits behind` };
+        }
+        else if (commitsBehind <= 5) {
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: `${commitsBehind} commit(s) behind — built ${ageStr}`,
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
+        }
+        else {
+            return {
+                name: 'Graph freshness',
+                status: 'fail',
+                message: `STALE — ${commitsBehind} commits behind (built ${ageStr})`,
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
+        }
+    }
+    catch {
+        return { name: 'Graph freshness', status: 'warn', message: 'Could not check graph freshness' };
+    }
+}
 // Check @monoes/memory (optional HNSW vector search package)
 async function checkMonoesMemory() {
     try {
@@ -798,7 +876,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
             type: 'string'
         },
         {
@@ -841,6 +919,7 @@ export const doctorCommand = {
             checkDiskSpace,
             checkBuildTools,
             checkMonograph,
+            checkMonographFreshness,
             checkMonoesMemory,
             checkHelpersFresh,
             checkAgenticFlow,
@@ -863,6 +942,7 @@ export const doctorCommand = {
             'disk': checkDiskSpace,
             'typescript': checkBuildTools,
             'monograph': checkMonograph,
+            'graph-freshness': checkMonographFreshness,
             'memory-pkg': checkMonoesMemory,
             'helpers': checkHelpersFresh,
             'agentic-flow': checkAgenticFlow,
@@ -889,6 +969,14 @@ export const doctorCommand = {
                     const result = settledResult.value;
                     results.push(result);
                     output.writeln(formatCheck(result));
+                    if (result.fix && result.status === 'fail') {
+                        // Always show fix inline for failures — no flag needed
+                        output.writeln(output.dim(`  Fix: ${result.fix}`));
+                    }
+                    else if (result.fix && result.status === 'warn') {
+                        // Show fix inline for warnings too, so users don't need --fix for common issues
+                        output.writeln(output.dim(`  Hint: ${result.fix}`));
+                    }
                     if (result.fix && (result.status === 'fail' || result.status === 'warn')) {
                         fixes.push(`${result.name}: ${result.fix}`);
                     }
@@ -949,9 +1037,13 @@ export const doctorCommand = {
                 output.writeln(output.dim(`  ${fix}`));
             }
         }
-        else if (fixes.length > 0 && !showFix) {
-            output.writeln();
-            output.writeln(output.dim(`Run with --fix to see ${fixes.length} suggested fix${fixes.length > 1 ? 'es' : ''}`));
+        else if (!showFix) {
+            // Only nudge about --fix for warnings (failures already showed their fix inline)
+            const warnFixes = results.filter(r => r.status === 'warn' && r.fix).length;
+            if (warnFixes > 0) {
+                output.writeln();
+                output.writeln(output.dim(`Run with --fix to see ${warnFixes} suggested fix${warnFixes > 1 ? 'es' : ''} for warnings`));
+            }
         }
         // Overall result
         if (failed > 0) {