@monoes/monomindcli 1.13.0 → 1.14.0

package/.claude/helpers/control-start.cjs

@@ -61,6 +61,29 @@ function findCliPath() {
   const local = path.join(CWD, 'packages', '@monomind', 'cli', 'bin', 'cli.js');
   if (fs.existsSync(local)) return { cmd: process.execPath, args: [local], usePort: false };
 
+  // Try global npm install paths for both package names
+  // npm root -g is slow; probe known conventional paths instead
+  const globalCandidates = [];
+  try {
+    const { execSync } = require('child_process');
+    const npmRoot = execSync('npm root -g', { timeout: 3000, encoding: 'utf-8' }).trim();
+    if (npmRoot) {
+      globalCandidates.push(
+        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'dist', 'src', 'ui', 'server.mjs'),
+        path.join(npmRoot, '@monoes', 'monomindcli', 'dist', 'src', 'ui', 'server.mjs'),
+        path.join(npmRoot, 'monomind', 'packages', '@monomind', 'cli', 'bin', 'cli.js'),
+        path.join(npmRoot, '@monoes', 'monomindcli', 'bin', 'cli.js'),
+      );
+    }
+  } catch { /* npm root -g failed — skip */ }
+
+  for (const candidate of globalCandidates) {
+    if (fs.existsSync(candidate)) {
+      const usePort = candidate.endsWith('server.mjs');
+      return { cmd: process.execPath, args: [candidate], usePort };
+    }
+  }
+
   // Try npx monomind as last resort
   return { cmd: 'npx', args: ['monomind@latest'], usePort: false };
 }
@@ -88,9 +111,45 @@ function main() {
 
   child.unref();
 
+  // Write optimistic status with DEFAULT_PORT immediately so dependent scripts
+  // (hooks, boss agents) have something to read while the server starts up.
   writeStatus(child.pid, DEFAULT_PORT);
   process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${child.pid})\n`);
-  process.exit(0);
+
+  // If port 4242 was in use, server.mjs auto-increments (up to +10).
+  // Poll a few ports to find where it actually bound and update control.json.
+  const http = require('http');
+  function probePort(p) {
+    return new Promise((resolve) => {
+      const req = http.get({ hostname: 'localhost', port: p, path: '/api/status', timeout: 1000 }, (res) => {
+        res.resume();
+        resolve(res.statusCode < 500);
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+    });
+  }
+
+  // Give the server up to ~3 s to start, then confirm the actual port.
+  async function confirmPort() {
+    for (let attempt = 0; attempt < 6; attempt++) {
+      await new Promise(r => setTimeout(r, 500));
+      for (let delta = 0; delta <= 10; delta++) {
+        const p = DEFAULT_PORT + delta;
+        if (await probePort(p)) {
+          if (p !== DEFAULT_PORT) {
+            writeStatus(child.pid, p);
+            process.stdout.write(`[control] server bound to port ${p} (updated control.json)\n`);
+          }
+          return;
+        }
+      }
+    }
+    // Server didn't respond in time — leave control.json as-is (best-effort)
+    process.stdout.write('[control] server did not respond within 3 s — control.json may have wrong port\n');
+  }
+
+  confirmPort().catch(() => {}).finally(() => process.exit(0));
 }
 
 main();

package/.claude/helpers/event-logger.cjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 /**
  * Universal Event Logger
- * Captures 100% of Claude Code hook events to .monomind/events/ JSONL files.
+ * Captures 100% of Claude Code hook events.
+ * Writes to .git/monomind/events/ (branch-agnostic, shared across worktrees).
+ * Falls back to .monomind/events/ when git is unavailable.
  * Runs as a fast, non-blocking hook — append-only, no processing.
  */
 
@@ -83,8 +85,26 @@ async function main() {
   // Remove undefined keys
   Object.keys(entry).forEach(k => entry[k] === undefined && delete entry[k]);
 
+  // Resolve the git-safe monomind root (mirrors _getGitMonomindDir in server.mjs)
+  function getMonoDir(workDir) {
+    try {
+      const gitEntry = path.join(workDir, '.git');
+      const st = fs.statSync(gitEntry);
+      if (st.isDirectory()) return path.join(gitEntry, 'monomind');
+      if (st.isFile()) {
+        const m = fs.readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
+        if (m) {
+          const worktreeDir = path.resolve(workDir, m[1].trim());
+          return path.join(path.dirname(path.dirname(worktreeDir)), 'monomind');
+        }
+      }
+    } catch {}
+    return path.join(workDir, '.monomind');
+  }
+  const monoDir = getMonoDir(CWD);
+
   // Write to daily all-events log
-  const eventsDir = path.join(CWD, '.monomind', 'events');
+  const eventsDir = path.join(monoDir, 'events');
   const today = new Date().toISOString().slice(0, 10);
   const allLog = path.join(eventsDir, `${today}-all-events.jsonl`);
 
@@ -101,6 +121,27 @@ async function main() {
     } catch {}
   }
 
+  // Solution 5: cross-reference Claude session ID into the active mastermind session.
+  // When a new Claude session starts, record its UUID in current.json so future
+  // lookups can join mastermind session state with the Claude conversation transcript.
+  if (eventType === 'session-start' && sessionId !== 'unknown') {
+    try {
+      const sessionsDir = path.join(monoDir, 'sessions');
+      const currentFile = path.join(sessionsDir, 'current.json');
+      if (fs.existsSync(currentFile)) {
+        const cur = JSON.parse(fs.readFileSync(currentFile, 'utf8'));
+        const claudeSessions = Array.isArray(cur.claude_sessions) ? cur.claude_sessions : [];
+        if (!claudeSessions.includes(sessionId)) {
+          claudeSessions.push(sessionId);
+          const updated = { ...cur, claude_sessions: claudeSessions };
+          const tmp = `${currentFile}.${process.pid}.tmp`;
+          fs.writeFileSync(tmp, JSON.stringify(updated, null, 2), 'utf8');
+          fs.renameSync(tmp, currentFile);
+        }
+      }
+    } catch {}
+  }
+
   // Forward notifications and subagent events to dashboard for live visibility
   const forwardTypes = ['notification', 'subagent-start', 'subagent-stop', 'user-prompt'];
   if (forwardTypes.includes(eventType)) {

package/.claude/helpers/handlers/capture-handler.cjs

@@ -0,0 +1,336 @@
+'use strict';
+// Comprehensive session + subagent capture handler.
+// Wired to SubagentStart (snapshot + spawn event) and SubagentStop (diff + emit).
+//
+// On SubagentStart:
+//   - Snapshots ~/.claude/projects/{proj}/*.jsonl file sizes
+//   - Emits agent:spawn to link the agent to the current mastermind session immediately
+//
+// On SubagentStop:
+//   - Diffs the snapshot, parses new JSONL files for token usage and last messages
+//   - Emits agent:complete (replaces org:comms) with full result and token data
+//   - Emits agent:usage for cost tracking
+//   - Persists to per-run capture log
+//
+// Active session awareness:
+//   - Reads .monomind/capture/active-session.json (written by server on session:start)
+//   - Reads .monomind/capture/active-run.json (written by server on run:start)
+//   - Includes sessionId in all emitted events so they link to the dashboard session
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const os = require('os');
+
+const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CAPTURE_DIR = path.join(CWD, '.monomind', 'capture');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.on('data', c => data += c);
+    process.stdin.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve({}); } });
+    setTimeout(() => resolve({}), 3000);
+  });
+}
+
+function getClaudeProjectDir() {
+  const encoded = CWD.replace(/\//g, '-');
+  return path.join(os.homedir(), '.claude', 'projects', encoded);
+}
+
+function snapshotJSONLFiles() {
+  const claudeDir = getClaudeProjectDir();
+  if (!fs.existsSync(claudeDir)) return [];
+  try {
+    return fs.readdirSync(claudeDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => {
+        try { return { name: f, size: fs.statSync(path.join(claudeDir, f)).size }; }
+        catch { return { name: f, size: 0 }; }
+      });
+  } catch { return []; }
+}
+
+function parseJSONLForData(filePath) {
+  let tin = 0, tout = 0;
+  let allMsgs = [];
+  let toolCalls = [];
+  try {
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const d = JSON.parse(line);
+        const u = d?.message?.usage || {};
+        tin  += (u.input_tokens || 0) + (u.cache_creation_input_tokens || 0);
+        tout += (u.output_tokens || 0);
+        if (d?.message?.role === 'assistant') {
+          const content = d?.message?.content;
+          if (Array.isArray(content)) {
+            const tb = content.find(b => b.type === 'text');
+            if (tb?.text) allMsgs.push(tb.text);
+            // Capture tool uses for context
+            const tools = content.filter(b => b.type === 'tool_use').map(b => b.name).filter(Boolean);
+            toolCalls.push(...tools);
+          } else if (typeof content === 'string' && content) {
+            allMsgs.push(content);
+          }
+        }
+      } catch { /* skip malformed lines */ }
+    }
+  } catch { /* unreadable */ }
+  // Return last 3 messages for context + first+last message
+  const lastMsg = allMsgs[allMsgs.length - 1] || '';
+  const firstMsg = allMsgs[0] || '';
+  const summary = allMsgs.length > 1
+    ? (firstMsg.slice(0, 300) + (allMsgs.length > 2 ? `\n…[${allMsgs.length - 2} more msgs]…\n` : '\n') + lastMsg.slice(0, 700))
+    : lastMsg.slice(0, 1000);
+  return { tokens_in: tin, tokens_out: tout, summary, last_msg: lastMsg, toolCalls: [...new Set(toolCalls)] };
+}
+
+function getActiveRun() {
+  const runFile = path.join(CAPTURE_DIR, 'active-run.json');
+  if (!fs.existsSync(runFile)) return null;
+  try {
+    const d = JSON.parse(fs.readFileSync(runFile, 'utf8'));
+    // Treat as stale after 8 hours (was 60 min — too short for long loops)
+    if (Date.now() - (d.ts || 0) > 8 * 60 * 60 * 1000) return null;
+    return d;
+  } catch { return null; }
+}
+
+function getActiveSession() {
+  const sessFile = path.join(CAPTURE_DIR, 'active-session.json');
+  if (!fs.existsSync(sessFile)) return null;
+  try {
+    const d = JSON.parse(fs.readFileSync(sessFile, 'utf8'));
+    // Treat as stale after 8 hours
+    if (Date.now() - (d.ts || 0) > 8 * 60 * 60 * 1000) return null;
+    return d; // { org, sessionId, ts }
+  } catch { return null; }
+}
+
+function postEvent(event) {
+  return new Promise((resolve) => {
+    try {
+      const ctrlPath = path.join(CWD, '.monomind', 'control.json');
+      let baseUrl = 'http://localhost:4242';
+      if (fs.existsSync(ctrlPath)) {
+        try { baseUrl = JSON.parse(fs.readFileSync(ctrlPath, 'utf8')).url || baseUrl; } catch {}
+      }
+      const u = new URL(baseUrl);
+      const body = JSON.stringify(event);
+      const req = http.request({
+        hostname: u.hostname,
+        port: parseInt(u.port || '4242', 10),
+        path: '/api/mastermind/event',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      }, () => resolve());
+      req.on('error', () => resolve());
+      req.setTimeout(3000, () => { req.destroy(); resolve(); });
+      req.write(body);
+      req.end();
+    } catch { resolve(); }
+  });
+}
+
+// ─── SubagentStart: snapshot + emit agent:spawn ──────────────────────────────
+
+async function handleSubagentStart(hookInput) {
+  fs.mkdirSync(CAPTURE_DIR, { recursive: true });
+
+  const snapshot = snapshotJSONLFiles();
+  const agentType = String(
+    hookInput.subagent_type || hookInput.agentType || hookInput.agent_type || 'unknown'
+  ).slice(0, 64).replace(/[^a-z0-9_-]/gi, '-');
+  const agentDesc = String(hookInput.description || hookInput.prompt_description || '').slice(0, 1000);
+  const activeRun = getActiveRun();
+  const activeSess = getActiveSession();
+
+  // Write snapshot to FIFO queue — subagent-stop pops the oldest
+  const snapFile = path.join(
+    CAPTURE_DIR,
+    'snap-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6) + '.json'
+  );
+  fs.writeFileSync(snapFile, JSON.stringify({
+    ts: Date.now(),
+    files: snapshot,
+    agentType,
+    agentDesc,
+    org: activeSess?.org || activeRun?.org || null,
+    runId: activeRun?.runId || null,
+    session: activeSess?.sessionId || null,
+  }));
+
+  console.log('[CAPTURE:start] ' + agentType + ' · snapped ' + snapshot.length + ' files'
+    + (activeSess ? ' · sess=' + activeSess.sessionId : '')
+    + (activeRun ? ' · run=' + activeRun.runId : ' · no active run'));
+
+  // Emit agent:spawn immediately so the dashboard shows the agent starting
+  const org = activeSess?.org || activeRun?.org;
+  if (org || activeSess?.sessionId) {
+    await postEvent({
+      type: 'agent:spawn',
+      org: org || '',
+      runId: activeRun?.runId || '',
+      session: activeSess?.sessionId || '',
+      agentType,
+      task: agentDesc.slice(0, 500),
+      from: 'orchestrator',
+      to: agentType,
+      ts: Date.now(),
+    });
+  }
+}
+
+// ─── SubagentStop: diff + emit ────────────────────────────────────────────────
+
+async function handleSubagentStop(hookInput) {
+  fs.mkdirSync(CAPTURE_DIR, { recursive: true });
+
+  // Pop oldest snapshot (FIFO — matches the agent that just finished)
+  const snapFiles = fs.readdirSync(CAPTURE_DIR)
+    .filter(f => f.startsWith('snap-') && f.endsWith('.json'))
+    .sort(); // lexicographic = timestamp order
+
+  if (snapFiles.length === 0) {
+    console.log('[CAPTURE:stop] No snapshot to diff — skipping');
+    return;
+  }
+
+  const snapPath = path.join(CAPTURE_DIR, snapFiles[0]);
+  let snap;
+  try { snap = JSON.parse(fs.readFileSync(snapPath, 'utf8')); } catch {
+    try { fs.unlinkSync(snapPath); } catch {}
+    return;
+  }
+  try { fs.unlinkSync(snapPath); } catch {}
+
+  // Also check current active session (may have changed since SubagentStart)
+  const activeSess = getActiveSession();
+  const session = snap.session || activeSess?.sessionId || null;
+  const org = snap.org || activeSess?.org || null;
+  const runId = snap.runId || null;
+
+  // Diff JSONL files — only count entirely NEW files (subagent creates its own session)
+  const claudeDir = getClaudeProjectDir();
+  const currentFiles = snapshotJSONLFiles();
+  const prevNames = new Set((snap.files || []).map(f => f.name));
+
+  let totalTin = 0, totalTout = 0;
+  let summary = '';
+  let toolCalls = [];
+  const capturedFiles = [];
+
+  for (const f of currentFiles) {
+    if (!prevNames.has(f.name)) {
+      const parsed = parseJSONLForData(path.join(claudeDir, f.name));
+      totalTin  += parsed.tokens_in;
+      totalTout += parsed.tokens_out;
+      if (parsed.summary) summary = parsed.summary;
+      toolCalls.push(...parsed.toolCalls);
+      capturedFiles.push(f.name);
+    }
+  }
+
+  const costUsd = parseFloat((totalTin * 3e-6 + totalTout * 15e-6).toFixed(6));
+  const { agentType, agentDesc } = snap;
+  toolCalls = [...new Set(toolCalls)].slice(0, 20);
+
+  console.log('[CAPTURE:stop] ' + agentType + ' · ' + totalTin + '+' + totalTout
+    + ' tok · $' + costUsd.toFixed(4) + ' · ' + capturedFiles.length + ' new files'
+    + (session ? ' · sess=' + session : '')
+    + (org ? ' · ' + org + '/' + runId : ''));
+
+  if (!org && !session) {
+    // No active org or session — log to general capture file only
+    const genLog = path.join(CAPTURE_DIR, 'unattributed.jsonl');
+    fs.appendFileSync(genLog, JSON.stringify({
+      ts: Date.now(), agentType, tokens_in: totalTin, tokens_out: totalTout,
+      cost_usd: costUsd, capturedFiles, summary: summary.slice(0, 200),
+    }) + '\n');
+    return;
+  }
+
+  // ── Emit agent:usage (token/cost accounting) ──────────────────────────────
+  if (totalTin > 0 || totalTout > 0) {
+    await postEvent({
+      type: 'agent:usage',
+      org: org || '',
+      runId: runId || '',
+      session: session || '',
+      role: agentType,
+      agentType,
+      tokens_in: totalTin,
+      tokens_out: totalTout,
+      cost_usd: costUsd,
+      ts: Date.now(),
+    });
+  }
+
+  // ── Emit agent:complete (replaces org:comms — richer, includes session) ───
+  // Always emit even if summary is empty (so the spawn/complete pair is always visible)
+  await postEvent({
+    type: 'agent:complete',
+    org: org || '',
+    runId: runId || '',
+    session: session || '',
+    agentType,
+    role: agentType,
+    from: agentType,
+    to: 'boss',
+    result: summary.slice(0, 1000),
+    toolCalls,
+    tokens_in: totalTin,
+    tokens_out: totalTout,
+    cost_usd: costUsd,
+    capturedFiles: capturedFiles.slice(0, 10),
+    ts: Date.now(),
+  });
+
+  // ── Also emit legacy org:comms for backwards compat ───────────────────────
+  if (summary && (org || session)) {
+    await postEvent({
+      type: 'org:comms',
+      org: org || '',
+      runId: runId || '',
+      session: session || '',
+      from: agentType,
+      to: 'boss',
+      msg: summary.slice(0, 500),
+      ts: Date.now(),
+    });
+  }
+
+  // ── Persist transcript reference to run directory ─────────────────────────
+  if (capturedFiles.length > 0 && org && runId) {
+    const runDir = path.join(CWD, '.monomind', 'orgs', org, 'runs');
+    fs.mkdirSync(runDir, { recursive: true });
+    const capLog = path.join(runDir, runId + '-captures.jsonl');
+    fs.appendFileSync(capLog, JSON.stringify({
+      type: 'agent:capture',
+      org, runId, session,
+      agentType,
+      agentDesc: agentDesc.slice(0, 200),
+      tokens_in: totalTin,
+      tokens_out: totalTout,
+      cost_usd: costUsd,
+      capturedFiles,
+      claudeProjectDir: claudeDir,
+      ts: Date.now(),
+    }) + '\n');
+  }
+}
+
+// ─── Dispatch ─────────────────────────────────────────────────────────────────
+
+const eventType = process.argv[2]; // 'subagent-start' | 'subagent-stop'
+
+readStdin().then(hookInput => {
+  if (eventType === 'subagent-start') return handleSubagentStart(hookInput);
+  if (eventType === 'subagent-stop')  return handleSubagentStop(hookInput);
+  console.log('[CAPTURE] unknown event type: ' + eventType);
+}).catch(() => process.exit(0));

package/.claude/helpers/handlers/route-handler.cjs

@@ -382,9 +382,10 @@ module.exports = {
           } catch (e) { /* ignore */ }
         }
         if (nodeCount > 100) {
-          // Pre-resolve top-5 relevant files for the user's prompt — the LLM
+          // Pre-resolve top-3 relevant files for the user's prompt — the LLM
           // sees the answer inline instead of being told to call a tool.
-          var suggestions = hCtx.getMonographSuggestions(prompt, 5);
+          // 3 is enough signal; more files inflate token cost on every prompt.
+          var suggestions = hCtx.getMonographSuggestions(prompt, 3);
 
           // Boost recently-edited files to the top of pre-resolve suggestions.
           // Even when the FTS index hasn't caught up to the latest edits, the
@@ -414,25 +415,24 @@ module.exports = {
                 }
               }
               if (editBoosts.length > 0) {
-                suggestions = editBoosts.concat(suggestions).slice(0, 5);
+                suggestions = editBoosts.concat(suggestions).slice(0, 3);
               }
             }
           } catch (e) { /* non-fatal */ }
 
           if (suggestions.length > 0) {
-            console.log('\n[MONOGRAPH] ' + nodeCount + ' nodes indexed. Top files for this task (pre-resolved from graph):');
-            for (var si = 0; si < suggestions.length; si++) {
-              var s = suggestions[si];
+            // Compact single-line format: "[MONOGRAPH] N nodes. Top files: name [Label] — path:line, ..."
+            // Matches the agent-start-handler pattern — keeps per-prompt token cost minimal.
+            var hintParts = suggestions.map(function(s) {
               var editTag = s._editBoost ? ' ✎' : '';
-              // Include :line suffix when available so LLM can navigate directly
               var fileLoc = (s.file || '');
               if (fileLoc && s.startLine != null) fileLoc = fileLoc + ':' + s.startLine;
-              console.log('  · ' + s.name + ' [' + s.label + '] — ' + fileLoc + (s.deg ? ' (deg ' + s.deg + ')' : '') + editTag);
-            }
-            console.log('  Use mcp__monomind__monograph_query / monograph_impact for deeper drill-down.');
+              return s.name + ' [' + s.label + '] — ' + fileLoc + editTag;
+            });
+            console.log('[MONOGRAPH] ' + nodeCount + ' nodes. Top files: ' + hintParts.join(' · '));
             hCtx._recordGraphTelemetry('preresolve_hit');
           } else {
-            console.log('\n[MONOGRAPH] ' + nodeCount + ' nodes indexed. Call mcp__monomind__monograph_suggest first to find relevant files without grepping.');
+            console.log('[MONOGRAPH] ' + nodeCount + ' nodes. Call mcp__monomind__monograph_suggest to find relevant files.');
             hCtx._recordGraphTelemetry('preresolve_miss');
           }
         }

package/.claude/helpers/hook-handler.cjs

@@ -99,17 +99,33 @@ const [,, command, ...args] = process.argv;
 // Read stdin — Claude Code sends hook data as JSON via stdin
 // Uses a timeout to prevent hanging when stdin is in an ambiguous state
 // (not TTY, not a proper pipe) which happens with Claude Code hook invocations.
+// Hard cap at 1 MiB: a legitimate hook payload (tool name + input) is at most
+// a few KB; anything larger is either a bug or an adversarial OOM attempt.
+const MAX_STDIN_BYTES = 1 * 1024 * 1024; // 1 MiB
 async function readStdin() {
   if (process.stdin.isTTY) return '';
   return new Promise((resolve) => {
     let data = '';
+    let byteCount = 0;
+    let truncated = false;
     const timer = setTimeout(() => {
       process.stdin.removeAllListeners();
       process.stdin.pause();
       resolve(data);
     }, 500);
     process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('data', (chunk) => {
+      if (truncated) return;
+      byteCount += Buffer.byteLength(chunk, 'utf8');
+      if (byteCount > MAX_STDIN_BYTES) {
+        truncated = true;
+        process.stdin.pause();
+        clearTimeout(timer);
+        resolve(''); // discard oversized input to prevent OOM
+        return;
+      }
+      data += chunk;
+    });
     process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
     process.stdin.on('error', () => { clearTimeout(timer); resolve(data); });
     process.stdin.resume();

package/.claude/helpers/session.cjs

@@ -1,7 +1,8 @@
 'use strict';
 /**
  * Session state management for hook-handler.cjs
- * Persists session data to .monomind/sessions/current.json
+ * Persists session data to .git/monomind/sessions/current.json (branch-agnostic,
+ * shared across git worktrees). Falls back to .monomind/sessions/ if not in a git repo.
  *
  * API: start(), restore(), end(), status(), metric(key), update(patch)
  */
@@ -10,7 +11,24 @@ const path = require('path');
 const fs = require('fs');
 
 const CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-const SESSIONS_DIR = path.join(CWD, '.monomind', 'sessions');
+
+function getMonoDir(workDir) {
+  try {
+    const gitEntry = path.join(workDir, '.git');
+    const st = fs.statSync(gitEntry);
+    if (st.isDirectory()) return path.join(gitEntry, 'monomind');
+    if (st.isFile()) {
+      const m = fs.readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
+      if (m) {
+        const worktreeDir = path.resolve(workDir, m[1].trim());
+        return path.join(path.dirname(path.dirname(worktreeDir)), 'monomind');
+      }
+    }
+  } catch {}
+  return path.join(workDir, '.monomind');
+}
+
+const SESSIONS_DIR = path.join(getMonoDir(CWD), 'sessions');
 const CURRENT_FILE = path.join(SESSIONS_DIR, 'current.json');
 
 var KNOWN_METRICS = new Set(['edits', 'commands', 'tasks', 'errors']);