monomind 2.0.0 → 2.0.2

package/packages/@monomind/cli/dist/src/orgrt/types.js

@@ -0,0 +1,51 @@
+// packages/@monomind/cli/src/orgrt/types.ts
+import { z } from 'zod';
+/** Per-role provider config. Default (absent) = subscription login of local Claude Code. */
+export const ProviderSchema = z.object({
+    kind: z.enum(['subscription', 'api-key', 'base-url', 'bedrock', 'vertex']).default('subscription'),
+    /** env var NAME holding the API key (never the key itself) */
+    apiKeyEnv: z.string().optional(),
+    baseUrl: z.string().optional(),
+    /** env var NAME holding the auth token for base-url providers */
+    authTokenEnv: z.string().optional(),
+}).strict();
+export const RolePolicySchema = z.object({
+    allowTools: z.array(z.string()).optional(),
+    denyTools: z.array(z.string()).default([]),
+    /** glob patterns relative to org cwd */
+    fileWrite: z.array(z.string()).default(['**']),
+    fileRead: z.array(z.string()).default(['**']),
+    /** allowed domains for WebFetch/WebSearch; empty array = no web */
+    webAllow: z.array(z.string()).optional(),
+    maxTokens: z.number().int().positive().optional(),
+}).partial().passthrough();
+export const RoleSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().default(''),
+    type: z.string().default('specialist'),
+    reports_to: z.string().nullable().default(null),
+    responsibilities: z.array(z.string()).default([]),
+    instructions_file: z.string().optional(),
+    adapter_config: z.object({
+        model: z.string().default('claude-sonnet-4-5'),
+        max_tokens: z.number().optional(),
+    }).partial().optional(),
+    provider: ProviderSchema.optional(),
+    policy: RolePolicySchema.optional(),
+}).passthrough();
+export const OrgDefSchema = z.object({
+    name: z.string().min(1),
+    goal: z.string().default(''),
+    status: z.string().default('stopped'),
+    schedule: z.union([z.string(), z.number(), z.null()]).default(null),
+    run_config: z.object({
+        max_concurrent_agents: z.number().int().positive().default(4),
+        budget_tokens: z.number().int().positive().default(1_000_000),
+        memory_namespace: z.string().optional(),
+        max_turns_per_message: z.number().int().positive().default(30),
+    }).partial().passthrough().default({})
+        .transform(rc => ({ max_concurrent_agents: 4, budget_tokens: 1_000_000, max_turns_per_message: 30, ...rc })),
+    roles: z.array(RoleSchema).min(1),
+}).passthrough();
+export const ORG_DIR = '.monomind/orgs';
+//# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/parser.js

@@ -159,11 +159,13 @@ export class CommandParser {
                 result.command.push(arg);
                 // Check for subcommand (level 1)
                 const cmd = this.commands.get(arg);
+                resolvedCmd = cmd;
                 if (cmd?.subcommands && i + 1 < args.length) {
                     const nextArg = args[i + 1];
                     const subCmd = cmd.subcommands.find(sc => sc.name === nextArg || sc.aliases?.includes(nextArg));
                     if (subCmd) {
                         result.command.push(nextArg);
+                        resolvedCmd = subCmd;
                         i++;
                         // Check for nested subcommand (level 2)
                         if (subCmd.subcommands && i + 1 < args.length) {
@@ -171,6 +173,7 @@ export class CommandParser {
                             const nestedCmd = subCmd.subcommands.find(sc => sc.name === nestedArg || sc.aliases?.includes(nestedArg));
                             if (nestedCmd) {
                                 result.command.push(nestedArg);
+                                resolvedCmd = nestedCmd;
                                 i++;
                                 // Check for deeply nested subcommand (level 3)
                                 if (nestedCmd.subcommands && i + 1 < args.length) {
@@ -178,6 +181,7 @@ export class CommandParser {
                                     const deepCmd = nestedCmd.subcommands.find(sc => sc.name === deepArg || sc.aliases?.includes(deepArg));
                                     if (deepCmd) {
                                         result.command.push(deepArg);
+                                        resolvedCmd = deepCmd;
                                         i++;
                                     }
                                 }
@@ -193,8 +197,10 @@ export class CommandParser {
             }
             i++;
         }
-        // Apply defaults
-        this.applyDefaults(result.flags);
+        // Apply defaults — the resolved (sub)command's own option definitions
+        // shadow same-name global options (e.g. `browse screenshot --format` is an
+        // image format, not the global text|json|table output format).
+        this.applyDefaults(result.flags, resolvedCmd);
         return result;
     }
     parseFlag(args, index, aliases, booleanFlags) {
@@ -398,10 +404,24 @@ export class CommandParser {
         }
         return flags;
     }
-    applyDefaults(flags) {
+    applyDefaults(flags, resolvedCmd) {
+        // The resolved command's own options shadow same-name globals: apply the
+        // command's defaults and suppress the global default for those names.
+        const shadowed = new Set();
+        if (resolvedCmd?.options) {
+            for (const opt of resolvedCmd.options) {
+                const key = this.normalizeKey(opt.name);
+                shadowed.add(key);
+                if (flags[key] === undefined && opt.default !== undefined) {
+                    flags[key] = opt.default;
+                }
+            }
+        }
         // Apply global option defaults
         for (const opt of this.globalOptions) {
             const key = this.normalizeKey(opt.name);
+            if (shadowed.has(key))
+                continue;
             if (flags[key] === undefined && opt.default !== undefined) {
                 flags[key] = opt.default;
             }
@@ -418,10 +438,16 @@ export class CommandParser {
     }
     validateFlags(flags, command) {
         const errors = [];
-        const allOptions = [...this.globalOptions];
+        // Command options shadow same-name globals — validate against the
+        // command's definition (its choices/validators), not the global's.
+        const byName = new Map();
+        for (const opt of this.globalOptions)
+            byName.set(opt.name, opt);
         if (command?.options) {
-            allOptions.push(...command.options);
+            for (const opt of command.options)
+                byName.set(opt.name, opt);
         }
+        const allOptions = [...byName.values()];
         // Check required flags
         for (const opt of allOptions) {
             const key = this.normalizeKey(opt.name);

package/packages/@monomind/cli/dist/src/ui/collector.mjs

@@ -277,12 +277,17 @@ function collectAgents(projectDir) {
 // Single source-of-truth for all model pricing (canonical list from src/pricing/model-pricing.ts).
 // server.mjs imports _tokPrice and _tokCost from here instead of duplicating this table.
 const _TOK_PRICES = {
+  // Frontier (Fable/Mythos)
+  'claude-fable-5':    { in: 10e-6,   out: 50e-6,   cw: 12.5e-6,  cr: 1e-6     },
+  'claude-mythos-5':   { in: 10e-6,   out: 50e-6,   cw: 12.5e-6,  cr: 1e-6     },
   // Opus
   'claude-opus-4-8':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
+  'claude-opus-4-7':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4-6':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4-5':   { in: 5e-6,    out: 25e-6,   cw: 6.25e-6,  cr: 0.5e-6   },
   'claude-opus-4':     { in: 15e-6,   out: 75e-6,   cw: 18.75e-6, cr: 1.5e-6   },
   // Sonnet
+  'claude-sonnet-5':   { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4-6': { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4-5': { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
   'claude-sonnet-4':   { in: 3e-6,    out: 15e-6,   cw: 3.75e-6,  cr: 0.3e-6   },
@@ -489,6 +494,15 @@ function collectMetrics(projectDir) {
   const avgConf = routingConfCount > 0 ? Math.round((routingConfSum / routingConfCount) * 100) : null;
   const topAgent = Object.entries(agentCounts).sort((a, b) => b[1] - a[1])[0];
 
+  // Worker freshness: stat the live worker output files so the frontend can
+  // render freshness pills. Shape: workers: [{name, exists, ageMs}]
+  const workerFiles = ['codebase-map', 'security-audit', 'performance', 'consolidation', 'ddd-progress'];
+  const now = Date.now();
+  const workers = workerFiles.map(name => {
+    const s = fileStat(path.join(base, 'metrics', name + '.json'));
+    return { name, exists: !!s, ageMs: s ? Math.max(0, now - s.mtimeMs) : null };
+  });
+
   return {
     routing: {
       total: routingTotal,
@@ -507,7 +521,9 @@ function collectMetrics(projectDir) {
       monthCost: tokenSummary.monthCost,
       monthCalls: tokenSummary.monthCalls,
     },
-    security: readJSON(path.join(base, 'security', 'audit-status.json')) || {}
+    // Live worker output (audit worker) — fields include riskLevel, recommendations
+    security: readJSON(path.join(base, 'metrics', 'security-audit.json')) || {},
+    workers,
   };
 }
 
@@ -554,43 +570,56 @@ function collectMemory(projectDir) {
   const d = path.resolve(projectDir);
   const monomindDir = path.join(d, '.monomind');
 
-  // AgentDB — check all known locations across different init styles
-  const dbCandidates = [
-    path.join(d, 'data', 'memory.db'),         // custom --path ./data/memory.db
-    path.join(d, '.swarm', 'memory.db'),        // default init path
-    path.join(monomindDir, 'memory.db'),        // legacy .monomind path
-    path.join(d, '.claude', 'memory.db'),       // .claude dir (some setups)
-  ];
-  const dbHit = probeFile(...dbCandidates);
-  const dbSize = dbHit ? dbHit.size : 0;
-  const dbPath = dbHit ? dbHit.path : null;
-
-  // HNSW — lives alongside the DB or at the .swarm default
-  const hnswCandidates = dbPath ? [
-    path.join(path.dirname(dbPath), 'memory.graph'),  // alongside DB (hybrid backend)
-    path.join(path.dirname(dbPath), 'hnsw.index'),    // default init name
-  ] : [
-    path.join(d, 'data', 'memory.graph'),
-    path.join(d, '.swarm', 'hnsw.index'),
-  ];
-  const hnswHit = probeFile(...hnswCandidates);
-  const hnsw = !!hnswHit;
+  // Auto-memory pattern store — array of pattern entries written by hooks
+  let patternCount = 0;
+  let patternsUpdated = null;
+  const storePath = path.join(monomindDir, 'data', 'auto-memory-store.json');
+  const store = readJSON(storePath);
+  if (Array.isArray(store)) {
+    patternCount = store.length;
+    for (const e of store) {
+      if (e && typeof e.ts === 'number' && (!patternsUpdated || e.ts > patternsUpdated)) patternsUpdated = e.ts;
+    }
+  }
+  if (!patternsUpdated) {
+    const s = fileStat(storePath);
+    if (s) patternsUpdated = s.mtimeMs;
+  }
 
-  // MonoVector DB
-  const monovectorHit = probeFile(
-    path.join(monomindDir, 'data', 'monovector.db'),
-    path.join(d, 'data', 'monovector.db'),
-  );
-  const monovectorSize = monovectorHit ? monovectorHit.size : 0;
-  const monovectorExists = !!monovectorHit;
+  // Episodic memory — one JSON line per episode
+  let episodeCount = 0;
+  let lastEpisode = null;
+  try {
+    const raw = fs.readFileSync(path.join(monomindDir, 'episodic', 'episodes.jsonl'), 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    episodeCount = lines.length;
+    if (lines.length) {
+      try {
+        const last = JSON.parse(lines[lines.length - 1]);
+        lastEpisode = last.ts || last.timestamp || null;
+      } catch {}
+    }
+  } catch {}
 
-  let monovectorPatterns = 0;
-  const ranked = readJSON(path.join(monomindDir, 'data', 'ranked-context.json'));
-  if (ranked && ranked.entries) monovectorPatterns = ranked.entries.length;
+  // Last consolidation run (consolidate worker output)
+  let lastConsolidated = null;
+  const consolidation = readJSON(path.join(monomindDir, 'metrics', 'consolidation.json'));
+  if (consolidation && consolidation.timestamp) lastConsolidated = consolidation.timestamp;
 
   const files = collectMemoryFiles(projectDir);
 
-  return { dbSize, dbPath, hnsw, monovectorSize, monovectorExists, monovectorPatterns, files, count: files.length };
+  return {
+    patternCount,
+    patternsUpdated,
+    episodeCount,
+    lastEpisode,
+    lastConsolidated,
+    files,
+    count: files.length,
+    // Legacy keys kept for frontend backward-safety (v1 backends no longer written in v2)
+    dbSize: 0, dbPath: null, hnsw: false,
+    monovectorSize: 0, monovectorExists: false, monovectorPatterns: 0,
+  };
 }
 
 function collectSystem() {
@@ -771,7 +800,10 @@ export function getWatchPaths(projectDir) {
     path.join(m, 'metrics', 'token-summary.json'),
     path.join(m, 'metrics', 'token-sessions.json'),
     path.join(m, 'metrics', 'ddd-progress.json'),
-    path.join(m, 'metrics', 'learning.json'),
+    path.join(m, 'metrics', 'codebase-map.json'),
+    path.join(m, 'metrics', 'security-audit.json'),
+    path.join(m, 'metrics', 'performance.json'),
+    path.join(m, 'metrics', 'consolidation.json'),
     // Agents
     path.join(m, 'registry.json'),
     path.join(m, 'agents', 'registrations'),
@@ -782,17 +814,10 @@ export function getWatchPaths(projectDir) {
     // Knowledge
     path.join(m, 'knowledge', 'chunks.jsonl'),
     path.join(m, 'skills.jsonl'),
-    // Security
-    path.join(m, 'security', 'audit-status.json'),
-    // Triggers & memory — watch all candidate locations
+    // Triggers & memory — live v2 sources
     path.join(m, 'trigger-index.json'),
-    path.join(resolvedDir, 'data', 'memory.db'),
-    path.join(resolvedDir, 'data', 'memory.graph'),
-    path.join(resolvedDir, '.swarm', 'memory.db'),
-    path.join(resolvedDir, '.swarm', 'hnsw.index'),
-    path.join(m, 'memory.db'),
-    path.join(m, 'data', 'monovector.db'),
-    path.join(m, 'data', 'ranked-context.json'),
+    path.join(m, 'data', 'auto-memory-store.json'),
+    path.join(m, 'episodic', 'episodes.jsonl'),
     // Sessions
     path.join(c, 'sessions')
   ];

package/packages/@monomind/cli/dist/src/ui/dashboard.html

@@ -2663,6 +2663,7 @@ function switchProject(path) {
   // Reset Monograph cache so it reloads for the new project
   _mgLoaded = false;
   _mgGraph = null;
+  window._mgRealTotals = null;
   document.getElementById('sb-proj').textContent = path.split('/').filter(Boolean).pop() || '—';
   document.getElementById('sb-path').textContent = path;
   _showNavProjectCtx(path);
@@ -3174,9 +3175,10 @@ async function loadStatusStrip() {
   const strip = document.getElementById('status-strip');
   if (!strip || !DIR) return;
   try {
-    const [statusRes, memRes] = await Promise.allSettled([
+    const [statusRes, memRes, metricsRes] = await Promise.allSettled([
       apiFetch('/api/status?dir=' + enc(DIR)),
       apiFetch('/api/memory/stats?dir=' + enc(DIR)),
+      apiFetch('/api/section?name=metrics&dir=' + enc(DIR)),
     ]);
     const checks = statusRes.status === 'fulfilled'
       ? (Array.isArray(statusRes.value) ? statusRes.value : (statusRes.value?.checks || []))
@@ -3193,15 +3195,27 @@ async function loadStatusStrip() {
       pills.push(`<span class="ss-pill ${cls}">${esc(c.name || c.label || c.key || '?')}</span>`);
     });
 
-    // HNSW status
-    const hnswOn = mem.hnsw === true || mem.hnswEnabled === true || mem.hnsw_enabled === true;
-    pills.push(`<span class="ss-pill ${hnswOn ? 'on' : ''}">HNSW ${hnswOn ? 'ON' : 'OFF'}</span>`);
-
     // Patterns count
     if (mem.patterns != null) {
       pills.push(`<span class="ss-pill">PATTERNS ${Number(mem.patterns).toLocaleString()}</span>`);
     }
 
+    // Worker freshness (metrics.workers = [{name, exists, ageMs}])
+    const metricsSec = metricsRes.status === 'fulfilled'
+      ? (metricsRes.value?.metrics || metricsRes.value || {})
+      : {};
+    const workers = Array.isArray(metricsSec.workers) ? metricsSec.workers : [];
+    const fmtAge = ms => ms < 3600e3 ? Math.round(ms / 60e3) + 'm'
+      : ms < 86400e3 ? Math.round(ms / 3600e3) + 'h'
+      : Math.round(ms / 86400e3) + 'd';
+    workers.forEach(w => {
+      if (!w || !w.name) return;
+      const fresh = w.exists && typeof w.ageMs === 'number' && w.ageMs < 12 * 3600e3;
+      const cls = !w.exists ? '' : (fresh ? 'on' : 'warn');
+      const ageTxt = !w.exists ? 'missing' : (typeof w.ageMs === 'number' ? fmtAge(w.ageMs) : '?');
+      pills.push(`<span class="ss-pill ${cls}" title="worker ${esc(w.name)}: ${esc(ageTxt)}">⚙ ${esc(w.name)}</span>`);
+    });
+
     // Chunks count
     if (mem.chunks != null) {
       pills.push(`<span class="ss-pill">CHUNKS ${Number(mem.chunks).toLocaleString()}</span>`);
@@ -3506,8 +3520,20 @@ async function loadMemUsagePeriod(btn, period) {
     }
 
     const totalCost = typeof s.todayCost === 'number' ? s.todayCost : (typeof s.cost === 'number' ? s.cost : null);
-    const cacheEff = s.cacheTokens && s.totalTokensIn
-      ? Math.round(s.cacheTokens / s.totalTokensIn * 100) : null;
+    // Cache efficiency = cacheRead / (cacheRead + input), capped at 100%.
+    // (The old cacheTokens/totalTokensIn math exceeded 100% because cache
+    // reads are not included in the input-token total.)
+    const cacheEff = s.cacheTokens
+      ? Math.min(100, Math.round(s.cacheTokens / (s.cacheTokens + (Number(s.totalTokensIn) || 0)) * 100))
+      : null;
+
+    // Projects rows sometimes arrive without a usable name — fall back to
+    // the directory basename, then 'unknown'.
+    const projRows = projects.map(p => {
+      const raw = (p.project && p.project !== '?') ? p.project : (p.name && p.name !== '?' ? p.name : '');
+      const base = String(p.dir || p.path || '').split('/').filter(Boolean).pop() || '';
+      return Object.assign({}, p, { project: raw || base || 'unknown' });
+    });
 
     content.innerHTML = `
       <!-- Overview stats -->
@@ -3536,8 +3562,8 @@ async function loadMemUsagePeriod(btn, period) {
       <div style="margin-bottom:14px">${barChart(mcps, 'count', 'server', 'oklch(70% 0.18 60)', 8)}</div>` : ''}
 
       <!-- Projects -->
-      ${projects.length ? `<div class="m-group-title" style="margin-bottom:6px">Projects</div>
-      <div style="margin-bottom:14px">${barChart(projects, 'cost', 'project', 'oklch(65% 0.15 150)', 5)}</div>` : ''}
+      ${projRows.length ? `<div class="m-group-title" style="margin-bottom:6px">Projects</div>
+      <div style="margin-bottom:14px">${barChart(projRows, 'cost', 'project', 'oklch(65% 0.15 150)', 5)}</div>` : ''}
 
       <!-- Fallback: session breakdown table if no breakdown data -->
       ${!models.length && !tools.length && rows.length ? `
@@ -6274,7 +6300,6 @@ const _v2AvatarKnown = new Set([
   'quorum-manager','consensus-coordinator','perf-analyzer','benchmarker',
   'task-orchestrator','memory-coordinator','load-balancer','resource-allocator',
   'pr-manager','code-review-swarm','issue-tracker','release-manager','repo-architect',
-  'workflow-automation','sparc-coord','sparc-coder','specification','pseudocode',
   'architecture','refinement','backend-dev','frontend-developer','mobile-dev',
   'ml-developer','cicd-engineer','system-architect','ai-engineer','model-qa',
   'data-engineer','analytics-reporter','experiment-tracker','data-consolidator',
@@ -8227,7 +8252,7 @@ function v2RenderOrgConfig() {
   const rc = d.run_config || {};
   const gov = (d.governance && typeof d.governance === 'object') ? d.governance : { policy: d.governance || 'auto' };
   const topos = ['hierarchical','hierarchical-mesh','mesh','star','ring','adaptive','hybrid'];
-  const modes = ['daemon','once','scheduled'];
+  const modes = [{ v: 'daemon', l: 'persistent (daemon)' }, { v: 'once', l: 'once' }, { v: 'scheduled', l: 'scheduled' }];
   const statuses = ['active','paused','archived'];
   const govPolicies = ['auto','board','strict'];
   const inp = (id,val,type,extra) => '<input class="filter-input" id="'+id+'" type="'+(type||'text')+'" value="'+esc(String(val??''))+'" '+(extra||'')+' style="width:100%;box-sizing:border-box">';
@@ -8239,7 +8264,7 @@ function v2RenderOrgConfig() {
       fld('Name', inp('oc-name', d.name||'','text','readonly style="opacity:0.5"'))
       +fld('Status', sel('oc-status', statuses, d.status||'active'))
       +'<div style="grid-column:1/-1">'+fld('Goal', '<textarea id="oc-goal" class="filter-input" rows="3" style="width:100%;box-sizing:border-box;resize:vertical;line-height:1.5">'+esc(d.goal||'')+'</textarea>')+'</div>'
-      +fld('Mode', sel('oc-mode', modes, d.mode||'daemon'))
+      +fld('Mode', '<select class="filter-input" id="oc-mode" style="width:100%;box-sizing:border-box;cursor:pointer">'+modes.map(o=>'<option value="'+esc(o.v)+'"'+((d.mode||'daemon')===o.v?' selected':'')+'>'+esc(o.l)+'</option>').join('')+'</select>')
       +fld('Topology', sel('oc-topology', topos, d.topology||'hierarchical'))
       +'<div style="grid-column:1/-1">'+fld('Schedule', inp('oc-schedule', d.schedule||''))+'</div>'
     )
@@ -9144,7 +9169,6 @@ const _MASTERMIND_SKILLS = [
   '/monomind:repeat','monomind:review','monomind:understand','monomind:adr',
   '/monomind:budget','monomind:graph-status','monomind:loops','monomind:swarm',
   '/swarm:development','swarm:analysis','swarm:testing','swarm:optimization',
-  '/sparc:architect','sparc:code','sparc:tdd','sparc:reviewer','sparc:security-review',
   '/github:pr-manager','github:issue-tracker','github:release-manager',
 ];
 window._allSkills = _MASTERMIND_SKILLS;
@@ -11871,8 +11895,16 @@ function renderMgOverview() {
   const E = g.edges.length;
   const avgDeg = N > 0 ? ((2 * E) / N).toFixed(1) : '0';
   const typeSet = new Set(g.nodes.map(n => n.type || n.kind || 'unknown'));
-  document.getElementById('mg-stat-nodes').textContent = N;
-  document.getElementById('mg-stat-edges').textContent = E;
+  // The graph fetch is capped at 2000 nodes — prefer real totals from the
+  // monograph report (set by mgLoadReport) and relabel honestly when capped.
+  const _capped = N >= 2000 || E >= 2000;
+  const _rt = window._mgRealTotals || null;
+  const _nEl = document.getElementById('mg-stat-nodes');
+  const _eEl = document.getElementById('mg-stat-edges');
+  _nEl.textContent = (_rt && _rt.nodes) ? Number(_rt.nodes).toLocaleString() : N;
+  _eEl.textContent = (_rt && _rt.edges) ? Number(_rt.edges).toLocaleString() : E;
+  if (_nEl.previousElementSibling) _nEl.previousElementSibling.textContent = ((_rt && _rt.nodes) || !_capped) ? 'Nodes' : 'Nodes (top 2000)';
+  if (_eEl.previousElementSibling) _eEl.previousElementSibling.textContent = ((_rt && _rt.edges) || !_capped) ? 'Edges' : 'Edges (top 2000)';
   document.getElementById('mg-stat-avgdeg').textContent = avgDeg;
   document.getElementById('mg-stat-types').textContent = typeSet.size;
 
@@ -11918,7 +11950,14 @@ function renderMgOverview() {
   else {
     const show = dead.slice(0, 12);
     deadEl.innerHTML = `<table class="mg-table"><thead><tr><th>Name</th><th>Type</th></tr></thead><tbody>` +
-      show.map(n => `<tr><td title="${esc(n.id||n.name||n.label)}">${esc(mgShortLabel(n.label||n.name||n.id||''))}</td><td>${esc(n.type||n.kind||'')}</td></tr>`).join('') +
+      show.map(n => {
+        // Prefer a real name; if the label is just a generic type word
+        // (e.g. "function"), fall back to the qualified id/path instead.
+        const raw = n.label || n.name || '';
+        const generic = !raw || /^(function|method|class|node|unknown|anonymous)$/i.test(String(raw).trim());
+        const display = generic ? (n.id || n.name || raw || '') : raw;
+        return `<tr><td title="${esc(n.id||n.name||n.label)}">${esc(mgShortLabel(display))}</td><td>${esc(n.type||n.kind||'')}</td></tr>`;
+      }).join('') +
       (dead.length > 12 ? `<tr><td colspan="2" style="color:var(--text-xs);font-size:11px">…and ${dead.length-12} more</td></tr>` : '') +
       `</tbody></table>`;
   }
@@ -12820,6 +12859,18 @@ async function mgLoadReport() {
     // Extract markdown from JSON envelope {exists, report, stats}
     const markdown = (data && data.report) ? data.report : (typeof data === 'string' ? data : JSON.stringify(data, null, 2));
     const stats = (data && data.stats) || {};
+    // Real graph totals — the overview cards otherwise show the capped fetch size
+    const _mdN = (String(markdown).match(/\*\*Nodes\*\*:\s*([\d,]+)/i) || [])[1];
+    const _mdE = (String(markdown).match(/\*\*Edges\*\*:\s*([\d,]+)/i) || [])[1];
+    const _totN = stats.nodes || (_mdN ? Number(_mdN.replace(/,/g, '')) : null);
+    const _totE = stats.edges || (_mdE ? Number(_mdE.replace(/,/g, '')) : null);
+    if (_totN || _totE) {
+      window._mgRealTotals = { nodes: _totN, edges: _totE };
+      const nEl = document.getElementById('mg-stat-nodes');
+      const eEl = document.getElementById('mg-stat-edges');
+      if (_totN && nEl) { nEl.textContent = Number(_totN).toLocaleString(); if (nEl.previousElementSibling) nEl.previousElementSibling.textContent = 'Nodes'; }
+      if (_totE && eEl) { eEl.textContent = Number(_totE).toLocaleString(); if (eEl.previousElementSibling) eEl.previousElementSibling.textContent = 'Edges'; }
+    }
     mgRenderReport(markdown, el, stats);
   } catch (err) {
     el.innerHTML = `<div style="color:var(--red);font-size:12px">Error: ${esc(String(err))}</div>`;
@@ -13156,7 +13207,7 @@ function mgWikiFindRelated(nodeId) {
 }
 
 function mgWikiRefresh() {
-  _mgLoaded = false; _mgGraph = null;
+  _mgLoaded = false; _mgGraph = null; window._mgRealTotals = null;
   document.getElementById('mg-wiki-list').innerHTML = '<div class="loading-txt">Loading…</div>';
   loadMonograph();
 }
@@ -13383,7 +13434,7 @@ async function selectSwarmRun(idx) {
   detail.innerHTML =
     '<div style="margin-bottom:10px">' +
       '<div style="font-size:13px;font-weight:600;color:var(--text-hi)">' + esc((run.swarmId || run.id || '—').toString().slice(0, 14)) + '</div>' +
-      '<div style="font-size:11px;color:var(--text-lo);margin-top:3px">' + esc(run.topology || '—') + ' · ' + esc(run.consensus || '—') + ' · ' + (run.agentCount || 0) + ' agents</div>' +
+      '<div style="font-size:11px;color:var(--text-lo);margin-top:3px">' + esc(run.topology || '—') + ' · ' + (run.consensus ? esc(run.consensus) + ' vote-threshold' : '—') + ' · ' + (run.agentCount || 0) + ' agents</div>' +
     '</div>' +
     '<canvas id="swarm-topo-canvas" style="width:100%;max-width:380px;height:190px;display:block;border:1px solid var(--border);border-radius:6px;margin-bottom:12px"></canvas>' +
     '<div id="swarm-agent-list" style="margin-bottom:10px"></div>' +
@@ -13545,25 +13596,40 @@ function _renderChunks(list) {
     grid.innerHTML = '<div class="empty">No chunks indexed.<br><span style="font-size:11px;color:var(--text-xs)">Run /monomind:understand to build the index.</span></div>';
     return;
   }
-  grid.innerHTML = list.slice(0, 200).map(c => {
+  // Keep the rendered slice around so button handlers can look chunks up by
+  // index — interpolating chunk content into onclick attributes broke (and
+  // leaked markup) whenever the text contained quotes.
+  const shown = list.slice(0, 200);
+  window._chunksShown = shown;
+  grid.innerHTML = shown.map((c, i) => {
     const src = (c.source || c.file || '').split('/').slice(-2).join('/');
     const excerpt = (c.content || c.text || c.body || '').slice(0, 220);
     const ns = c.namespace || c.type || '';
-    const chunkId = JSON.stringify(c.id || c.path || c.source || '');
-    const chunkContent = JSON.stringify(c.content || c.text || c.body || '');
-    const chunkSrc = JSON.stringify(src);
     return '<div class="chunk-card" data-search="' + esc((src + ' ' + excerpt + ' ' + ns).toLowerCase()) + '">' +
       '<div class="chunk-src">' + esc(src || '—') + '</div>' +
       '<div class="chunk-excerpt">' + esc(excerpt) + '</div>' +
       '<div class="chunk-footer">' +
         (ns ? '<span class="chunk-ns">' + esc(ns) + '</span>' : '') +
-        '<button class="btn" style="margin-left:auto;font-size:10px;padding:1px 7px" onclick="openChunkEdit(' + chunkId + ',' + chunkContent + ',' + chunkSrc + ')">✎ Edit</button>' +
-        '<button class="btn" style="font-size:10px;padding:1px 7px;color:var(--red);border-color:var(--red)" onclick="deleteChunk(' + chunkId + ')">✕</button>' +
+        '<button class="btn" style="margin-left:auto;font-size:10px;padding:1px 7px" onclick="openChunkEditAt(' + i + ')">✎ Edit</button>' +
+        '<button class="btn" style="font-size:10px;padding:1px 7px;color:var(--red);border-color:var(--red)" onclick="deleteChunkAt(' + i + ')">✕</button>' +
       '</div>' +
     '</div>';
   }).join('');
 }
 
+function openChunkEditAt(i) {
+  const c = (window._chunksShown || [])[i];
+  if (!c) return;
+  const src = (c.source || c.file || '').split('/').slice(-2).join('/');
+  openChunkEdit(c.id || c.path || c.source || '', c.content || c.text || c.body || '', src);
+}
+
+function deleteChunkAt(i) {
+  const c = (window._chunksShown || [])[i];
+  if (!c) return;
+  deleteChunk(c.id || c.path || c.source || '');
+}
+
 function openChunkEdit(id, content, srcLabel) {
   _editChunkId = id;
   document.getElementById('chunk-modal-title').textContent = 'Edit Chunk';
@@ -13665,7 +13731,28 @@ async function loadAgentGraphTab() {
   if (bar) bar.innerHTML = '<div class="loading-txt">Loading…</div>';
   try {
     const data = await apiFetch('/api/graph?dir=' + enc(DIR));
-    _agData = data;
+    // /api/graph returns {nodes, edges} — session nodes + agenttype nodes.
+    // Transform into the summary/sessions shape this tab renders.
+    const nodes = Array.isArray(data && data.nodes) ? data.nodes : [];
+    const sessNodes = nodes.filter(n => n.type === 'session').sort((a, b) => (b.mtime || 0) - (a.mtime || 0));
+    const agNodes = nodes.filter(n => n.type === 'agenttype');
+    const sessions = sessNodes.map(n => ({
+      id: n.id,
+      turns: n.turns || 0,
+      spawnCount: Object.values(n.agentSpawns || {}).reduce((a, b) => a + b, 0),
+      toolCount: n.totalTools || 0,
+      tools: n.toolCounts || {},
+      agentTypes: n.agentSpawns || {},
+      cost: n.cost,
+    }));
+    _agData = {
+      sessions,
+      sessionCount: sessions.length,
+      agentTypes: agNodes.length,
+      totalSpawns: agNodes.reduce((a, n) => a + (n.totalSpawns || 0), 0),
+      totalToolCalls: sessions.reduce((a, s) => a + (s.toolCount || 0), 0),
+      totalCost: sessions.reduce((a, s) => a + (Number(s.cost) || 0), 0),
+    };
     _renderAgSummary();
     _renderAgSessList();
   } catch (e) {

package/packages/@monomind/cli/dist/src/ui/orgs.html

@@ -841,6 +841,15 @@ html, body {
                 <div class="meta-cell-value" id="meta-created" style="font-size:10px;color:var(--muted)">—</div>
               </div>
             </div>
+
+            <!-- Audit Coverage card (populated from /api/org-coverage; hidden when no coverage.json) -->
+            <div id="audit-coverage-card" style="display:none; background:var(--bg-panel); border:1px solid var(--border); border-radius:3px; padding:10px 14px;">
+              <div class="meta-cell-label" style="display:flex; align-items:center; gap:8px;">
+                AUDIT COVERAGE
+                <span id="acov-summary" style="letter-spacing:1px; color:var(--muted)"></span>
+              </div>
+              <div id="acov-areas" style="display:flex; flex-wrap:wrap; gap:6px; margin-top:2px;"></div>
+            </div>
             <div id="chart-svg-wrap">
               <svg id="org-chart-svg" viewBox="0 0 720 320">
                 <defs>
@@ -1203,6 +1212,51 @@ async function selectOrg(name) {
   }
 
   renderTab(currentTab);
+  loadAuditCoverage(listOrg);
+}
+
+// ── Audit Coverage card (reads .monomind/audit/coverage.json via /api/org-coverage) ──
+async function loadAuditCoverage(listOrg) {
+  const card = document.getElementById('audit-coverage-card');
+  card.style.display = 'none';
+  const esc = s => String(s ?? '').replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+  try {
+    const dir = listOrg.projectDir || window._orgDir;
+    const url = '/api/org-coverage' + (dir ? `?dir=${encodeURIComponent(dir)}` : '');
+    const r = await fetch(url);
+    if (!r.ok) return; // 404 = no coverage.json — keep card hidden
+    const cov = await r.json();
+    const areas = cov.areas && typeof cov.areas === 'object' ? cov.areas : {};
+    const names = Object.keys(areas);
+    if (!names.length) return;
+
+    const summ = [];
+    if (cov.areas_converged != null && cov.areas_total != null) summ.push(`${cov.areas_converged}/${cov.areas_total} CONVERGED`);
+    if (cov.current_area) summ.push(`NOW: ${String(cov.current_area).toUpperCase()}`);
+    document.getElementById('acov-summary').textContent = summ.join(' · ');
+
+    const verdictColor = v => {
+      const s = String(v || '').toUpperCase();
+      if (s.includes('CONVERGE') || s.includes('KEEP') || s.includes('PASS') || s.includes('DONE')) return 'var(--green, oklch(68% 0.2 150))';
+      if (s.includes('ITERATE') || s.includes('WARN')) return 'oklch(78% 0.18 80)';
+      if (s.includes('FAIL') || s.includes('REJECT')) return 'var(--red, oklch(62% 0.22 25))';
+      return 'var(--muted, oklch(55% 0.02 186))';
+    };
+    document.getElementById('acov-areas').innerHTML = names.map(name => {
+      const a = areas[name] || {};
+      const verdict = a.verdict || a.status || '—';
+      const value = a.value_delivered || a.valueDelivered || null;
+      const c = verdictColor(verdict);
+      return `<span style="display:inline-flex; align-items:center; gap:5px; font-size:9px; font-family:var(--mono);
+        border:1px solid var(--border); border-radius:3px; padding:2px 7px; color:var(--text);"
+        title="${esc(value || verdict)}">
+        ${esc(name)}
+        <span style="color:${c}; letter-spacing:1px;">${esc(String(verdict).toUpperCase())}</span>
+        ${value ? `<span style="color:var(--dim); max-width:180px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;">${esc(value)}</span>` : ''}
+      </span>`;
+    }).join('');
+    card.style.display = '';
+  } catch (_) { /* keep hidden */ }
 }
 
 function updateHeader(listOrg, data) {