clementine-agent 1.1.22 → 1.1.24

package/dist/agent/assistant.js

@@ -22,6 +22,7 @@ import { AgentManager } from './agent-manager.js';
 import { extractLinks } from './link-extractor.js';
 import { StallGuard } from './stall-guard.js';
 import { collectToolCalls, detectContradiction, buildCorrectionPrompt } from './contradiction-validator.js';
+import { recordToolOutcome as recordMcpToolOutcome } from './mcp-circuit-breaker.js';
 import { assembleContext } from '../memory/context-assembler.js';
 import { PromptCache } from './prompt-cache.js';
 import { searchSkills as searchSkillsSync } from './skill-extractor.js';
@@ -2946,6 +2947,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 if (!contradictionRetried && attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES && responseText.trim()) {
                     try {
                         const toolCallRecords = collectToolCalls(collectedSdkMessages);
+                        // Feed every tool outcome to the MCP circuit breaker so flaky
+                        // connectors get tripped + surfaced via the advisor-events
+                        // path that insight-engine already monitors.
+                        for (const r of toolCallRecords) {
+                            try {
+                                recordMcpToolOutcome(r.name, r.resultClass);
+                            }
+                            catch { /* non-fatal */ }
+                        }
                         // Diagnostic — emits once per turn so we can see what the
                         // validator is working with even when it doesn't fire. Without
                         // this we're blind to the "regex missed the phrasing" case.

package/dist/agent/brain-digest.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Cross-agent brain digest.
+ *
+ * Aggregates raw signals from across the team (memory recurrence, cron
+ * activity, memory growth) and runs a single LLM synthesis pass to
+ * produce a leadable markdown narrative — what the team accomplished,
+ * what they learned in common, where to lead next.
+ *
+ * Intended caller: `clementine brain digest` CLI for v1; cron entry +
+ * heartbeat-side proactive surfacing for v2.
+ */
+import type { AgentManager } from './agent-manager.js';
+import type { MemoryStore } from '../memory/store.js';
+import type { PersonalAssistant } from './assistant.js';
+export interface BrainDigestInputs {
+    windowDays: number;
+    agents: Array<{
+        slug: string;
+        name: string;
+    }>;
+    /** Clusters of similar memory chunks recurring across multiple agents. */
+    crossAgentClusters: Array<{
+        agents: string[];
+        representativeContent: string;
+        representativeSource: string;
+        memberCount: number;
+    }>;
+    /** Per-job summary of runs in the window. */
+    cronRunsByJob: Array<{
+        jobName: string;
+        agentSlug: string | null;
+        runs: number;
+        failures: number;
+    }>;
+    /** Chunk count growth per agent in the window — proxy for "what they worked on". */
+    memoryDeltas: Array<{
+        agentSlug: string;
+        chunksAdded: number;
+    }>;
+}
+/** Aggregate raw signals — pure data, no LLM call. */
+export declare function gatherBrainDigestInputs(opts: {
+    agentManager: AgentManager;
+    memoryStore: MemoryStore;
+    baseDir: string;
+    windowDays: number;
+}): BrainDigestInputs;
+/**
+ * Format the raw inputs as a single text block the LLM can synthesize.
+ * Kept terse — the LLM does the heavy lifting of pattern surfacing.
+ */
+export declare function formatRawMaterial(inputs: BrainDigestInputs): string;
+export declare function runBrainDigest(opts: {
+    assistant: PersonalAssistant;
+    agentManager: AgentManager;
+    memoryStore: MemoryStore;
+    baseDir: string;
+    windowDays?: number;
+    model?: string;
+}): Promise<{
+    markdown: string;
+    inputs: BrainDigestInputs;
+}>;
+//# sourceMappingURL=brain-digest.d.ts.map

package/dist/agent/brain-digest.js

@@ -0,0 +1,196 @@
+/**
+ * Cross-agent brain digest.
+ *
+ * Aggregates raw signals from across the team (memory recurrence, cron
+ * activity, memory growth) and runs a single LLM synthesis pass to
+ * produce a leadable markdown narrative — what the team accomplished,
+ * what they learned in common, where to lead next.
+ *
+ * Intended caller: `clementine brain digest` CLI for v1; cron entry +
+ * heartbeat-side proactive surfacing for v2.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+const logger = pino({ name: 'clementine.brain-digest' });
+/** Aggregate raw signals — pure data, no LLM call. */
+export function gatherBrainDigestInputs(opts) {
+    const sinceMs = Date.now() - opts.windowDays * 86_400_000;
+    const sinceIso = new Date(sinceMs).toISOString();
+    const agents = opts.agentManager.listAll().map(a => ({ slug: a.slug, name: a.name }));
+    // 1. Cross-agent memory recurrence — facts/topics surfaced by 2+ agents.
+    let crossAgentClusters = [];
+    try {
+        const clusters = opts.memoryStore.findCrossAgentRecurrence({
+            threshold: 0.85,
+            minAgents: 2,
+            limit: 20,
+        });
+        crossAgentClusters = clusters.map(c => ({
+            agents: c.agents,
+            representativeContent: c.representative.content.slice(0, 400),
+            representativeSource: `${c.representative.sourceFile}>${c.representative.section}`,
+            memberCount: c.members.length,
+        }));
+    }
+    catch (err) {
+        logger.debug({ err }, 'Cross-agent recurrence scan failed — continuing with empty list');
+    }
+    // 2. Cron run summary — walk cron/runs/*.jsonl, filter to the window.
+    const cronRunsByJob = gatherCronRunsByJob(opts.baseDir, sinceIso);
+    // 3. Memory deltas — chunk growth per agent in the window.
+    const memoryDeltas = gatherMemoryDeltas(opts.memoryStore, sinceIso);
+    return {
+        windowDays: opts.windowDays,
+        agents,
+        crossAgentClusters,
+        cronRunsByJob,
+        memoryDeltas,
+    };
+}
+function gatherCronRunsByJob(baseDir, sinceIso) {
+    const runsDir = path.join(baseDir, 'cron', 'runs');
+    if (!existsSync(runsDir))
+        return [];
+    const sinceMs = Date.parse(sinceIso);
+    const aggregates = new Map();
+    for (const file of readdirSync(runsDir).filter(f => f.endsWith('.jsonl'))) {
+        const jobName = file.replace(/\.jsonl$/, '');
+        const filePath = path.join(runsDir, file);
+        let lines;
+        try {
+            lines = readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+        }
+        catch {
+            continue;
+        }
+        let runs = 0;
+        let failures = 0;
+        let agentSlug = null;
+        // jobNames may be agent-scoped: "<agent-slug>:<job>"
+        const parts = jobName.split(':');
+        if (parts.length > 1) {
+            agentSlug = parts[0];
+        }
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                const ts = entry.startedAt ?? entry.finishedAt;
+                if (!ts)
+                    continue;
+                if (Date.parse(ts) < sinceMs)
+                    continue;
+                runs++;
+                if (entry.status === 'error')
+                    failures++;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (runs > 0) {
+            aggregates.set(jobName, { jobName, agentSlug, runs, failures });
+        }
+    }
+    return Array.from(aggregates.values()).sort((a, b) => b.runs - a.runs);
+}
+function gatherMemoryDeltas(memoryStore, sinceIso) {
+    // Reach into the underlying connection — same pattern memory-tools.ts uses.
+    const conn = memoryStore.conn;
+    try {
+        const rows = conn
+            .prepare(`SELECT COALESCE(agent_slug, 'global') as agentSlug, COUNT(*) as chunksAdded
+         FROM chunks
+         WHERE updated_at >= ?
+         GROUP BY agent_slug
+         ORDER BY chunksAdded DESC`)
+            .all(sinceIso);
+        return rows;
+    }
+    catch (err) {
+        logger.debug({ err }, 'Memory delta query failed — continuing with empty list');
+        return [];
+    }
+}
+/**
+ * Format the raw inputs as a single text block the LLM can synthesize.
+ * Kept terse — the LLM does the heavy lifting of pattern surfacing.
+ */
+export function formatRawMaterial(inputs) {
+    const sections = [];
+    sections.push(`## Window\nLast ${inputs.windowDays} days.`);
+    sections.push(`## Team roster\n${inputs.agents.length === 0 ? '(no specialist agents)' : inputs.agents.map(a => `- ${a.name} (${a.slug})`).join('\n')}`);
+    if (inputs.cronRunsByJob.length === 0) {
+        sections.push(`## Cron activity\n(no autonomous runs in window)`);
+    }
+    else {
+        const lines = inputs.cronRunsByJob.slice(0, 20).map(r => {
+            const tag = r.agentSlug ? ` [${r.agentSlug}]` : '';
+            const failTag = r.failures > 0 ? ` — ${r.failures} failure${r.failures === 1 ? '' : 's'}` : '';
+            return `- ${r.jobName}${tag}: ${r.runs} run${r.runs === 1 ? '' : 's'}${failTag}`;
+        });
+        sections.push(`## Cron activity\n${lines.join('\n')}`);
+    }
+    if (inputs.memoryDeltas.length === 0) {
+        sections.push(`## Memory growth\n(no new chunks in window)`);
+    }
+    else {
+        const lines = inputs.memoryDeltas.map(d => `- ${d.agentSlug}: +${d.chunksAdded} chunks`);
+        sections.push(`## Memory growth\n${lines.join('\n')}`);
+    }
+    if (inputs.crossAgentClusters.length === 0) {
+        sections.push(`## Cross-agent recurrence\n(no facts surfaced from 2+ agents)`);
+    }
+    else {
+        const lines = inputs.crossAgentClusters.slice(0, 12).map((c, i) => {
+            const preview = c.representativeContent.replace(/\n/g, ' ').slice(0, 200);
+            return `${i + 1}. agents: ${c.agents.join(', ')} (${c.memberCount} chunks)\n   "${preview}${preview.length >= 200 ? '…' : ''}"`;
+        });
+        sections.push(`## Cross-agent recurrence\n${lines.join('\n')}`);
+    }
+    return sections.join('\n\n');
+}
+const SYNTHESIS_SYSTEM_PROMPT = `You are Clementine, the master assistant. Your team of specialist agents has been working autonomously, and you need to write a **brain digest** — a leadable summary of what happened over the window, what the team learned in common, and where you should lead them next.
+
+Format the digest as markdown:
+
+# Brain Digest — last {N} days
+
+## What happened
+2-3 sentence overview of activity. Be specific about who did what.
+
+## What we learned together
+The cross-agent recurrence section shows facts/topics that surfaced from MULTIPLE agents — these are the team's emerging shared knowledge. List the 3-5 most meaningful patterns. If empty, say "Nothing recurred across agents this window — the team's still working in parallel silos."
+
+## Where to lead
+2-3 concrete priorities or follow-ups based on what you see. What's the team's biggest opportunity? What's at risk? What's a clear next move?
+
+## Per-agent highlights
+One bullet per active agent — what they worked on, status (healthy / quiet / failing). Skip agents with no activity.
+
+**Style rules:**
+- Lead with what matters. Don't list raw data — synthesize.
+- Be honest about sparse data. If the window is quiet, say so. Don't pad.
+- Under 400 words total. Cut anything that doesn't help you lead the team.
+- No greeting, no sign-off — this is a working document.
+`;
+export async function runBrainDigest(opts) {
+    const windowDays = opts.windowDays ?? 7;
+    const inputs = gatherBrainDigestInputs({
+        agentManager: opts.agentManager,
+        memoryStore: opts.memoryStore,
+        baseDir: opts.baseDir,
+        windowDays,
+    });
+    const rawMaterial = formatRawMaterial(inputs);
+    const prompt = `${SYNTHESIS_SYSTEM_PROMPT.replace('{N}', String(windowDays))}\n\n---\n\n# Raw signals\n\n${rawMaterial}`;
+    logger.info({ windowDays, agents: inputs.agents.length, clusters: inputs.crossAgentClusters.length, jobs: inputs.cronRunsByJob.length }, 'Running brain digest synthesis');
+    const markdown = await opts.assistant.runPlanStep('brain-digest', prompt, {
+        tier: 1,
+        maxTurns: 3,
+        model: opts.model ?? 'sonnet',
+        disableTools: true, // synthesis only — no tool calls
+    });
+    return { markdown: markdown.trim(), inputs };
+}
+//# sourceMappingURL=brain-digest.js.map

package/dist/agent/mcp-circuit-breaker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Per-MCP-server circuit breaker.
+ *
+ * When an MCP server starts returning errors (auth failures, connector
+ * timeouts, "no such tool available") repeatedly, agents keep calling it
+ * — burning tool turns on something that isn't going to work. This module
+ * tracks per-server failure rates with a sliding window and surfaces a
+ * tripped state to the existing insight-engine via advisor-events.jsonl
+ * (same path the cron-side circuit breaker uses).
+ *
+ * Trip rule: K failures of class auth_error/other_error within WINDOW_MS
+ * trips the breaker for COOLDOWN_MS. Argument errors are agent-fault, not
+ * connector-fault, and don't count toward the trip threshold.
+ *
+ * Auto-reset: COOLDOWN_MS after the trip moment, the breaker clears and
+ * the failure window resets. The next failure starts the count fresh.
+ */
+export type ToolResultClass = 'success' | 'arg_error' | 'auth_error' | 'other_error';
+/**
+ * Extract the MCP server name from a fully-qualified tool name. Handles
+ * server names that themselves contain underscores (e.g. `claude_ai_Gmail`)
+ * by treating only the FINAL `__` separator as the server/tool boundary.
+ *
+ *   mcp__clementine-tools__memory_search        → "clementine-tools"
+ *   mcp__claude_ai_Gmail__authenticate          → "claude_ai_Gmail"
+ *   mcp__ElevenLabs__text_to_speech             → "ElevenLabs"
+ *   mcp__plugin_x_y__do_thing                   → "plugin_x_y"
+ *
+ * Returns null for non-MCP tools (Bash, Read, etc.).
+ */
+export declare function extractServerName(toolName: string): string | null;
+/**
+ * Record the outcome of a single tool invocation. Only auth_error /
+ * other_error count toward the failure window — arg_error is the agent's
+ * fault (bad parameters), and success obviously doesn't count.
+ */
+export declare function recordToolOutcome(toolName: string, resultClass: ToolResultClass): void;
+/** True when the named server is currently in the open (failing) state. */
+export declare function isServerTripped(server: string): boolean;
+/** Get all currently-tripped servers — useful for status display + system-prompt injection. */
+export declare function getTrippedServers(): Array<{
+    server: string;
+    trippedAt: string;
+    reason: string;
+    cooldownRemainingMs: number;
+}>;
+/** Manual reset — used by an `mcp circuit reset` admin command (future). */
+export declare function resetServer(server: string): boolean;
+/** Reset every breaker — used by tests. */
+export declare function _resetAll(): void;
+//# sourceMappingURL=mcp-circuit-breaker.d.ts.map

package/dist/agent/mcp-circuit-breaker.js

@@ -0,0 +1,175 @@
+/**
+ * Per-MCP-server circuit breaker.
+ *
+ * When an MCP server starts returning errors (auth failures, connector
+ * timeouts, "no such tool available") repeatedly, agents keep calling it
+ * — burning tool turns on something that isn't going to work. This module
+ * tracks per-server failure rates with a sliding window and surfaces a
+ * tripped state to the existing insight-engine via advisor-events.jsonl
+ * (same path the cron-side circuit breaker uses).
+ *
+ * Trip rule: K failures of class auth_error/other_error within WINDOW_MS
+ * trips the breaker for COOLDOWN_MS. Argument errors are agent-fault, not
+ * connector-fault, and don't count toward the trip threshold.
+ *
+ * Auto-reset: COOLDOWN_MS after the trip moment, the breaker clears and
+ * the failure window resets. The next failure starts the count fresh.
+ */
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { BASE_DIR } from '../config.js';
+const logger = pino({ name: 'clementine.mcp-circuit-breaker' });
+/** Threshold to trip the breaker. */
+const MAX_CONNECTOR_FAILURES = 5;
+/** Sliding window for counting failures. */
+const WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+/** How long the breaker stays open before auto-resetting. */
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const ADVISOR_EVENTS_FILE = path.join(BASE_DIR, 'cron', 'advisor-events.jsonl');
+const state = new Map();
+/**
+ * Extract the MCP server name from a fully-qualified tool name. Handles
+ * server names that themselves contain underscores (e.g. `claude_ai_Gmail`)
+ * by treating only the FINAL `__` separator as the server/tool boundary.
+ *
+ *   mcp__clementine-tools__memory_search        → "clementine-tools"
+ *   mcp__claude_ai_Gmail__authenticate          → "claude_ai_Gmail"
+ *   mcp__ElevenLabs__text_to_speech             → "ElevenLabs"
+ *   mcp__plugin_x_y__do_thing                   → "plugin_x_y"
+ *
+ * Returns null for non-MCP tools (Bash, Read, etc.).
+ */
+export function extractServerName(toolName) {
+    if (!toolName.startsWith('mcp__'))
+        return null;
+    const rest = toolName.slice('mcp__'.length);
+    const lastSep = rest.lastIndexOf('__');
+    if (lastSep <= 0)
+        return null;
+    return rest.slice(0, lastSep);
+}
+function getServerState(server) {
+    let s = state.get(server);
+    if (!s) {
+        s = { failureTimestamps: [] };
+        state.set(server, s);
+    }
+    return s;
+}
+/**
+ * Record the outcome of a single tool invocation. Only auth_error /
+ * other_error count toward the failure window — arg_error is the agent's
+ * fault (bad parameters), and success obviously doesn't count.
+ */
+export function recordToolOutcome(toolName, resultClass) {
+    const server = extractServerName(toolName);
+    if (!server)
+        return; // built-in tool like Bash/Read — not our concern
+    const s = getServerState(server);
+    const now = Date.now();
+    // Auto-reset if the cooldown has expired since the last trip.
+    if (s.trippedAt !== undefined && now - s.trippedAt >= COOLDOWN_MS) {
+        s.trippedAt = undefined;
+        s.trippedReason = undefined;
+        s.failureTimestamps = [];
+        logger.info({ server }, 'MCP circuit breaker auto-reset after cooldown');
+        emitAdvisorEvent({
+            type: 'circuit-breaker',
+            jobName: `mcp:${server}`,
+            detail: 'Connector breaker reset — probing again on next call',
+            reset: true,
+        });
+    }
+    if (resultClass === 'success') {
+        // Successful call inside the window — clear the failure list so a flap
+        // doesn't accumulate forever. Don't auto-reset a tripped breaker on
+        // success though; that needs to wait for the cooldown so we don't
+        // ping-pong on intermittent failures.
+        if (s.trippedAt === undefined) {
+            s.failureTimestamps = [];
+        }
+        return;
+    }
+    if (resultClass === 'arg_error') {
+        // Agent passed bad args — connector itself is fine.
+        return;
+    }
+    // auth_error or other_error — count toward the failure window.
+    s.failureTimestamps.push(now);
+    // Drop old timestamps outside the window.
+    s.failureTimestamps = s.failureTimestamps.filter(t => now - t <= WINDOW_MS);
+    if (s.trippedAt === undefined && s.failureTimestamps.length >= MAX_CONNECTOR_FAILURES) {
+        s.trippedAt = now;
+        s.trippedReason = `${s.failureTimestamps.length} ${resultClass} failure(s) in the last ${Math.round(WINDOW_MS / 60_000)}m`;
+        logger.warn({ server, failures: s.failureTimestamps.length, resultClass }, 'MCP circuit breaker tripped');
+        emitAdvisorEvent({
+            type: 'circuit-breaker',
+            jobName: `mcp:${server}`,
+            detail: `MCP connector "${server}" tripped — ${s.trippedReason}. Prefer alternatives until cooldown expires (~${Math.round(COOLDOWN_MS / 60_000)}m).`,
+        });
+    }
+}
+/** True when the named server is currently in the open (failing) state. */
+export function isServerTripped(server) {
+    const s = state.get(server);
+    if (!s || s.trippedAt === undefined)
+        return false;
+    if (Date.now() - s.trippedAt >= COOLDOWN_MS)
+        return false;
+    return true;
+}
+/** Get all currently-tripped servers — useful for status display + system-prompt injection. */
+export function getTrippedServers() {
+    const now = Date.now();
+    const out = [];
+    for (const [server, s] of state) {
+        if (s.trippedAt === undefined)
+            continue;
+        const remaining = COOLDOWN_MS - (now - s.trippedAt);
+        if (remaining <= 0)
+            continue;
+        out.push({
+            server,
+            trippedAt: new Date(s.trippedAt).toISOString(),
+            reason: s.trippedReason ?? 'unknown',
+            cooldownRemainingMs: remaining,
+        });
+    }
+    return out;
+}
+/** Manual reset — used by an `mcp circuit reset` admin command (future). */
+export function resetServer(server) {
+    const s = state.get(server);
+    if (!s || s.trippedAt === undefined)
+        return false;
+    s.trippedAt = undefined;
+    s.trippedReason = undefined;
+    s.failureTimestamps = [];
+    logger.info({ server }, 'MCP circuit breaker manually reset');
+    emitAdvisorEvent({
+        type: 'circuit-breaker',
+        jobName: `mcp:${server}`,
+        detail: 'Manually reset',
+        reset: true,
+    });
+    return true;
+}
+/** Reset every breaker — used by tests. */
+export function _resetAll() {
+    state.clear();
+}
+function emitAdvisorEvent(evt) {
+    try {
+        mkdirSync(path.dirname(ADVISOR_EVENTS_FILE), { recursive: true });
+        if (!existsSync(path.dirname(ADVISOR_EVENTS_FILE)))
+            return;
+        const line = JSON.stringify({ timestamp: new Date().toISOString(), ...evt }) + '\n';
+        appendFileSync(ADVISOR_EVENTS_FILE, line);
+    }
+    catch (err) {
+        // Non-fatal — observability event, not load-bearing for the breaker logic.
+        logger.debug({ err }, 'Failed to emit advisor event for MCP circuit breaker');
+    }
+}
+//# sourceMappingURL=mcp-circuit-breaker.js.map

package/dist/cli/index.js

@@ -2130,6 +2130,80 @@ configCmd
         console.error(`  Failed to open editor: ${editor}`);
     }
 });
+// ── Brain commands ──────────────────────────────────────────────────
+const brainCmd = program
+    .command('brain')
+    .description('Cross-agent synthesis — leadable summaries of what your team learned');
+brainCmd
+    .command('digest')
+    .description('Run a brain digest — synthesize the past N days of cross-agent activity into a leadable narrative')
+    .option('-d, --days <n>', 'Window in days', '7')
+    .option('-m, --model <model>', 'Model to use for synthesis (sonnet, haiku, opus)', 'sonnet')
+    .option('--save', 'Also save the digest to vault/00-System/brain-digests/<date>.md')
+    .option('--raw', 'Print the raw signals only — skip the LLM synthesis')
+    .action(async (opts) => {
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[0;90m';
+    const GREEN = '\x1b[0;32m';
+    const RED = '\x1b[0;31m';
+    const RESET = '\x1b[0m';
+    const days = Math.max(1, Math.min(60, parseInt(opts.days, 10) || 7));
+    process.env.CLEMENTINE_HOME = BASE_DIR;
+    delete process.env['CLAUDECODE'];
+    try {
+        const { AgentManager } = await import('../agent/agent-manager.js');
+        const { MemoryStore } = await import('../memory/store.js');
+        const { gatherBrainDigestInputs, formatRawMaterial, runBrainDigest } = await import('../agent/brain-digest.js');
+        const VAULT_DIR = path.join(BASE_DIR, 'vault');
+        const DB_PATH = path.join(VAULT_DIR, '.memory.db');
+        const AGENTS_DIR = path.join(BASE_DIR, 'agents');
+        const agentManager = new AgentManager(AGENTS_DIR);
+        const memoryStore = new MemoryStore(DB_PATH, VAULT_DIR);
+        // Raw mode short-circuits the LLM call — useful for inspecting signals.
+        if (opts.raw) {
+            const inputs = gatherBrainDigestInputs({ agentManager, memoryStore, baseDir: BASE_DIR, windowDays: days });
+            console.log();
+            console.log(`  ${BOLD}Brain digest — raw signals (${days} days)${RESET}`);
+            console.log();
+            console.log(formatRawMaterial(inputs));
+            console.log();
+            return;
+        }
+        console.log();
+        console.log(`  ${DIM}Synthesizing brain digest over ${days} days using ${opts.model}…${RESET}`);
+        const { PersonalAssistant } = await import('../agent/assistant.js');
+        const assistant = new PersonalAssistant();
+        // Headless: auto-deny any approval prompts during synthesis.
+        const { setApprovalCallback } = await import('../agent/hooks.js');
+        setApprovalCallback(async () => false);
+        const result = await runBrainDigest({
+            assistant,
+            agentManager,
+            memoryStore,
+            baseDir: BASE_DIR,
+            windowDays: days,
+            model: opts.model,
+        });
+        console.log();
+        console.log(result.markdown);
+        console.log();
+        console.log(`  ${DIM}Sources: ${result.inputs.agents.length} agent(s), ${result.inputs.cronRunsByJob.length} cron job(s) active, ${result.inputs.crossAgentClusters.length} cross-agent cluster(s).${RESET}`);
+        if (opts.save) {
+            const digestsDir = path.join(VAULT_DIR, '00-System', 'brain-digests');
+            mkdirSync(digestsDir, { recursive: true });
+            const stamp = new Date().toISOString().slice(0, 10);
+            const filename = path.join(digestsDir, `${stamp}-${days}d.md`);
+            const fileBody = `---\ntype: brain-digest\ngeneratedAt: ${new Date().toISOString()}\nwindowDays: ${days}\nmodel: ${opts.model}\n---\n\n${result.markdown}\n`;
+            writeFileSync(filename, fileBody);
+            console.log(`  ${GREEN}✓${RESET} Saved to ${DIM}${filename}${RESET}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  ${RED}Error generating brain digest:${RESET} ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+});
 // ── Agent commands ──────────────────────────────────────────────────
 const agentCmd = program
     .command('agent')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",