@monoes/monomindcli 1.6.9 → 1.7.0

package/.claude/commands/monomind-improve.md

@@ -267,112 +267,43 @@ Also move any `skipElaboration: true` ideas directly to `Approved`.
 
 ## Step 7: Task Decomposer — Break Improvements into Subtasks
 
-### Task Board Setup
-- Check if a `monomind-task` board exists in the space (same lookup method as Step 3).
-- If not, create it with these columns:
-  - `Backlog`
-  - `Todo`
-  - `In Progress`
-  - `Review`
-  - `Human in Loop`
-  - `Done`
-- Store column IDs.
-
-### Decomposition into Professional Task Cards
+### Generate the TASKS Array
 
 Spawn a single `Software Architect` agent via the Agent tool. Provide it with:
 - All ideas in the `Approved` column (titles, descriptions, and all comments including implementation paths and research)
 - The `COMPONENT_ANALYSIS` from Step 2
 - The `PROJECT_CONTEXT`
+- **The Task Grouping Rules and Card Format from `monomind-task-engine` skill (Sections 1 & 2)** — include them verbatim in the agent prompt so it produces correctly structured tasks
 
-For each approved improvement, the agent must:
+The agent MUST produce a `TASKS` array following the `monomind-task-engine` card format (Section 2). Each task must comply with all 7 grouping rules (Section 1). For each approved improvement, decompose into 2-6 subtasks.
 
-1. **Analyze and decompose** into 2-6 subtasks. Each subtask must be a professional task card:
-
-```json
-{
-  "title": "Action-oriented title (verb + noun + context)",
-  "description": "## What\nExact deliverable (new file, modified function, endpoint, etc.).\n\n## Why\nBusiness or technical motivation — what breaks without this?\n\n## Where\nFile paths, module boundaries, related components.\n\n## Patterns\nExisting conventions to follow (naming, error handling, test style).",
-  "definition_of_done": [
-    "Specific, binary, verifiable condition (include HTTP codes, error shapes, edge cases)",
-    "Quantified thresholds where applicable (rate limits, timeouts, sizes)"
-  ],
-  "testing_criteria": {
-    "unit_tests": ["function(input) → expected outcome"],
-    "integration_tests": ["endpoint + method → status + response shape"],
-    "edge_cases": ["boundary condition → expected behavior"]
-  },
-  "checklist": [
-    "Write failing test for [specific behavior]",
-    "Implement [function/class] in [file path]",
-    "Run tests — verify green",
-    "Commit: '[type]: [description]'"
-  ],
-  "agent_type": "best-fit agent from 230+ roster",
-  "priority": "critical | high | medium | low",
-  "effort": "1-10 (1=trivial, 10=full day)",
-  "dependencies": ["titles of prerequisite tasks, or empty"]
-}
-```
-
-**Task generation rules:**
-- Tasks MUST be ordered so dependencies come first
-- Each task: 5-30 minutes for a single agent
-- Split anything larger
-- Every task starts with writing a test (TDD)
-- DOD items must be binary (pass/fail, not "looks good")
-- Testing criteria must name specific functions, endpoints, inputs
-
-2. **Create each subtask** as a card in `Backlog` (has deps) or `Todo` (no deps):
-   ```bash
-   monotask card create $TASK_BOARD_ID $COLUMN_ID "<title>" --json
-   monotask card tag add $TASK_BOARD_ID $CARD_ID "monomind-improve"
-   ```
-
-3. **Set description** with full context block:
-   ```bash
-   monotask card set-description $TASK_BOARD_ID $CARD_ID "<description with What/Why/Where/Patterns>"
-   ```
-
-4. **Add DOD comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Definition of Done\n- [ ] <condition 1>\n- [ ] <condition 2>\n..."
-   ```
-
-5. **Add testing criteria comment**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "## Testing Criteria\n\n### Unit Tests\n- <test 1>\n\n### Integration Tests\n- <test 1>\n\n### Edge Cases\n- <case 1>"
-   ```
-
-6. **Add agent assignment + metadata**:
-   ```bash
-   monotask card comment add $TASK_BOARD_ID $CARD_ID "Assigned agent: <agent_type>\nPriority: <priority>\nEffort: <effort>/10\nDependencies: <dep titles or none>\nSource: monomind-improve"
-   ```
+**If the architect has doubts** about decomposing an improvement (unclear scope, missing info):
+- Add a comment with the question
+- Move the improvement to `Deferred` instead of `Tasked`
 
-7. **Set priority**: `monotask card set-priority $TASK_BOARD_ID $CARD_ID <1-4>`
+Store the result as `TASKS` array.
 
-8. **Create checklist** (TDD implementation steps):
-   ```bash
-   monotask checklist add $TASK_BOARD_ID $CARD_ID "Implementation Steps" --json
-   ```
-   Then for each step:
-   ```bash
-   monotask checklist item-add $TASK_BOARD_ID $CARD_ID $CHECKLIST_ID "<step>"
-   ```
+### Invoke the Unified Task Engine
 
-9. **Comment on original improvement card** listing all subtask titles:
-   ```bash
-   monotask card comment add $BOARD_ID $IMPROVE_CARD_ID "Subtasks created:\n- <title> (agent: <type>, effort: <N>/10)\n- <title> (agent: <type>, effort: <N>/10)\n..."
-   ```
+Invoke the `monomind-task-engine` skill (Sections 3-7) with these parameters:
 
-10. **Move the improvement card** to `Tasked`:
-    ```bash
-    monotask card move $BOARD_ID $IMPROVE_CARD_ID $COL_TASKED --json
-    ```
+| Parameter | Value |
+|-----------|-------|
+| `TASKS` | The array from the architect agent |
+| `TASK_BOARD_ID` | From Step 3 (or let the engine set up the board) |
+| `REPO_NAME` | From Step 1 |
+| `SOURCE_TAG` | `"monomind-improve"` |
+| `SOURCE_SUMMARY` | First 100 chars of `$ARGUMENTS` |
+| `PARENT_CARD_ID` | Each `IMPROVE_CARD_ID` in the Approved column |
+| `PARENT_BOARD_ID` | `$BOARD_ID` (the monomind-improve board) |
+| `PARENT_DONE_COLUMN` | `$COL_TASKED` |
 
-**If the architect has doubts** about decomposing an improvement (unclear scope, missing info):
-- Add a comment with the question
-- Move the improvement to `Deferred` instead of `Tasked`
+The engine will:
+1. Create all cards on the monotask board (Section 4)
+2. Store execution strategy in session memory (Section 5)
+3. Run the **Final Dependency & Critical Path Review** (Section 6) — a fresh Code Reviewer agent validates prerequisites, context groups, critical path, parallel safety, and agent assignments
+4. Fix any blocker issues automatically, present warnings to user
+5. Present execution offer with mode recommendation (Section 7)
 
 ---
 
@@ -412,13 +343,10 @@ Output board references:
 
 ## Step 9: Offer to Execute Tasks
 
-If there are any tasked improvements (subtasks in Backlog/Todo), ask the user:
+The `monomind-task-engine` (Section 7) already presents the execution offer after the final review passes. If the user picks a mode there, it invokes `monomind-do` automatically.
 
-> **M subtasks are ready.** Want me to start executing them now?
->
-> Say **yes** to launch `/monomind:do` — it will pick up tasks one by one, execute them with the assigned agent, review for bugs, and loop until the queue is empty.
+If the engine's execution offer was skipped or the user deferred, and there are tasks in Todo, offer:
 
-If the user says yes, invoke:
 ```
-Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID")
+Skill("monomind-do", "--space $SPACE_ID --board $TASK_BOARD_ID --mode <parallel|minimal|sequential>")
 ```

package/.claude/helpers/graphify-freshen.cjs

@@ -1,118 +1,33 @@
 'use strict';
-// Runs at SessionStart — rebuilds the knowledge graph for the current project in the background.
+// Runs at SessionStart — rebuilds the knowledge graph using graphify (Python) in the background.
 // Fire-and-forget: spawns detached child, logs start, exits immediately without blocking session.
 const path = require('path');
 const fs = require('fs');
+const { spawn, execSync } = require('child_process');
 
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 const graphDir = path.join(projectDir, '.monomind', 'graph');
-const statsFile = path.join(graphDir, 'stats.json');
 
-// Locate @monomind/graph — check local, global npm, bundled-graph, pnpm
-function findGraphPkg(base) {
-  const candidates = [
-    path.join(base, 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-    path.join(base, 'packages', '@monomind', 'cli', 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-    path.join(base, 'packages', '@monomind', 'graph', 'dist', 'src', 'index.js'),
-  ];
-  // Check global npm install paths (monomind umbrella ships bundled-graph)
-  try {
-    const globalRoot = require('child_process').execSync('npm root -g', { encoding: 'utf-8' }).trim();
-    candidates.push(
-      path.join(globalRoot, 'monomind', 'packages', '@monomind', 'cli', 'bundled-graph', 'dist', 'src', 'index.js'),
-      path.join(globalRoot, 'monomind', 'node_modules', '@monoes', 'monomindcli', 'bundled-graph', 'dist', 'src', 'index.js'),
-    );
-  } catch {}
-  for (const c of candidates) {
-    if (fs.existsSync(c)) return c;
-  }
-  // pnpm: glob for @monomind+graph in .pnpm
-  const pnpmDir = path.join(base, 'node_modules', '.pnpm');
-  if (fs.existsSync(pnpmDir)) {
-    for (const entry of fs.readdirSync(pnpmDir)) {
-      if (entry.startsWith('@monomind+graph')) {
-        const p = path.join(pnpmDir, entry, 'node_modules', '@monomind', 'graph', 'dist', 'src', 'index.js');
-        if (fs.existsSync(p)) return p;
-      }
-    }
-  }
-  return null;
-}
-
-const graphPkg = findGraphPkg(projectDir);
-
-if (!graphPkg) {
-  console.log('[graph] skip: @monomind/graph not found');
+// Check if graphify CLI is available
+try {
+  execSync('graphify --help', { encoding: 'utf-8', stdio: 'ignore' });
+} catch {
+  console.log('[graph] skip: graphify not installed (run: uv tool install graphifyy)');
   process.exit(0);
 }
 
 fs.mkdirSync(graphDir, { recursive: true });
 
-// Locate the enricher script — works for both monorepo layout and npm-install layout
-const enricherCandidates = [
-  path.join(projectDir, 'packages', '@monomind', 'cli', 'dist', 'src', 'graph', 'enrich.mjs'),
-  path.join(projectDir, 'node_modules', '@monomind', 'cli', 'dist', 'src', 'graph', 'enrich.mjs'),
-];
-const enricherPath = enricherCandidates.find(p => fs.existsSync(p)) ?? null;
-const hasEnricher = enricherPath !== null;
-
-const { spawn } = require('child_process');
-const script = [
-  `import { buildGraph } from ${JSON.stringify('file://' + graphPkg)};`,
-  `import fs from 'fs';`,
-  `import path from 'path';`,
-  `const projectDir = ${JSON.stringify(projectDir)};`,
-  `const graphDir = ${JSON.stringify(graphDir)};`,
-  `const statsFile = ${JSON.stringify(statsFile)};`,
-  `buildGraph(projectDir, { codeOnly: true, outputDir: graphDir })`,
-  `.then(async r => {`,
-  `  fs.writeFileSync(statsFile, JSON.stringify({ nodes: r.analysis?.stats?.nodes, edges: r.analysis?.stats?.edges, files: r.filesProcessed, builtAt: Date.now() }));`,
-  `  console.log('[graph] built: ' + r.filesProcessed + ' files, ' + (r.analysis?.stats?.nodes ?? '?') + ' nodes');`,
-  hasEnricher ? [
-    `  try {`,
-    `    const { enrichGraph } = await import(${JSON.stringify('file://' + enricherPath)});`,
-    `    const er = await enrichGraph(projectDir, { graphDir });`,
-    `    console.log('[graph] enriched: ' + er.metrics.enrichedNodes + '/' + er.metrics.totalNodes + ' nodes');`,
-    `  } catch (ee) { console.error('[graph] enrichment failed:', ee.message); }`,
-  ].join('\n') : '',
-  // Normalize graph.json: add snake_case field aliases expected by the MCP tools
-  `  try {`,
-  `    const graphPath = path.join(graphDir, 'graph.json');`,
-  `    const raw = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));`,
-  `    if (Array.isArray(raw.nodes)) {`,
-  `      for (const n of raw.nodes) {`,
-  `        n.source_file = n.sourceFile || '';`,
-  `        n.source_location = n.sourceLocation || '';`,
-  `        n.file_type = n.fileType || '';`,
-  `        // Zero out degree for external symbols so they don't dominate god_nodes results`,
-  `        if (!n.source_file) n.degree = 0;`,
-  `      }`,
-  `      fs.writeFileSync(graphPath, JSON.stringify(raw));`,
-  `      console.log('[graph] normalized: added MCP field aliases to ' + raw.nodes.length + ' nodes');`,
-  `    }`,
-  `  } catch (ne) { console.error('[graph] normalize failed:', ne.message); }`,
-  // Ensure .monomind/graph symlink exists so the MCP server can locate the graph
-  `  try {`,
-  `    const monomindDir = path.join(projectDir, '.monomind');`,
-  `    fs.mkdirSync(monomindDir, { recursive: true });`,
-  `    const symlinkTarget = path.join(monomindDir, 'graph');`,
-  `    let exists = false;`,
-  `    try { fs.lstatSync(symlinkTarget); exists = true; } catch {}`,
-  `    if (!exists) { fs.symlinkSync(graphDir, symlinkTarget); console.log('[graph] created .monomind/graph symlink'); }`,
-  `  } catch (se) { console.error('[graph] symlink setup failed:', se.message); }`,
-  `})`,
-  `.catch(e => console.error('[graph] build failed:', e.message));`,
-].join('\n');
-
 const logPath = path.join(graphDir, 'build.log');
 let logFd;
 try { logFd = fs.openSync(logPath, 'a'); } catch { logFd = 'ignore'; }
-const child = spawn(process.execPath, ['--input-type=module'], {
+
+// graphify update <path> — re-extracts code files and rebuilds graph.json
+const child = spawn('graphify', ['update', projectDir], {
   detached: true,
-  stdio: ['pipe', logFd, logFd],
+  stdio: ['ignore', logFd, logFd],
+  cwd: projectDir,
 });
-child.stdin.write(script);
-child.stdin.end();
 child.unref();
 
 console.log('[graph] background build started for ' + projectDir);

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

@@ -961,6 +961,22 @@ const handlers = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // ── Monomind Control UI Status ────────────────────────────────────────
+    try {
+      var http = require('http');
+      var controlPort = 4242;
+      var req = http.get('http://localhost:' + controlPort + '/', function(res) {
+        if (res.statusCode === 200) {
+          console.log('[CONTROL_UI] UP — http://localhost:' + controlPort);
+        }
+        res.resume();
+      });
+      req.on('error', function() {
+        console.log('[CONTROL_UI] offline — run: npx monomind mcp start');
+      });
+      req.setTimeout(800, function() { req.destroy(); });
+    } catch (e) { /* non-fatal */ }
+
     // ── Worker Queue Resume (SR-003) ────────────────────────────────────
     try {
       var dispatchDir = path.join(CWD, '.monomind', 'worker-dispatch');

package/.claude/helpers/statusline.cjs

@@ -104,6 +104,18 @@ function safeStat(filePath) {
   return null;
 }
 
+// Project identifier — github owner/repo from git remote, else folder name
+function getProjectName() {
+  try {
+    const remote = safeExec('git remote get-url origin 2>/dev/null', 2000).trim();
+    if (remote) {
+      const m = remote.match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+      if (m) return `${m[1]}/${m[2]}`;
+    }
+  } catch { /* ignore */ }
+  return path.basename(CWD);
+}
+
 // Shared settings cache — read once, used by multiple functions
 let _settingsCache = undefined;
 function getSettings() {
@@ -565,37 +577,56 @@ function getAgentDBStats() {
   let namespaces = 0;
   let hasHnsw = false;
 
-  // 0. PRIMARY: Count drawers from Memory Palace (this is where memories actually live)
+  // Count all memory entries across sources (sum, not max)
+  // 0. Palace drawers
   const drawersPath = path.join(CWD, '.monomind', 'palace', 'drawers.jsonl');
   const drawersStat = safeStat(drawersPath);
   if (drawersStat) {
     dbSizeKB += drawersStat.size / 1024;
     try {
-      const lines = fs.readFileSync(drawersPath, 'utf-8').split('\n').filter(Boolean);
-      if (lines.length > vectorCount) vectorCount = lines.length;
+      vectorCount += fs.readFileSync(drawersPath, 'utf-8').split('\n').filter(Boolean).length;
+    } catch { /* ignore */ }
+  }
+
+  // 1. Palace closets
+  const closetsPath = path.join(CWD, '.monomind', 'palace', 'closets.jsonl');
+  const closetsStat = safeStat(closetsPath);
+  if (closetsStat) {
+    dbSizeKB += closetsStat.size / 1024;
+    try {
+      vectorCount += fs.readFileSync(closetsPath, 'utf-8').split('\n').filter(Boolean).length;
     } catch { /* ignore */ }
   }
 
-  // 1. Count real entries from auto-memory-store.json (intelligence layer)
+  // 2. Knowledge chunks
+  const chunksPath = path.join(CWD, '.monomind', 'knowledge', 'chunks.jsonl');
+  const chunksStat = safeStat(chunksPath);
+  if (chunksStat) {
+    dbSizeKB += chunksStat.size / 1024;
+    try {
+      vectorCount += fs.readFileSync(chunksPath, 'utf-8').split('\n').filter(Boolean).length;
+    } catch { /* ignore */ }
+  }
+
+  // 3. Auto-memory store (intelligence layer)
   const storePath = path.join(CWD, '.monomind', 'data', 'auto-memory-store.json');
   const storeStat = safeStat(storePath);
   if (storeStat) {
     dbSizeKB += storeStat.size / 1024;
     try {
       const store = JSON.parse(fs.readFileSync(storePath, 'utf-8'));
-      const storeCount = Array.isArray(store) ? store.length : (store?.entries?.length || 0);
-      if (storeCount > vectorCount) vectorCount = storeCount;
-    } catch { /* fall back to size estimate */ }
+      vectorCount += Array.isArray(store) ? store.length : (store?.entries?.length || 0);
+    } catch { /* ignore */ }
   }
 
-  // 2. Count entries from ranked-context.json
+  // 4. Ranked context
   const rankedPath = path.join(CWD, '.monomind', 'data', 'ranked-context.json');
   try {
     const ranked = readJSON(rankedPath);
-    if (ranked?.entries?.length > vectorCount) vectorCount = ranked.entries.length;
+    if (ranked?.entries?.length) vectorCount += ranked.entries.length;
   } catch { /* ignore */ }
 
-  // 3. Add DB file sizes
+  // 5. DB file sizes
   const dbFiles = [
     path.join(CWD, 'data', 'memory.db'),
     path.join(CWD, '.monomind', 'memory.db'),
@@ -603,31 +634,17 @@ function getAgentDBStats() {
   ];
   for (const f of dbFiles) {
     const stat = safeStat(f);
-    if (stat) {
-      dbSizeKB += stat.size / 1024;
-      namespaces++;
-    }
+    if (stat) { dbSizeKB += stat.size / 1024; namespaces++; }
   }
 
-  // 4. Check for graph data
-  const graphPath = path.join(CWD, 'data', 'memory.graph');
-  const graphStat = safeStat(graphPath);
-  if (graphStat) dbSizeKB += graphStat.size / 1024;
-
-  // 5. HNSW index
+  // 6. HNSW index
   const hnswPaths = [
     path.join(CWD, '.swarm', 'hnsw.index'),
     path.join(CWD, '.monomind', 'hnsw.index'),
   ];
   for (const p of hnswPaths) {
-    const stat = safeStat(p);
-    if (stat) {
-      hasHnsw = true;
-      break;
-    }
+    if (safeStat(p)) { hasHnsw = true; break; }
   }
-
-  // HNSW is available if memory package is present
   if (!hasHnsw) {
     const memPkgPaths = [
       path.join(CWD, 'packages', '@monomind', 'memory', 'dist'),
@@ -641,6 +658,26 @@ function getAgentDBStats() {
   return { vectorCount, dbSizeKB: Math.floor(dbSizeKB), namespaces, hasHnsw };
 }
 
+// Graphify knowledge graph stats
+function getGraphifyStats() {
+  const statsPath = path.join(CWD, '.monomind', 'graph', 'stats.json');
+  const graphPath = path.join(CWD, '.monomind', 'graph', 'graph.json');
+  try {
+    const s = readJSON(statsPath);
+    if (s && s.nodes !== undefined) return { nodes: s.nodes, edges: s.edges || 0, exists: true };
+  } catch { /* ignore */ }
+  try {
+    const stat = safeStat(graphPath);
+    if (stat && stat.size < 10 * 1024 * 1024) {
+      const g = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
+      const nodes = Array.isArray(g.nodes) ? g.nodes.length : 0;
+      const edges = (Array.isArray(g.edges) ? g.edges : (Array.isArray(g.links) ? g.links : [])).length;
+      return { nodes, edges, exists: true };
+    }
+  } catch { /* ignore */ }
+  return { nodes: 0, edges: 0, exists: false };
+}
+
 // Memory Palace stats — drawers.jsonl + kg.json (the real persistent memory)
 function getMemoryPalaceStats() {
   const palaceDir = path.join(CWD, '.monomind', 'palace');
@@ -907,9 +944,10 @@ function generateStatusline() {
   const tokens    = getTokenStats();
   const parts     = [];
 
-  // Brand + swarm dot
+  // Brand + project + swarm dot
   const swarmDot = swarm.coordinationActive ? `${x.green}●${x.reset}` : `${x.slate}○${x.reset}`;
-  parts.push(`${x.bold}${x.purple}▊ Monomind${x.reset} ${swarmDot}`);
+  const projName = getProjectName();
+  parts.push(`${x.bold}${x.purple}▊ MonoMind${x.reset} ${x.teal}${projName}${x.reset} ${swarmDot}`);
 
   // Git branch + changes (compact)
   if (git.gitBranch) {
@@ -958,12 +996,18 @@ function generateStatusline() {
     parts.push(`${x.purple}🧠 ${autoMemCompact.count}m${x.reset}${typeSuffix}`);
   }
 
-  // Knowledge chunks (Task 28) — show when populated
+  // Knowledge chunks — show when populated
   if (knowledge.chunks > 0) {
     parts.push(`${x.teal}📚 ${knowledge.chunks}k${x.reset}`);
   }
 
-  // Triggers (Task 32) — show when populated
+  // Graphify code graph
+  const gfCompact = getGraphifyStats();
+  if (gfCompact.exists) {
+    parts.push(`${x.sky}🔗 ${gfCompact.nodes}n ${gfCompact.edges}e${x.reset}`);
+  }
+
+  // Triggers — show when populated
   if (triggers.triggers > 0) {
     parts.push(`${x.mint}🎯 ${triggers.triggers}t${x.reset}`);
   }
@@ -997,7 +1041,7 @@ function generateDashboard() {
   const security    = getSecurityStatus();
   const swarm       = getSwarmStatus();
   const system      = getSystemMetrics();
-  const adrs        = getADRStatus();
+  // adrs removed — internal dev metric
   const hooks       = getHooksStatus();
   const agentdb     = getAgentDBStats();
   const tests       = getTestStats();
@@ -1015,7 +1059,8 @@ function generateDashboard() {
 
   // ── Header: brand + git + model + session ────────────────────
   const swarmDot = swarm.coordinationActive ? `${x.green}● LIVE${x.reset}` : `${x.slate}○ IDLE${x.reset}`;
-  let hdr = `${x.bold}${x.purple}▊ Monomind ${VERSION}${x.reset}  ${swarmDot}  ${x.teal}${x.bold}${git.name}${x.reset}`;
+  const projName = getProjectName();
+  let hdr = `${x.bold}${x.purple}▊ MonoMind${x.reset} ${x.dim}${VERSION}${x.reset}  ${swarmDot}  ${x.teal}${x.bold}${projName}${x.reset}`;
 
   if (git.gitBranch) {
     hdr += `  ${DIV}  ${x.sky}⎇ ${x.bold}${git.gitBranch}${x.reset}`;
@@ -1036,30 +1081,29 @@ function generateDashboard() {
   lines.push(hdr);
   lines.push(SEP);
 
-  // ── Row 1: Intelligence & Learning ───────────────────────────
-  const intellCol = pctColor(system.intelligencePct);
-  const intellBar = blockBar(system.intelligencePct, 100, 6);
-
-  // Knowledge (Task 28)
+  // ── Row 1: Knowledge & Graphify ──────────────────────────────
   const knowStr = knowledge.chunks > 0
     ? `${x.teal}📚 ${x.bold}${knowledge.chunks}${x.reset}${x.slate} chunks${x.reset}`
     : `${x.slate}📚 no chunks${x.reset}`;
 
-  // Skills (Task 45)
   const skillStr = knowledge.skills > 0
     ? `  ${x.mint}✦ ${knowledge.skills} skills${x.reset}`
     : '';
 
-  // Patterns
   const patStr = progress.patternsLearned > 0
     ? `${x.gold}${progress.patternsLearned >= 1000 ? (progress.patternsLearned / 1000).toFixed(1) + 'k' : progress.patternsLearned} patterns${x.reset}`
     : `${x.slate}0 patterns${x.reset}`;
 
+  const gf = getGraphifyStats();
+  const gfStr = gf.exists
+    ? `${x.sky}🔗 ${x.bold}${gf.nodes}${x.reset}${x.slate} nodes · ${x.reset}${x.sky}${x.bold}${gf.edges}${x.reset}${x.slate} edges${x.reset}`
+    : `${x.slate}🔗 no graph${x.reset}`;
+
   lines.push(
     `${x.purple}💡  INTEL${x.reset}    ` +
-    `${intellCol}${intellBar} ${x.bold}${system.intelligencePct}%${x.reset}   ${DIV}   ` +
     `${knowStr}${skillStr}   ${DIV}   ` +
-    patStr
+    `${patStr}   ${DIV}   ` +
+    gfStr
   );
   lines.push(SEP);
 
@@ -1112,26 +1156,14 @@ function generateDashboard() {
   );
   lines.push(SEP);
 
-  // ── Row 3: Architecture & Security ───────────────────────────
-  const adrCol = adrs.count > 0
-    ? (adrs.implemented >= adrs.count ? x.green : x.gold)
-    : x.slate;
-  const adrStr = adrs.count > 0
-    ? `${adrCol}${x.bold}${adrs.implemented}${x.reset}${x.slate}/${x.reset}${x.white}${adrs.count}${x.reset} ADRs`
-    : `${x.slate}no ADRs${x.reset}`;
-
-  const dddCol = pctColor(progress.dddProgress);
-  const dddBar = blockBar(progress.dddProgress, 100, 5);
-
+  // ── Row 3: Security ──────────────────────────────────────────
   const cveStatus = security.totalCves === 0
     ? (security.status === 'NONE' ? `${x.slate}not scanned${x.reset}` : `${x.green}✔ clean${x.reset}`)
     : `${x.coral}${security.cvesFixed}/${security.totalCves} fixed${x.reset}`;
 
   lines.push(
-    `${x.purple}🧩  ARCH${x.reset}     ` +
-    `${adrStr}   ${DIV}   ` +
-    `DDD ${dddBar} ${dddCol}${x.bold}${progress.dddProgress}%${x.reset}   ${DIV}   ` +
-    `🛡️  ${sec.col}${sec.label}${x.reset}   ${DIV}   ` +
+    `${x.purple}🛡️  SECURITY${x.reset}  ` +
+    `${sec.col}${sec.label}${x.reset}   ${DIV}   ` +
     `CVE ${cveStatus}`
   );
   lines.push(SEP);
@@ -1190,13 +1222,6 @@ function generateDashboard() {
     siStr = `${x.slate}📄 no shared instructions${x.reset}`;
   }
 
-  // Domains
-  const domCol = progress.domainsCompleted >= 4 ? x.green
-               : progress.domainsCompleted >= 2 ? x.gold
-               : progress.domainsCompleted >= 1 ? x.orange
-               : x.slate;
-  const domBar = blockBar(progress.domainsCompleted, progress.totalDomains);
-
   let monthStr = '';
   if (tokens) {
     const mFmt = tokens.monthCost >= 100 ? `$${tokens.monthCost.toFixed(2)}` : tokens.monthCost >= 1 ? `$${tokens.monthCost.toFixed(3)}` : `$${tokens.monthCost.toFixed(4)}`;
@@ -1205,7 +1230,6 @@ function generateDashboard() {
   lines.push(
     `${x.slate}📋  CONTEXT${x.reset}  ` +
     `${siStr}   ${DIV}   ` +
-    `${x.teal}🏗 ${domBar} ${domCol}${x.bold}${progress.domainsCompleted}${x.reset}${x.slate}/${x.reset}${x.white}${progress.totalDomains}${x.reset} domains   ${DIV}   ` +
     `${x.dim}💾 ${system.memoryMB} MB RAM${x.reset}` +
     monthStr
   );