monomind 2.7.5 → 2.7.6

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.js

@@ -1,21 +1,33 @@
 /**
- * EWC++ (Elastic Weight Consolidation) Implementation
- * Prevents catastrophic forgetting of important patterns during continual learning
+ * EWC-inspired pattern consolidation.
  *
- * Algorithm:
- * L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ * Protects high-importance stored patterns from being overwritten by newer,
+ * similar ones — the pattern-store analogue of avoiding catastrophic
+ * forgetting.
  *
- * Where:
- * - L_new is the loss on new data
- * - lambda is the importance weight (ewcLambda)
- * - F_i is the Fisher information for parameter i
- * - theta_i is the current parameter value
- * - theta_old_i is the previous parameter value
+ * HONEST SCOPE — read before extending this:
+ * This is *not* Elastic Weight Consolidation. Real EWC penalises drift in a
+ * model's parameters using Fisher information estimated from training
+ * gradients:
  *
- * Features:
- * - Fisher Information Matrix computation from gradient history
- * - Online EWC updates for streaming patterns
- * - Selective consolidation based on pattern importance
+ *   L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ *
+ * There is no model here, no training loop, and therefore no gradients. What
+ * this file actually computes is a per-dimension importance weight from the
+ * *squared embedding values* of stored patterns, used as a stand-in for the
+ * Fisher diagonal (see computeFisherMatrix — the substitution is noted at the
+ * line that performs it), smoothed with an EMA and applied as a quadratic
+ * penalty when a new pattern would displace an existing one.
+ *
+ * That heuristic is real, deterministic, and useful. The EWC name and the
+ * formula above describe the *inspiration*, not the implementation — do not
+ * cite this as an EWC implementation or reason about it as if `F_i` carried
+ * Fisher semantics.
+ *
+ * What it does:
+ * - Per-dimension importance from squared embedding magnitudes (gradient proxy)
+ * - Online EMA updates as new patterns stream in
+ * - Selective consolidation based on that importance
  * - Persistent storage in .swarm/ewc-fisher.json
  *
  * @module v1/cli/memory/ewc-consolidation

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -24,7 +24,15 @@ import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
  * falling back to home directory
  */
 function getDataDir() {
-    const cwd = process.cwd();
+    // MONOMIND_CWD is the project root; process.cwd() is wherever the process
+    // happened to start. For a global or MCP install those differ — the server
+    // is launched by the editor, not from the project — so keying the pattern
+    // store off cwd scattered a project's learned patterns across whatever
+    // directory the server booted in (or fell through to ~/.monomind entirely).
+    // Every other consumer resolves the project this way; see getProjectCwd()
+    // in mcp-tools/types.ts. Inlined rather than imported to keep the memory
+    // layer independent of the MCP tool layer.
+    const cwd = process.env.MONOMIND_CWD || process.cwd();
     const localDir = join(cwd, '.monomind', 'neural');
     const homeDir = join(homedir(), '.monomind', 'neural');
     // Prefer local directory if .monomind exists
@@ -1083,6 +1091,14 @@ export function clearIntelligence() {
     sonaCoordinator = null;
     reasoningBank = null;
     intelligenceInitialized = false;
+    // Must be dropped too. initializeIntelligence() returns an existing
+    // initPromise without re-running init, so leaving the resolved promise here
+    // made every later init report success while sonaCoordinator and
+    // reasoningBank stayed null — after which the non-null assertions in
+    // clearAllPatterns()/getAllPatterns() etc. threw
+    // "Cannot read properties of null". Intelligence could never be
+    // re-initialized after a clear, for the life of the process.
+    initPromise = null;
     globalStats = {
         trajectoriesRecorded: 0,
         lastAdaptation: null

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -178,6 +178,18 @@ async function flushBackend(backend) {
     }
     catch { /* best effort */ }
 }
+/** Loads the local embedding model.
+ *
+ *  This is the single point where `onnxruntime-node` enters the CLI process
+ *  (via @huggingface/transformers). Once it has run, the process is subject to
+ *  docs/adrs/ADR-R001-onnxruntime-process-teardown.md: calling process.exit()
+ *  will abort with SIGABRT ("mutex lock failed") instead of exiting cleanly,
+ *  and disposing the pipeline first does not help.
+ *
+ *  Anything that reaches this — `doctor`, `memory store`, `memory search`, the
+ *  MCP memory tools — inherits that constraint, which is why it bit commands
+ *  that look nothing like ML work. Adding a new caller is fine; adding a new
+ *  process-exit path is not. */
 async function loadEmbedder() {
     if (_embedder)
         return;

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

@@ -2,6 +2,7 @@
 // monolean: single-process inter-org — upgrade path = daemon-to-daemon HTTP when multi-host is real
 import { readFileSync, mkdirSync, writeFileSync, existsSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
+import { reapOrphanedSdkProcesses } from '../utils/resource-governor.js';
 import { OrgBus } from './bus.js';
 import { PolicyEngine } from './policy.js';
 import { Mailbox } from './mailbox.js';
@@ -235,8 +236,11 @@ export class OrgDaemon {
         // monolean: process-scoped listener — upgrade path = per-org tracking
         const crashCleanup = () => {
             try {
-                const rg = require('../utils/resource-governor.js');
-                rg.reapOrphanedSdkProcesses(new Set(), process.pid);
+                // Statically imported: a process 'exit' handler must be synchronous,
+                // so `await import()` is unavailable — and a bare require() throws
+                // "require is not defined" in this ESM package. Guarded by
+                // no-cjs-require-in-esm.test.ts.
+                reapOrphanedSdkProcesses(new Set(), process.pid);
             }
             catch { /* best-effort */ }
         };

package/packages/@monomind/cli/dist/src/routing/embed-worker.js

@@ -56,6 +56,14 @@ async function main() {
     // and the parent's `close` listener waits until it force-kills us at the
     // timeout — discarding the result we already wrote. Force-exit once the
     // write is flushed (same onnx-teardown class as memory.ts's #1428 fix).
+    //
+    // The force-exit is REQUIRED here and FORBIDDEN in the main CLI process,
+    // where the identical thread pool makes process.exit() abort with SIGABRT
+    // instead. Same root cause, opposite fix — see
+    // docs/adrs/ADR-R001-onnxruntime-process-teardown.md before changing either.
+    // Safe here because we are a disposable child that has already flushed its
+    // result, and the parent resolves on the stdout marker rather than our exit
+    // code (route-layer-factory.ts), so even an aborted teardown loses nothing.
     const wroteSynchronously = process.stdout.write(`\n__ROUTE_RESULT__${JSON.stringify(result)}\n`);
     if (wroteSynchronously) {
         process.exit(0);

package/packages/@monomind/cli/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.7.5",
+  "version": "2.7.6",
   "type": "module",
-  "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
+  "description": "CLI engine for Monomind \u2014 an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "sideEffects": false,
@@ -81,9 +81,11 @@
     "README.md"
   ],
   "scripts": {
+    "prebuild": "rm -rf dist",
     "build": "tsc && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/ui && cp src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html dist/src/ui/ && rm -rf dist/src/ui/data && cp -r src/ui/data dist/src/ui/data",
     "build:loose": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/ui && cp src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html dist/src/ui/ && rm -rf dist/src/ui/data && cp -r src/ui/data dist/src/ui/data",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
     "prepublishOnly": "node ../../@monoes/monodesign/scripts/sync-skill.mjs && cp ../../../README.md ./README.md",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
@@ -97,7 +99,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.207",
     "@monoes/monobrowse": "^1.0.6",
     "@monoes/monodesign": "^1.2.0",
-    "@monoes/monograph": "^1.5.3",
+    "@monoes/monograph": "^1.5.4",
     "@noble/ed25519": "^2.1.0",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",

package/scripts/generate-channel-profile-assets.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Generates the shared "monoes" monkey mascot avatar + one channel-appropriate
+# banner per platform (each referencing the avatar so the character stays
+# visually consistent), via monoagentcli's Gemini browser crawl.
+set -uo pipefail
+
+OUT="/Volumes/media/projects/monoes/monomind/.monomind/orgs/monomind-growth/workspace/reports/channel-profiles"
+mkdir -p "$OUT"
+
+log() { echo "[$(date '+%H:%M:%S')] $*" >&2; }
+
+gen() {
+  local name="$1" prompt="$2" ref="${3:-}"
+  if [ -s "$OUT/$name.png" ]; then
+    log "Skipping $name, already exists"
+    echo "$OUT/$name.png"
+    return 0
+  fi
+  local cfg
+  if [ -n "$ref" ]; then
+    cfg=$(printf '{"prompt":"%s","referenceImagePath":"%s","maxWaitSeconds":150,"downloadDir":"%s"}' "$prompt" "$ref" "$OUT")
+  else
+    cfg=$(printf '{"prompt":"%s","maxWaitSeconds":150,"downloadDir":"%s"}' "$prompt" "$OUT")
+  fi
+  log "Generating $name: $prompt"
+  local out errfile
+  errfile=$(mktemp)
+  out=$(monoagentcli --profile monoes node run gemini.generate_image --headless --output json --config "$cfg" 2>"$errfile")
+  if [ -s "$errfile" ]; then log "  (stderr: $(cat "$errfile"))"; fi
+  rm -f "$errfile"
+  local path
+  path=$(echo "$out" | node -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const j=JSON.parse(d);const img=j.main?.[0]?.json?.images?.[0];console.log(img?img.path:'');}catch(e){console.log('');}})")
+  if [ -z "$path" ]; then
+    log "FAILED: $name — raw output: $out"
+    echo "FAIL:$name" >> "$OUT/.gen-status"
+    return 1
+  fi
+  local final="$OUT/$name.png"
+  mv "$path" "$final"
+  log "OK: $name -> $final"
+  echo "OK:$name:$final" >> "$OUT/.gen-status"
+  echo "$final"
+}
+
+# Reference is the REAL existing monomind logo (assets/logo.png) — a soft
+# 3D-rendered meditating monkey with a glowing brain, blue "M" neckerchief,
+# white background. Every banner below must keep that exact character,
+# rendering style, and white/clean background — only the pose/prop changes.
+AVATAR="$OUT/avatar-monoes.png"
+if [ ! -s "$AVATAR" ]; then log "Avatar missing at $AVATAR, aborting"; exit 1; fi
+log "Using real logo as reference: $AVATAR"
+
+# Prompt template proven to preserve the character (tested live 2026-07-24):
+# "same cute 3D cartoon monkey mascot with blue M neckerchief, <action>"
+log "=== Banners (same character/render style as reference, no added text) ==="
+gen "banner-x-twitter"  "same cute 3D cartoon monkey mascot with blue M neckerchief, sitting at laptop" "$AVATAR"
+gen "banner-linkedin"   "same cute 3D cartoon monkey mascot with blue M neckerchief, wearing a tiny tie" "$AVATAR"
+gen "banner-reddit"     "same cute 3D cartoon monkey mascot with blue M neckerchief, reading a book" "$AVATAR"
+gen "banner-discord"    "same cute 3D cartoon monkey mascot with blue M neckerchief, wearing headphones" "$AVATAR"
+gen "banner-bluesky"    "same cute 3D cartoon monkey mascot with blue M neckerchief, holding paper airplane" "$AVATAR"
+gen "banner-mastodon"   "same cute 3D cartoon monkey mascot with blue M neckerchief, watering a small plant" "$AVATAR"
+gen "banner-youtube"    "same cute 3D cartoon monkey mascot with blue M neckerchief, holding small camera" "$AVATAR"
+gen "banner-devto"      "same cute 3D cartoon monkey mascot with blue M neckerchief, writing in notebook" "$AVATAR"
+gen "banner-newsletter" "same cute 3D cartoon monkey mascot with blue M neckerchief, holding an envelope" "$AVATAR"
+
+log "=== Done ==="
+cat "$OUT/.gen-status" 2>/dev/null

package/scripts/growth-content-calendar.mjs

@@ -30,17 +30,20 @@ function parseArticles(text, org) {
     const [, slug, title] = m;
     let heroImage = null;
     let supportingImages = [];
+    let diagrams = [];
     const bodyLines = [];
     for (const line of lines.slice(1)) {
       const heroMatch = line.match(/^HeroImage:\s*(.+?)\s*$/i);
       const suppMatch = line.match(/^SupportingImages:\s*(.+?)\s*$/i);
+      const diagMatch = line.match(/^Diagrams:\s*(.+?)\s*$/i);
       if (heroMatch) { heroImage = heroMatch[1]; continue; }
       if (suppMatch) { supportingImages = suppMatch[1].split(',').map((s) => s.trim()).filter(Boolean); continue; }
+      if (diagMatch) { diagrams = diagMatch[1].split(',').map((s) => s.trim()).filter(Boolean); continue; }
       bodyLines.push(line);
     }
     const body = bodyLines.join('\n').trim();
     if (!body) continue;
-    articles.push({ org, slug: slug.trim(), title: title.trim(), heroImage, supportingImages, body });
+    articles.push({ org, slug: slug.trim(), title: title.trim(), heroImage, supportingImages, diagrams, body });
   }
   return articles;
 }
@@ -80,15 +83,25 @@ function escapeHtml(s) {
   return String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
 }
 
-function mdToHtml(md) {
-  // Minimal renderer: paragraphs, headings, code fences, bold/italic, links, tables.
-  return escapeHtml(md)
+function mdToHtml(md, copiedSet) {
+  // Minimal renderer: paragraphs, headings, code fences, bold/italic, inline images, tables.
+  const figures = [];
+  const placeholder = (i) => `[[[FIGURE-${i}]]]`;
+  const withPlaceholders = md.replace(/!\[(.*?)\]\((?:\.\/)?(.*?)\)/g, (_, alt, src) => {
+    const idx = figures.length;
+    const visible = copiedSet.has(src);
+    figures.push(visible ? `<figure class="inline-diagram"><img src="./${escapeHtml(src)}" alt="${escapeHtml(alt)}"><figcaption>${escapeHtml(alt)}</figcaption></figure>` : '');
+    return placeholder(idx);
+  });
+  let html = escapeHtml(withPlaceholders)
     .replace(/^### (.+)$/gm, '<h4>$1</h4>')
     .replace(/^## (.+)$/gm, '<h3>$1</h3>')
     .replace(/^# (.+)$/gm, '<h2>$1</h2>')
     .replace(/```([\s\S]*?)```/g, (_, code) => `<pre><code>${code}</code></pre>`)
     .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
     .replace(/\n\n/g, '</p><p>');
+  figures.forEach((fig, i) => { html = html.replace(placeholder(i), fig); });
+  return html;
 }
 
 function render() {
@@ -121,7 +134,7 @@ function render() {
   // copy every referenced image (article hero/supporting + post images) alongside html/md
   const copied = new Set();
   const allImageNames = new Set([
-    ...articles.flatMap((a) => [a.heroImage, ...a.supportingImages].filter(Boolean)),
+    ...articles.flatMap((a) => [a.heroImage, ...a.supportingImages, ...a.diagrams].filter(Boolean)),
     ...posts.map((p) => p.image).filter(Boolean),
   ]);
   for (const name of allImageNames) {
@@ -172,12 +185,14 @@ function render() {
   function articleCard(a) {
     const img = a.heroImage && copied.has(a.heroImage) ? `<img class="hero" src="./${escapeHtml(a.heroImage)}" alt="">` : '';
     const supp = a.supportingImages.filter((n) => copied.has(n)).map((n) => `<img class="supporting" src="./${escapeHtml(n)}" alt="">`).join('');
+    const missingDiagrams = a.diagrams.filter((n) => !copied.has(n));
     return `<div class="article">
       <div class="article-slug">${escapeHtml(a.slug)}</div>
       <h3 class="article-title">${escapeHtml(a.title)}</h3>
       ${img}
       ${supp ? `<div class="supporting-row">${supp}</div>` : ''}
-      <div class="article-body"><p>${mdToHtml(a.body)}</p></div>
+      <div class="article-body"><p>${mdToHtml(a.body, copied)}</p></div>
+      ${missingDiagrams.length ? `<div class="missing-note">Missing diagram file(s) referenced but not found: ${missingDiagrams.map(escapeHtml).join(', ')}</div>` : ''}
     </div>`;
   }
 
@@ -211,6 +226,11 @@ main { max-width:860px; margin:0 auto; padding:0 1.5rem 4rem; }
 .supporting-row img { width:100%; border-radius:8px; }
 .article-body { font-size:.92rem; color:var(--text); }
 .article-body p { white-space:pre-wrap; }
+.article-body h2, .article-body h3, .article-body h4 { white-space:normal; }
+.inline-diagram { margin:1.2rem 0; }
+.inline-diagram img { width:100%; border-radius:8px; background:var(--espresso); }
+.inline-diagram figcaption { font-size:.78rem; color:var(--muted); margin-top:.3rem; text-align:center; }
+.missing-note { margin-top:1rem; padding:.6rem .8rem; border:1px dashed var(--border); border-radius:8px; font-size:.78rem; color:var(--muted); }
 .card { background:var(--card); border:1px solid var(--border); border-radius:12px; padding:1.1rem 1.3rem; margin-bottom:1rem; }
 .channel { font-size:.72rem; font-weight:700; text-transform:uppercase; letter-spacing:.04em; color:var(--accent); margin-bottom:.6rem; }
 .based-on { font-weight:400; text-transform:none; letter-spacing:0; color:var(--muted); font-style:italic; }
@@ -231,7 +251,10 @@ ${!articles.length && !posts.length ? '<div class="empty">Nothing finalized yet
 </body></html>`;
   fs.writeFileSync(path.join(OUT_DIR, 'content-calendar.html'), html);
 
-  console.log(`Wrote ${articles.length} article(s), ${posts.length} post(s), ${copied.size} image(s) -> ${path.relative(ROOT, OUT_DIR)}`);
+  const totalDiagrams = articles.reduce((n, a) => n + a.diagrams.length, 0);
+  const underDiagrammed = articles.filter((a) => a.diagrams.length < 2).map((a) => a.slug);
+  console.log(`Wrote ${articles.length} article(s), ${posts.length} post(s), ${copied.size} image(s) (incl. ${totalDiagrams} diagram(s)) -> ${path.relative(ROOT, OUT_DIR)}`);
+  if (underDiagrammed.length) console.log(`Note: fewer than 2 diagrams on: ${underDiagrammed.join(', ')}`);
 }
 
 render();

package/scripts/growth-profile-kit.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+// Renders channel-profiles.html: per-channel profile picture, banner, and
+// bio copy for setting up monomind's social/community accounts. Images are
+// generated by scripts/generate-channel-profile-assets.sh (monoagentcli
+// Gemini crawl, "monoes" monkey mascot, referenceImagePath-chained for
+// character consistency). Regenerate after that script finishes:
+//   node scripts/growth-profile-kit.mjs
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ROOT = process.cwd();
+const OUT_DIR = path.join(ROOT, '.monomind/orgs/monomind-growth/workspace/reports/channel-profiles');
+const AVATAR = 'avatar-monoes.png';
+
+const CHANNELS = [
+  {
+    name: 'X/Twitter', banner: 'banner-x-twitter.png',
+    specs: 'Profile photo 400x400 (displayed circular) · Header 1500x500 · Name ≤50 chars · Bio ≤160 chars',
+    displayName: 'monomind', handle: '@monomind_ai (suggested, verify availability)',
+    bio: "Claude Code gives you an agent. monomind gives you a company. Open-source persistent agent orgs — real hierarchy, budgets, human approval. npx monomind@latest init",
+  },
+  {
+    name: 'LinkedIn (Company Page)', banner: 'banner-linkedin.png',
+    specs: 'Logo 300x300 · Cover 1128x191 · Tagline ≤120 chars · About ≤2000 chars',
+    displayName: 'monomind',
+    bio: 'Persistent, governed multi-agent orgs for Claude Code — open source, local-first.',
+    about: "monomind is an open-source orchestration layer on top of Claude Code. Instead of spinning up agents for one task and discarding everything they learned when the run ends, monomind treats a set of agents as a persistent \"org\": defined roles and reporting lines, local-first memory (SQLite + local embeddings, no cloud vector DB), per-agent budgets with burn-rate tracking, and human-approval gates before anything destructive ships. Plus a real code knowledge graph (tree-sitter + SQLite) for blast-radius analysis and dead-code detection.\n\nClaude Code gives you an agent. monomind gives you a company.",
+  },
+  {
+    name: 'Reddit', banner: 'banner-reddit.png',
+    specs: 'Avatar 256x256 · Profile banner 1920x384 · About ≤200 chars',
+    displayName: 'monomind', handle: 'u/monomind-dev (suggested, verify availability)',
+    bio: "Open-source orchestration layer on top of Claude Code — persistent agent orgs with real hierarchy, local-first memory, and human-approval gates. Not a one-shot script.",
+  },
+  {
+    name: 'Discord (Server)', banner: 'banner-discord.png',
+    specs: 'Server icon 512x512 · Server banner/splash 1920x1080 (Boost Level 2+) · Discovery description ≤120 chars',
+    displayName: 'monomind',
+    bio: "Open-source persistent multi-agent orgs for Claude Code. Local-first memory, real hierarchy, human-in-the-loop.",
+  },
+  {
+    name: 'Bluesky', banner: 'banner-bluesky.png',
+    specs: 'Avatar 1000x1000 recommended · Banner 3000x1000 · Bio ≤256 chars',
+    displayName: 'monomind', handle: '@monomind.bsky.social (suggested)',
+    bio: "Claude Code gives you an agent. monomind gives you a company. Open-source, local-first, persistent multi-agent orgs — real hierarchy, budgets, human-approval gates. No cloud vector DB, nothing leaves your machine.",
+  },
+  {
+    name: 'Mastodon', banner: 'banner-mastodon.png',
+    specs: 'Avatar 400x400 · Header 1500x500 · Bio ≤500 chars',
+    displayName: 'monomind', handle: '@monomind@fosstodon.org (suggested)',
+    bio: "Open-source orchestration layer on top of Claude Code. Persistent multi-agent orgs — defined roles, hierarchy, and reporting lines that survive across sessions. Local-first memory (SQLite + local embeddings, no cloud vector DB), per-agent budgets with burn-rate tracking, human-approval gates before anything destructive. A real code knowledge graph (tree-sitter + SQLite) for blast-radius analysis. Claude Code gives you an agent. monomind gives you a company.",
+  },
+  {
+    name: 'YouTube', banner: 'banner-youtube.png',
+    specs: 'Icon 800x800 · Banner 2560x1440 (safe area 1546x423) · Description no hard cap, ~1000 chars shown by default',
+    displayName: 'monomind',
+    bio: "monomind is an open-source orchestration layer on top of Claude Code that turns a set of coding agents into a persistent \"org\" instead of a one-shot script — defined roles and hierarchy, local-first memory, per-agent budgets, and human-approval gates before anything destructive ships. This channel covers demos, architecture walkthroughs, and monthly recaps of what shipped.\n\nClaude Code gives you an agent. monomind gives you a company.",
+  },
+  {
+    name: 'TikTok', banner: null,
+    specs: 'Profile photo min 200x200 (no banner) · Bio ≤80 chars',
+    displayName: 'monomind', handle: '@monomind_ai (suggested)',
+    bio: "I gave Claude Code a whole company 🤖 open-source, local-first agent orgs",
+  },
+  {
+    name: 'GitHub (Org)', banner: null,
+    specs: 'Org avatar 460x460+ · Bio/description ≤160 chars (social preview card 1280x640 reuses existing github-social-preview.svg)',
+    displayName: 'monomind', handle: 'github.com/monoes (existing)',
+    bio: "Open-source orchestration layer on top of Claude Code — persistent multi-agent orgs, local-first memory, real knowledge graph for code.",
+  },
+  {
+    name: 'Dev.to', banner: 'banner-devto.png',
+    specs: 'Profile pic square · Optional cover image 1000x420 · Bio ≤200 chars',
+    displayName: 'monomind',
+    bio: "Building monomind — an open-source orchestration layer on top of Claude Code. Persistent agent orgs, local-first memory, real code knowledge graph. Posting deep-dives and comparisons.",
+  },
+  {
+    name: 'Newsletter', banner: 'banner-newsletter.png',
+    specs: 'Masthead logo square · Header/cover ~1200x600 · Short tagline for signup page',
+    displayName: 'monomind',
+    bio: "An open-source AI company, not just an AI agent. Updates on org runtime, local-first memory, and the knowledge graph — from the people building it.",
+  },
+];
+
+function escapeHtml(s) {
+  return String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+}
+
+function render() {
+  const avatarExists = fs.existsSync(path.join(OUT_DIR, AVATAR));
+
+  function channelCard(c) {
+    const bannerExists = c.banner && fs.existsSync(path.join(OUT_DIR, c.banner));
+    return `<div class="channel">
+      <h3 class="channel-name">${escapeHtml(c.name)}</h3>
+      <div class="assets-row">
+        ${avatarExists ? `<div class="asset-col"><div class="asset-label">Profile picture</div><img class="avatar" src="./${AVATAR}" alt="${escapeHtml(c.name)} avatar"></div>` : '<div class="asset-col missing">avatar missing</div>'}
+        ${c.banner ? (bannerExists ? `<div class="asset-col wide"><div class="asset-label">Banner / header</div><img class="banner" src="./${escapeHtml(c.banner)}" alt="${escapeHtml(c.name)} banner"></div>` : '<div class="asset-col missing">banner missing</div>') : ''}
+      </div>
+      <div class="specs">${escapeHtml(c.specs)}</div>
+      <div class="field"><span class="field-label">Display name</span>${escapeHtml(c.displayName)}</div>
+      ${c.handle ? `<div class="field"><span class="field-label">Handle / URL</span>${escapeHtml(c.handle)}</div>` : ''}
+      <div class="field"><span class="field-label">Bio (${c.bio.length} chars)</span><div class="bio-text">${escapeHtml(c.bio)}</div></div>
+      ${c.about ? `<div class="field"><span class="field-label">About (long-form)</span><div class="bio-text">${escapeHtml(c.about).replace(/\n/g, '<br>')}</div></div>` : ''}
+    </div>`;
+  }
+
+  const html = `<!doctype html>
+<html><head><meta charset="utf-8"><title>monomind — Channel Profile Kit</title>
+<style>
+:root {
+  --ivory:#FAF7F0; --ivory-warm:#F5F0E6; --ivory-deep:#EDE8DC;
+  --espresso:#2A2318; --espresso-deep:#1a1208; --espresso-mid:#3D3228; --espresso-light:#5C4F3D;
+  --gold:#C8A97E; --gold-warm:#D4A84A;
+  color-scheme: light dark;
+  --bg: var(--espresso-deep); --surface: var(--espresso); --card: var(--espresso-mid);
+  --border: var(--espresso-light); --text: var(--ivory); --muted: rgba(250,247,240,0.55); --accent: var(--gold);
+}
+@media (prefers-color-scheme: light) {
+  :root { --bg: var(--ivory); --surface: var(--ivory-warm); --card: #ffffff; --border: var(--ivory-deep); --text: var(--espresso); --muted: #6b5f4d; --accent: #8B6914; }
+}
+* { box-sizing: border-box; }
+body { margin:0; background:var(--bg); color:var(--text); font:15px/1.6 -apple-system,BlinkMacSystemFont,Segoe UI,sans-serif; }
+header { padding:2.5rem 1.5rem 1rem; max-width:900px; margin:0 auto; }
+h1 { margin:0 0 .3rem; font-size:1.7rem; font-weight:300; }
+.sub { color:var(--muted); font-size:.85rem; }
+main { max-width:900px; margin:0 auto; padding:0 1.5rem 4rem; display:grid; gap:1.4rem; }
+.channel { background:var(--surface); border:1px solid var(--border); border-radius:14px; padding:1.4rem 1.6rem; }
+.channel-name { margin:0 0 .8rem; font-size:1.15rem; font-weight:600; color:var(--accent); }
+.assets-row { display:flex; gap:1rem; align-items:flex-start; margin-bottom:.8rem; flex-wrap:wrap; }
+.asset-col { flex:0 0 auto; }
+.asset-col.wide { flex:1 1 300px; min-width:220px; }
+.asset-label { font-size:.68rem; text-transform:uppercase; letter-spacing:.05em; color:var(--muted); margin-bottom:.3rem; }
+.avatar { width:96px; height:96px; border-radius:50%; object-fit:cover; border:1px solid var(--border); }
+.banner { width:100%; max-height:150px; object-fit:cover; border-radius:8px; border:1px solid var(--border); }
+.missing { color:var(--muted); font-size:.8rem; font-style:italic; padding:1rem; }
+.specs { font-size:.72rem; color:var(--muted); margin-bottom:.9rem; font-family:ui-monospace,monospace; }
+.field { margin-bottom:.6rem; font-size:.88rem; }
+.field-label { display:block; font-size:.68rem; text-transform:uppercase; letter-spacing:.05em; color:var(--accent); margin-bottom:.15rem; }
+.bio-text { white-space:pre-wrap; }
+</style></head>
+<body>
+<header>
+  <h1>monomind — Channel Profile Kit</h1>
+  <div class="sub">Profile picture (shared "monoes" monkey mascot, consistent everywhere), a channel-appropriate banner, and ready-to-paste bio copy sized to each platform's actual limits. Handles marked "suggested" haven't been checked for availability.</div>
+</header>
+<main>
+${CHANNELS.map(channelCard).join('\n')}
+</main>
+</body></html>`;
+  fs.mkdirSync(OUT_DIR, { recursive: true });
+  fs.writeFileSync(path.join(OUT_DIR, 'channel-profiles.html'), html);
+  console.log(`Wrote channel-profiles.html for ${CHANNELS.length} channels (avatar ${avatarExists ? 'found' : 'MISSING'}) -> ${path.relative(ROOT, OUT_DIR)}`);
+}
+
+render();