monomind 2.5.8 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.5.8",
+  "version": "2.6.0",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/commands/cleanup.js

@@ -425,6 +425,35 @@ export const cleanupCommand = {
                 }
                 catch { /* already gone */ }
             }
+            // Kill stale MCP server processes
+            const mcpPidPaths = [
+                join(require('os').homedir(), '.monomind', 'mcp.pid'),
+                join(cwd, '.monomind', 'mcp-server.pid'),
+            ];
+            for (const pp of mcpPidPaths) {
+                try {
+                    if (!existsSync(pp) || statSync(pp).size > 32)
+                        continue;
+                    const pid = parseInt(readFileSync(pp, 'utf-8').trim(), 10);
+                    if (Number.isInteger(pid) && pid > 0 && looksLikeOurProcess(pid)) {
+                        process.kill(pid, 'SIGTERM');
+                        output.writeln(output.info(`  Stopped MCP server (pid ${pid})`));
+                    }
+                    try {
+                        unlinkSync(pp);
+                    }
+                    catch { }
+                }
+                catch { /* already gone */ }
+            }
+            // Reap orphaned claude-agent-sdk processes from crashed orgs
+            try {
+                const { reapOrphanedSdkProcesses } = await import('../utils/resource-governor.js');
+                const reaped = reapOrphanedSdkProcesses(new Set());
+                if (reaped > 0)
+                    output.writeln(output.info(`  Reaped ${reaped} orphaned SDK agent process(es)`));
+            }
+            catch { /* resource-governor not available */ }
         }
         output.writeln();
         output.writeln(output.bold(dryRun

package/packages/@monomind/cli/dist/src/commands/status.js

@@ -149,7 +149,7 @@ async function getSystemStatus() {
     }
 }
 // Display status in text format
-function displayStatus(status) {
+async function displayStatus(status) {
     output.writeln();
     // Header with overall status
     const statusIcon = status.running
@@ -246,6 +246,27 @@ function displayStatus(status) {
             `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`
         ]);
     }
+    // System resources section
+    output.writeln(output.bold('System Resources'));
+    try {
+        const { checkResources } = await import('../utils/resource-governor.js');
+        const res = checkResources();
+        const memColor = res.freeMemPct < 15 ? output.error : res.freeMemPct < 30 ? output.warning : output.success;
+        output.printTable({
+            columns: [
+                { key: 'property', header: 'Property', width: 18 },
+                { key: 'value', header: 'Value', width: 25, align: 'right' }
+            ],
+            data: [
+                { property: 'Available RAM', value: memColor(`${res.freeMemMB}MB (${res.freeMemPct}%)`) },
+                { property: 'SDK Processes', value: `${res.sdkProcesses} / ${res.maxSdkProcesses} max` },
+                { property: 'Status', value: res.ok ? output.success('OK') : output.warning(res.reason ?? 'pressure') },
+            ]
+        });
+    }
+    catch {
+        output.printInfo('  Resource governor not available');
+    }
 }
 // Format health status with color
 function formatHealth(health) {
@@ -290,7 +311,7 @@ const statusAction = async (ctx) => {
         return watchStatus(interval);
     }
     // Single status display
-    displayStatus(status);
+    await displayStatus(status);
     return { success: true, data: status };
 };
 // Perform health checks
@@ -379,7 +400,7 @@ async function watchStatus(intervalSeconds) {
         output.writeln(output.dim(`Last updated: ${new Date().toLocaleTimeString()}`));
         output.writeln();
         const status = await getSystemStatus();
-        displayStatus(status);
+        await displayStatus(status);
     };
     // Initial display
     await refresh();

package/packages/@monomind/cli/dist/src/orgrt/daemon.d.ts

@@ -54,6 +54,13 @@ export declare class OrgDaemon {
     listOrgs(): RunningOrg[];
     getOrg(name: string): RunningOrg | undefined;
     startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
+    /** A role that failed its resource gate at boot isn't abandoned — keep polling
+     *  for capacity in the background (bounded) and spawn it the moment resources
+     *  free up, instead of silently running the org shorthanded for its whole life.
+     *  Bails quietly if the org is stopped (or restarted under the same name)
+     *  before capacity returns; `running` is compared by identity, not `name`,
+     *  so a stale retry can never spawn into a different run. */
+    private scheduleDeferredSpawn;
     /**
      * Resolves an org_send `to` address ("role" for same-org, "org:role" for
      * cross-org) into its parts. Centralizes the one addressing rule that

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

@@ -11,6 +11,7 @@ import { BrokerLease, lookupOrg } from './broker.js';
 import { queueMessage, drainInbox } from './inbox.js';
 import { OrgDefSchema, ORG_DIR } from './types.js';
 import { summarizeRun, readRunEvents, readHistory, historyFile } from './reporting.js';
+import { checkResources, waitForCapacity, getResourceLimits } from '../utils/resource-governor.js';
 export class OrgDaemon {
     root;
     opts;
@@ -102,7 +103,16 @@ export class OrgDaemon {
                 return [];
             }
         })();
-        for (const role of def.roles) {
+        // Resource-gated staggered spawn: check memory/process limits before each
+        // NON-BOSS agent, wait if under pressure. The boss always spawns immediately
+        // and ungated — the org has no coordinator at all without it, so gating it
+        // behind host memory pressure would make the whole org fail to start over a
+        // condition workers are specifically designed to ride out.
+        const limits = getResourceLimits();
+        // Extracted so a role that fails its gate check can be spawned later by
+        // scheduleDeferredSpawn() once resources free up, without re-running the
+        // gate logic or duplicating the session-wiring below.
+        const spawnRole = (role) => {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
             const runtime = { mailbox, policy, status: 'running', done: Promise.resolve() };
@@ -194,7 +204,44 @@ export class OrgDaemon {
                 }
             })();
             running.agents.set(role.id, runtime);
+        };
+        spawnRole(bossRole); // always, ungated — see comment above
+        for (const role of def.roles) {
+            if (role.id === bossRole.id)
+                continue;
+            // Gate non-boss agents: stagger when under 50% free mem, resource check.
+            const check = checkResources();
+            // Stagger only when memory pressure exists (< 50% free)
+            if (check.freeMemPct < 50) {
+                await new Promise(r => { const t = setTimeout(r, limits.spawnStaggerMs); t.unref?.(); });
+            }
+            if (!check.ok) {
+                bus.emit({ type: 'audit', from: role.id, reason: 'resource-pressure',
+                    msg: `pausing spawn of "${role.id}": ${check.reason} — waiting` });
+                const waited = await waitForCapacity(60_000);
+                if (!waited.ok) {
+                    // Deferred, not dropped: a role missing for the org's whole life is
+                    // worse than a slow retry loop. Retries in the background and
+                    // spawns the moment capacity returns (see scheduleDeferredSpawn).
+                    bus.emit({ type: 'audit', from: role.id, reason: 'resource-skip',
+                        msg: `deferring "${role.id}" — will keep retrying in the background: ${waited.reason}` });
+                    this.scheduleDeferredSpawn(name, running, role, spawnRole);
+                    continue;
+                }
+            }
+            spawnRole(role);
         }
+        // Crash cleanup: reap SDK children if this process exits abnormally.
+        // 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);
+            }
+            catch { /* best-effort */ }
+        };
+        process.on('exit', crashCleanup);
+        running._crashCleanup = crashCleanup;
         const boss = bossRole;
         // Cross-run memory: brief the coordinator on the previous run so scheduled
         // orgs accumulate instead of starting cold every interval.
@@ -272,6 +319,32 @@ export class OrgDaemon {
             bus.emit({ type: 'status', msg: `drained ${queued.length} queued message(s) from inbox` });
         return running;
     }
+    /** A role that failed its resource gate at boot isn't abandoned — keep polling
+     *  for capacity in the background (bounded) and spawn it the moment resources
+     *  free up, instead of silently running the org shorthanded for its whole life.
+     *  Bails quietly if the org is stopped (or restarted under the same name)
+     *  before capacity returns; `running` is compared by identity, not `name`,
+     *  so a stale retry can never spawn into a different run. */
+    scheduleDeferredSpawn(name, running, role, spawnRole) {
+        const MAX_ATTEMPTS = 6; // ~30 min of retrying before giving up loudly
+        (async () => {
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                const waited = await waitForCapacity(5 * 60_000);
+                if (this.orgs.get(name) !== running)
+                    return; // org stopped/restarted — abandon quietly
+                if (waited.ok) {
+                    running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-recovered',
+                        msg: `resources recovered after ${attempt} retr${attempt === 1 ? 'y' : 'ies'} — spawning deferred role "${role.id}"` });
+                    spawnRole(role);
+                    return;
+                }
+                running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-pressure',
+                    msg: `still under pressure (attempt ${attempt}/${MAX_ATTEMPTS}) — retrying "${role.id}" spawn: ${waited.reason}` });
+            }
+            running.bus.emit({ type: 'audit', from: role.id, reason: 'resource-abandoned',
+                msg: `giving up spawning "${role.id}" after ${MAX_ATTEMPTS} retries — org will run without this role until manually restarted` });
+        })().catch(err => console.error(`org ${name}: deferred spawn of "${role.id}" failed:`, err instanceof Error ? err.message : err));
+    }
     /**
      * Resolves an org_send `to` address ("role" for same-org, "org:role" for
      * cross-org) into its parts. Centralizes the one addressing rule that
@@ -505,6 +578,10 @@ export class OrgDaemon {
         // register a NEW forwarder under the same name — settling/unsubscribing
         // that one would sever the new run's dashboard stream.
         const forwarder = this.forwarders.get(name);
+        // Remove crash-cleanup handler — normal stop handles reaping itself
+        const cleanup = org._crashCleanup;
+        if (cleanup)
+            process.removeListener('exit', cleanup);
         const wd = this.watchdogs.get(name);
         if (wd) {
             clearInterval(wd);
@@ -526,6 +603,15 @@ export class OrgDaemon {
                 type: 'audit', msg: `org stop timed out after ${stopWaitMs}ms waiting for agent sessions to finish — proceeding anyway`,
                 reason: 'stop-timeout',
             });
+            // Reap only SDK processes spawned by THIS node process — ownerPid filter
+            // ensures other `monomind org run` daemons' agents are untouched.
+            try {
+                const { reapOrphanedSdkProcesses } = await import('../utils/resource-governor.js');
+                const reaped = reapOrphanedSdkProcesses(new Set(), process.pid);
+                if (reaped > 0)
+                    org.bus.emit({ type: 'audit', reason: 'orphan-reap', msg: `reaped ${reaped} orphaned SDK process(es) after stop timeout` });
+            }
+            catch { /* best-effort */ }
         }
         org.bus.emit({ type: 'status', msg: 'org stopped' });
         await org.bus.flush();

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

@@ -37,12 +37,16 @@ export function buildRolePrompt(role, def, roster, glossary) {
  */
 export async function runAgentSession(opts) {
     const { mailbox } = opts;
+    // Carries the SDK's own session_id across a maxTurns restart so the next
+    // query() call resumes the prior conversation instead of starting cold —
+    // without this, a restart silently discarded all in-progress reasoning.
+    let resumeSessionId;
     // Always run at least once: a mailbox can be closed with queued items still
     // pending (stream() drains the queue before honoring `closed`), which is a
     // normal, valid starting state — checking isClosed before the first run
     // would skip that drain entirely.
     while (true) {
-        await runOneSession(opts);
+        resumeSessionId = await runOneSession(opts, resumeSessionId);
         // The dead session's generator may still hold the waker — drop it so a
         // push() before the next stream() starts only queues instead of being
         // consumed by the abandoned generator (silent message loss).
@@ -52,8 +56,8 @@ export async function runAgentSession(opts) {
         opts.bus.emit({ type: 'status', from: opts.role.id, msg: 'session restarting (turn limit reached, mailbox still open)' });
     }
 }
-/** One bounded SDK session for a role; resolves when the SDK stream ends (mailbox closed or maxTurns reached). */
-async function runOneSession(opts) {
+/** One bounded SDK session for a role; resolves with the SDK's session_id (for resuming on restart) when the stream ends (mailbox closed or maxTurns reached). */
+async function runOneSession(opts, resume) {
     const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
     const queryFn = opts.queryFn ?? query;
     const orgServer = createSdkMcpServer({
@@ -101,6 +105,7 @@ async function runOneSession(opts) {
         ],
     });
     bus.emit({ type: 'status', from: role.id, msg: 'session starting' });
+    let sessionId = resume;
     try {
         const stream = queryFn({
             prompt: mailbox.stream(),
@@ -112,6 +117,7 @@ async function runOneSession(opts) {
                 mcpServers: { org: orgServer },
                 maxTurns: opts.maxTurns ?? 30,
                 permissionMode: 'default',
+                resume,
                 canUseTool: async (toolName, input) => policy.decide(toolName, input),
                 // test seam: lets the scripted fake SDK (test-loop.ts) drive org_send and
                 // tool calls through the real deliver/policy paths; the real SDK ignores it
@@ -122,6 +128,8 @@ async function runOneSession(opts) {
             },
         });
         for await (const m of stream) {
+            if (m.session_id)
+                sessionId = m.session_id;
             if (m.type === 'assistant') {
                 const text = (m.message?.content ?? [])
                     .filter((b) => b.type === 'text').map((b) => b.text).join('\n');
@@ -139,6 +147,7 @@ async function runOneSession(opts) {
             }
         }
         bus.emit({ type: 'status', from: role.id, msg: 'session ended' });
+        return sessionId;
     }
     catch (err) {
         bus.emit({ type: 'status', from: role.id, msg: `session error: ${err.message}` });

package/packages/@monomind/cli/dist/src/utils/resource-governor.d.ts

@@ -0,0 +1,32 @@
+export interface ResourceLimits {
+    /** Minimum free memory (bytes) required before spawning. Default: 15% of total. */
+    minFreeMemBytes: number;
+    /** Maximum concurrent claude-agent-sdk processes across all orgs. Default: cpus - 2, min 2. */
+    maxSdkProcesses: number;
+    /** Delay between sequential agent spawns (ms). Default: 2000. */
+    spawnStaggerMs: number;
+}
+export declare function configureResourceLimits(o: Partial<ResourceLimits>): void;
+export declare function getResourceLimits(): ResourceLimits;
+/** Available memory in bytes — free + reclaimable (inactive/speculative/purgeable on macOS).
+ *  os.freemem() on macOS returns only wired-free pages, which is near-zero on
+ *  a warm system even though GB of file-cache are instantly reclaimable. */
+export declare function getAvailableMemBytes(): number;
+export declare function countSdkProcesses(): number;
+export interface ResourceCheck {
+    ok: boolean;
+    freeMemMB: number;
+    freeMemPct: number;
+    sdkProcesses: number;
+    maxSdkProcesses: number;
+    reason?: string;
+}
+export declare function checkResources(): ResourceCheck;
+/** Wait until resources are available, with a timeout. Returns false if timed out. */
+export declare function waitForCapacity(timeoutMs?: number): Promise<ResourceCheck>;
+/** Kill orphaned claude-agent-sdk processes.
+ *  @param protectedPids PIDs to never kill (e.g. sibling org agents).
+ *  @param ownerPid Only kill SDK processes whose parent is this PID.
+ *    Prevents killing agents from OTHER monomind org processes. */
+export declare function reapOrphanedSdkProcesses(protectedPids: Set<number>, ownerPid?: number): number;
+//# sourceMappingURL=resource-governor.d.ts.map

package/packages/@monomind/cli/dist/src/utils/resource-governor.js

@@ -0,0 +1,115 @@
+// packages/@monomind/cli/src/utils/resource-governor.ts
+// monolean: single-module resource gate — upgrade path = cgroup integration
+import { freemem, totalmem, cpus, platform } from 'node:os';
+import { execSync } from 'node:child_process';
+const defaults = () => ({
+    minFreeMemBytes: parseInt(process.env.MONOMIND_MIN_FREE_MEM_MB || '0', 10) * 1024 * 1024
+        || Math.floor(totalmem() * 0.15),
+    maxSdkProcesses: parseInt(process.env.MONOMIND_MAX_SDK_PROCS || '0', 10)
+        || Math.max(2, cpus().length - 2),
+    spawnStaggerMs: parseInt(process.env.MONOMIND_SPAWN_STAGGER_MS || '0', 10) || 2000,
+});
+let overrides = {};
+export function configureResourceLimits(o) {
+    overrides = { ...overrides, ...o };
+}
+export function getResourceLimits() {
+    return { ...defaults(), ...overrides };
+}
+/** Available memory in bytes — free + reclaimable (inactive/speculative/purgeable on macOS).
+ *  os.freemem() on macOS returns only wired-free pages, which is near-zero on
+ *  a warm system even though GB of file-cache are instantly reclaimable. */
+export function getAvailableMemBytes() {
+    if (platform() === 'darwin') {
+        try {
+            const out = execSync('vm_stat', { encoding: 'utf8', timeout: 3000 });
+            const page = (out.match(/page size of (\d+)/) ?? [])[1];
+            const free = (out.match(/Pages free:\s+(\d+)/) ?? [])[1];
+            const inactive = (out.match(/Pages inactive:\s+(\d+)/) ?? [])[1];
+            const speculative = (out.match(/Pages speculative:\s+(\d+)/) ?? [])[1];
+            const purgeable = (out.match(/Pages purgeable:\s+(\d+)/) ?? [])[1];
+            if (page && free) {
+                const ps = parseInt(page, 10);
+                return ps * (parseInt(free, 10) + parseInt(inactive || '0', 10) + parseInt(speculative || '0', 10) + parseInt(purgeable || '0', 10));
+            }
+        }
+        catch { /* fall through */ }
+    }
+    return freemem();
+}
+export function countSdkProcesses() {
+    try {
+        // Match only actual SDK agent binaries (have --output-format in argv),
+        // not processes that merely reference the SDK package path.
+        const out = execSync('pgrep -f "claude-agent-sdk.*--output-format"', { encoding: 'utf8', timeout: 5000 });
+        return out.trim().split('\n').filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    } // pgrep exits 1 when no matches
+}
+export function checkResources() {
+    const limits = getResourceLimits();
+    const free = getAvailableMemBytes();
+    const total = totalmem();
+    const freeMemMB = Math.round(free / 1024 / 1024);
+    const freeMemPct = Math.round((free / total) * 100);
+    const sdkProcesses = countSdkProcesses();
+    if (free < limits.minFreeMemBytes) {
+        return {
+            ok: false, freeMemMB, freeMemPct, sdkProcesses,
+            maxSdkProcesses: limits.maxSdkProcesses,
+            reason: `low memory: ${freeMemMB}MB free (${freeMemPct}%), need ${Math.round(limits.minFreeMemBytes / 1024 / 1024)}MB`,
+        };
+    }
+    if (sdkProcesses >= limits.maxSdkProcesses) {
+        return {
+            ok: false, freeMemMB, freeMemPct, sdkProcesses,
+            maxSdkProcesses: limits.maxSdkProcesses,
+            reason: `too many SDK processes: ${sdkProcesses}/${limits.maxSdkProcesses}`,
+        };
+    }
+    return { ok: true, freeMemMB, freeMemPct, sdkProcesses, maxSdkProcesses: limits.maxSdkProcesses };
+}
+/** Wait until resources are available, with a timeout. Returns false if timed out. */
+export async function waitForCapacity(timeoutMs = 60_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const check = checkResources();
+        if (check.ok)
+            return check;
+        await new Promise(r => { const t = setTimeout(r, 3000); t.unref?.(); });
+    }
+    return checkResources();
+}
+/** Kill orphaned claude-agent-sdk processes.
+ *  @param protectedPids PIDs to never kill (e.g. sibling org agents).
+ *  @param ownerPid Only kill SDK processes whose parent is this PID.
+ *    Prevents killing agents from OTHER monomind org processes. */
+export function reapOrphanedSdkProcesses(protectedPids, ownerPid) {
+    try {
+        const out = execSync('ps -eo pid,ppid,command', { encoding: 'utf8', timeout: 5000 });
+        let reaped = 0;
+        for (const line of out.split('\n')) {
+            if (!line.includes('claude-agent-sdk') || !line.includes('--output-format'))
+                continue;
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[0], 10);
+            const ppid = parseInt(parts[1], 10);
+            if (isNaN(pid) || protectedPids.has(pid))
+                continue;
+            if (ownerPid != null && ppid !== ownerPid)
+                continue;
+            try {
+                process.kill(pid, 'SIGTERM');
+                reaped++;
+            }
+            catch { /* already dead */ }
+        }
+        return reaped;
+    }
+    catch {
+        return 0;
+    }
+}
+//# sourceMappingURL=resource-governor.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.5.8",
+  "version": "2.6.0",
   "type": "module",
   "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",

package/scripts/growth-content-calendar.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-// Renders the public content calendar (HTML + MD) from each growth org's
-// workspace/posts.md — the single canonical, ready-to-publish post ledger.
-// Regenerate after any growth org run:
+// Renders the public content calendar (HTML + MD) from monomind-growth's
+// workspace/articles.md (6 pillar articles) + workspace/posts.md (channel
+// posts derived from those articles, reusing their images). Regenerate
+// after any growth org run:
 //   node scripts/growth-content-calendar.mjs
 import fs from 'node:fs';
 import path from 'node:path';
@@ -13,30 +14,64 @@ const ORGS = [
 ];
 const OUT_DIR = path.join(ROOT, '.monomind/orgs/monomind-growth/workspace/reports/content-calendar');
 
+// Record format in articles.md (one per pillar article):
+//
+// ### <slug> — <Title>
+// HeroImage: <filename>
+// SupportingImages: <filename>, <filename>
+// <full article body>
+function parseArticles(text, org) {
+  const articles = [];
+  const blocks = text.split(/^### /m).slice(1);
+  for (const block of blocks) {
+    const lines = block.split('\n');
+    const m = lines[0].match(/^(.+?)\s*—\s*(.+?)\s*$/);
+    if (!m) continue;
+    const [, slug, title] = m;
+    let heroImage = null;
+    let supportingImages = [];
+    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);
+      if (heroMatch) { heroImage = heroMatch[1]; continue; }
+      if (suppMatch) { supportingImages = suppMatch[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 });
+  }
+  return articles;
+}
+
 // Record format in posts.md (one per finalized, ready-to-publish post):
 //
 // ### <Channel> — <YYYY-MM-DD>
-// Image: <filename in ../assets/>
-// <final publish-ready text, one or more lines, until the next "### " or EOF>
-function parsePosts(text, org, sourceFile) {
+// Article: <slug>
+// Image: <filename>
+// <final publish-ready text, until the next "### " or EOF>
+function parsePosts(text, org) {
   const posts = [];
   const blocks = text.split(/^### /m).slice(1);
   for (const block of blocks) {
     const lines = block.split('\n');
-    const headerLine = lines[0];
-    const m = headerLine.match(/^(.+?)\s*—\s*(\d{4}-\d{2}-\d{2})\s*$/);
+    const m = lines[0].match(/^(.+?)\s*—\s*(\d{4}-\d{2}-\d{2})\s*$/);
     if (!m) continue;
     const [, channel, date] = m;
     let image = null;
+    let article = null;
     const bodyLines = [];
     for (const line of lines.slice(1)) {
       const imgMatch = line.match(/^Image:\s*(.+?)\s*$/i);
+      const articleMatch = line.match(/^Article:\s*(.+?)\s*$/i);
       if (imgMatch) { image = imgMatch[1]; continue; }
+      if (articleMatch) { article = articleMatch[1]; continue; }
       bodyLines.push(line);
     }
     const text = bodyLines.join('\n').trim();
     if (!text) continue;
-    posts.push({ org, sourceFile, channel: channel.trim(), date, text, image });
+    posts.push({ org, channel: channel.trim(), date, article, text, image });
   }
   return posts;
 }
@@ -45,17 +80,32 @@ 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)
+    .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>');
+}
+
 function render() {
   fs.mkdirSync(OUT_DIR, { recursive: true });
 
+  let articles = [];
   let posts = [];
   for (const org of ORGS) {
+    const articlesFile = path.join(org.dir, 'articles.md');
+    if (fs.existsSync(articlesFile)) articles.push(...parseArticles(fs.readFileSync(articlesFile, 'utf8'), org.name));
     const postsFile = path.join(org.dir, 'posts.md');
-    if (!fs.existsSync(postsFile)) continue;
-    const text = fs.readFileSync(postsFile, 'utf8');
-    posts.push(...parsePosts(text, org.name, path.relative(ROOT, postsFile)));
+    if (fs.existsSync(postsFile)) posts.push(...parsePosts(fs.readFileSync(postsFile, 'utf8'), org.name));
   }
 
+  // dedupe articles by slug (growth-execution mirrors monomind-growth)
+  { const bySlug = new Map(); for (const a of articles) if (!bySlug.has(a.slug)) bySlug.set(a.slug, a); articles = [...bySlug.values()]; }
+
   // dedupe identical posts mirrored across both orgs
   const merged = new Map();
   for (const p of posts) {
@@ -66,13 +116,18 @@ function render() {
   }
   posts = [...merged.values()].sort((a, b) => b.date.localeCompare(a.date));
 
-  // copy referenced images alongside html/md
+  const articleBySlug = new Map(articles.map((a) => [a.slug, a]));
+
+  // copy every referenced image (article hero/supporting + post images) alongside html/md
   const copied = new Set();
-  for (const p of posts) {
-    if (!p.image) continue;
+  const allImageNames = new Set([
+    ...articles.flatMap((a) => [a.heroImage, ...a.supportingImages].filter(Boolean)),
+    ...posts.map((p) => p.image).filter(Boolean),
+  ]);
+  for (const name of allImageNames) {
     for (const org of ORGS) {
-      const src = path.join(org.dir, 'assets', p.image);
-      if (fs.existsSync(src)) { fs.copyFileSync(src, path.join(OUT_DIR, p.image)); copied.add(p.image); break; }
+      const src = path.join(org.dir, 'assets', name);
+      if (fs.existsSync(src)) { fs.copyFileSync(src, path.join(OUT_DIR, name)); copied.add(name); break; }
     }
   }
 
@@ -80,45 +135,85 @@ function render() {
   const md = [];
   md.push('# Monomind Growth — Content Calendar (auto-generated)');
   md.push('');
-  md.push('Regenerated by `scripts/growth-content-calendar.mjs` from each org\'s `workspace/posts.md`. Newest publish date first.');
+  md.push("Regenerated by `scripts/growth-content-calendar.mjs` from workspace/articles.md (pillar articles) + workspace/posts.md (channel posts derived from them). Newest publish date first.");
   md.push('');
+  md.push(`## Pillar Articles (${articles.length}/6)`);
+  for (const a of articles) {
+    md.push(`\n### ${a.title}  \`${a.slug}\``);
+    if (a.heroImage) md.push(`\n![${a.title}](./${a.heroImage})`);
+    md.push(`\n${a.body}`);
+  }
+  md.push('\n---\n\n## Channel Calendar');
   let lastDate = null;
   for (const p of posts) {
     if (p.date !== lastDate) { md.push(`\n## ${p.date}`); lastDate = p.date; }
-    md.push(`\n### ${p.channel}\n`);
+    const src = articleBySlug.get(p.article);
+    md.push(`\n### ${p.channel}${src ? ` — based on _"${src.title}"_` : ''}\n`);
     md.push(p.text);
     if (p.image) md.push(`\n![${p.channel} image](./${p.image})`);
   }
-  if (!posts.length) md.push('\n_No finalized posts yet — workspace/posts.md is empty for both orgs._');
+  if (!articles.length && !posts.length) md.push('\n_Nothing finalized yet — articles.md and posts.md are empty for both orgs._');
   fs.writeFileSync(path.join(OUT_DIR, 'content-calendar.md'), md.join('\n') + '\n');
 
-  // --- HTML ---
+  // --- HTML (monoes design system: espresso/ivory/gold) ---
   const groups = [];
   { let cur = null; for (const p of posts) { if (p.date !== cur?.date) { cur = { date: p.date, items: [] }; groups.push(cur); } cur.items.push(p); } }
 
-  function card(p) {
+  function postCard(p) {
     const img = p.image && copied.has(p.image) ? `<img class="thumb" src="./${escapeHtml(p.image)}" alt="">` : '';
+    const src = articleBySlug.get(p.article);
     return `<div class="card">
-      <div class="channel">${escapeHtml(p.channel)}</div>
+      <div class="channel">${escapeHtml(p.channel)}${src ? ` <span class="based-on">based on "${escapeHtml(src.title)}"</span>` : ''}</div>
       ${img}
       <div class="text">${escapeHtml(p.text).replace(/\n/g, '<br>')}</div>
     </div>`;
   }
 
+  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('');
+    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>`;
+  }
+
   const html = `<!doctype html>
 <html><head><meta charset="utf-8"><title>Monomind Growth — Content Calendar</title>
 <style>
-:root { color-scheme: light dark; --bg:#0b0d12; --card:#151922; --line:#232837; --text:#e7ebf3; --muted:#8a93a6; --accent:#7cc4ff; }
-@media (prefers-color-scheme: light) { :root { --bg:#f6f7fb; --card:#ffffff; --line:#e4e7ef; --text:#171923; --muted:#5a6270; --accent:#2563eb; } }
+: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.55 -apple-system,BlinkMacSystemFont,Segoe UI,sans-serif; }
-header { padding:2.5rem 1.5rem 1rem; max-width:820px; margin:0 auto; }
-h1 { margin:0 0 .3rem; font-size:1.6rem; }
-.sub { color:var(--muted); font-size:.9rem; }
-main { max-width:820px; margin:0 auto; padding:0 1.5rem 4rem; }
-.date-heading { font-size:1.05rem; font-weight:700; color:var(--accent); border-bottom:1px solid var(--line); padding:1.6rem 0 .5rem; margin-bottom:1rem; }
-.card { background:var(--card); border:1px solid var(--line); border-radius:12px; padding:1.1rem 1.3rem; margin-bottom:1rem; }
+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:860px; margin:0 auto; }
+h1 { margin:0 0 .3rem; font-size:1.7rem; font-weight:300; letter-spacing:.01em; }
+.sub { color:var(--muted); font-size:.85rem; }
+main { max-width:860px; margin:0 auto; padding:0 1.5rem 4rem; }
+.section-heading { font-size:1.1rem; font-weight:700; color:var(--accent); text-transform:uppercase; letter-spacing:.06em; border-bottom:1px solid var(--border); padding:2rem 0 .6rem; margin-bottom:1.2rem; }
+.date-heading { font-size:1.0rem; font-weight:700; color:var(--accent); padding:1.4rem 0 .5rem; }
+.article { background:var(--surface); border:1px solid var(--border); border-radius:14px; padding:1.5rem 1.7rem; margin-bottom:1.5rem; }
+.article-slug { font:11px ui-monospace,monospace; color:var(--accent); text-transform:uppercase; letter-spacing:.08em; margin-bottom:.3rem; }
+.article-title { margin:0 0 1rem; font-size:1.3rem; font-weight:400; }
+.article .hero { width:100%; border-radius:10px; margin-bottom:1rem; display:block; }
+.supporting-row { display:flex; gap:.6rem; margin-bottom:1rem; }
+.supporting-row img { width:100%; border-radius:8px; }
+.article-body { font-size:.92rem; color:var(--text); }
+.article-body p { white-space:pre-wrap; }
+.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; }
 .thumb { max-width:100%; border-radius:8px; margin-bottom:.7rem; display:block; }
 .text { font-size:.92rem; white-space:normal; }
 .empty { color:var(--muted); padding:2rem 0; }
@@ -126,15 +221,17 @@ main { max-width:820px; margin:0 auto; padding:0 1.5rem 4rem; }
 <body>
 <header>
   <h1>Monomind Growth — Content Calendar</h1>
-  <div class="sub">Auto-generated by <code>scripts/growth-content-calendar.mjs</code> from workspace/posts.md. Newest publish date first.</div>
+  <div class="sub">Auto-generated from workspace/articles.md (pillar articles) + workspace/posts.md (channel posts derived from them). Newest publish date first.</div>
 </header>
 <main>
-${groups.length ? groups.map((g) => `<div class="date-heading">${g.date}</div>${g.items.map(card).join('\n')}`).join('\n') : '<div class="empty">No finalized posts yet — workspace/posts.md is empty for both orgs.</div>'}
+${articles.length ? `<div class="section-heading">Pillar Articles (${articles.length}/6)</div>${articles.map(articleCard).join('\n')}` : ''}
+${groups.length ? `<div class="section-heading">Channel Calendar</div>${groups.map((g) => `<div class="date-heading">${g.date}</div>${g.items.map(postCard).join('\n')}`).join('\n')}` : ''}
+${!articles.length && !posts.length ? '<div class="empty">Nothing finalized yet — articles.md and posts.md are empty for both orgs.</div>' : ''}
 </main>
 </body></html>`;
   fs.writeFileSync(path.join(OUT_DIR, 'content-calendar.html'), html);
 
-  console.log(`Wrote ${posts.length} post(s), ${copied.size} image(s) -> ${path.relative(ROOT, OUT_DIR)}`);
+  console.log(`Wrote ${articles.length} article(s), ${posts.length} post(s), ${copied.size} image(s) -> ${path.relative(ROOT, OUT_DIR)}`);
 }
 
 render();