clementine-agent 1.7.0 → 1.8.1

package/dist/agent/self-improve-loop.d.ts

@@ -26,6 +26,19 @@
  */
 export interface TriggerFile {
     jobName: string;
+    /**
+     * Bare job name (without `{agentSlug}:` prefix). Set by cron-scheduler
+     * for agent-scoped jobs so the loop can look the job up in
+     * agents/{agentSlug}/CRON.md. Optional for backward compat with
+     * triggers written before this field existed.
+     */
+    bareName?: string;
+    /**
+     * Owning agent slug, set by cron-scheduler. When present, the loop
+     * applies fixes to vault/00-System/agents/{agentSlug}/CRON.md instead
+     * of the central CRON.md. Falls back to scanning if absent (older triggers).
+     */
+    agentSlug?: string;
     consecutiveErrors: number;
     recentErrors: string[];
     triggeredAt: string;
@@ -61,6 +74,11 @@ export interface SelfImproveLoopOptions {
     triggersDir?: string;
     pendingDir?: string;
     cronPath?: string;
+    /**
+     * Override the agents root (vault/00-System/agents). When a trigger
+     * has agentSlug, the loop reads/writes `${agentsDir}/${agentSlug}/CRON.md`.
+     */
+    agentsDir?: string;
     /**
      * Disable the fs.watch event-driven path. Tests use this so they can
      * call tick() directly without racing the watcher.
@@ -73,6 +91,7 @@ export declare class SelfImproveLoop {
     private readonly triggersDir;
     private readonly pendingDir;
     private readonly cronPath;
+    private readonly agentsDir;
     private readonly dispatcher;
     private readonly watchEnabled;
     private timer;

package/dist/agent/self-improve-loop.js

@@ -28,7 +28,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, watch, wr
 import path from 'node:path';
 import matter from 'gray-matter';
 import pino from 'pino';
-import { BASE_DIR, SYSTEM_DIR } from '../config.js';
+import { AGENTS_DIR, BASE_DIR, SYSTEM_DIR } from '../config.js';
 const logger = pino({ name: 'clementine.self-improve-loop' });
 /**
  * Fallback tick interval. The loop is primarily event-driven via fs.watch
@@ -46,6 +46,7 @@ const WATCH_DEBOUNCE_MS = 2000;
 const TRIGGERS_DIR = path.join(BASE_DIR, 'self-improve', 'triggers');
 const PENDING_CHANGES_DIR = path.join(BASE_DIR, 'self-improve', 'pending-changes');
 const CRON_PATH = path.join(SYSTEM_DIR, 'CRON.md');
+const AGENTS_ROOT = AGENTS_DIR;
 // ── Pattern recognition ──────────────────────────────────────────────
 const PATTERNS = [
     {
@@ -108,36 +109,108 @@ export function classifyFailure(recentErrors) {
         description: 'Unrecognized failure pattern. Owner needs to inspect the trigger file.',
     };
 }
-function loadCronJob(jobName, cronPath) {
+function readJobsFromFile(cronPath) {
     if (!existsSync(cronPath))
         return null;
     const raw = readFileSync(cronPath, 'utf-8');
     const parsed = matter(raw);
     const jobs = (parsed.data.jobs ?? []);
-    const job = jobs.find((j) => String(j.name ?? '') === jobName);
-    if (!job)
-        return null;
-    const agentSlug = typeof job.agentSlug === 'string' ? job.agentSlug : (typeof job.agent_slug === 'string' ? job.agent_slug : undefined);
-    return { agentSlug, job, raw, parsed };
+    return { raw, parsed, jobs };
+}
+function readAgentSlug(job) {
+    if (typeof job.agentSlug === 'string')
+        return job.agentSlug;
+    if (typeof job.agent_slug === 'string')
+        return job.agent_slug;
+    return undefined;
 }
 /**
- * Apply the recipe's mutator to the job's frontmatter and write CRON.md
- * back atomically. Returns true if a change was actually written.
+ * Locate a job's frontmatter entry in either the central CRON.md or an
+ * agent-scoped CRON.md. Search priority:
+ *
+ *   1. If trigger.agentSlug is set, look in agents/{slug}/CRON.md by bareName.
+ *   2. Otherwise look in central CRON.md by exact name.
+ *   3. Fall back to scanning agents/* for the bareName (covers older triggers
+ *      that lack agentSlug — the cron-scheduler-prefixed jobName like
+ *      `slug:name` lets us recover the slug).
  */
-function applyCronEdit(jobName, recipe, cronPath) {
+function loadCronJob(trigger, cronPath, agentsDir) {
+    const explicitSlug = trigger.agentSlug;
+    const bare = trigger.bareName ?? (explicitSlug && trigger.jobName.startsWith(`${explicitSlug}:`)
+        ? trigger.jobName.slice(explicitSlug.length + 1)
+        : trigger.jobName);
+    // 1. Agent-scoped file when slug is known
+    if (explicitSlug) {
+        const agentCronPath = path.join(agentsDir, explicitSlug, 'CRON.md');
+        const file = readJobsFromFile(agentCronPath);
+        if (file) {
+            const job = file.jobs.find((j) => String(j.name ?? '') === bare);
+            if (job) {
+                return {
+                    agentSlug: explicitSlug,
+                    cronPath: agentCronPath,
+                    bareName: bare,
+                    job,
+                    raw: file.raw,
+                    parsed: file.parsed,
+                };
+            }
+        }
+    }
+    // 2. Central CRON.md by full jobName (handles globally-defined jobs and
+    //    legacy jobs tagged with agentSlug field directly in the central file)
+    const central = readJobsFromFile(cronPath);
+    if (central) {
+        const job = central.jobs.find((j) => String(j.name ?? '') === trigger.jobName);
+        if (job) {
+            return {
+                agentSlug: explicitSlug ?? readAgentSlug(job),
+                cronPath,
+                bareName: String(job.name ?? ''),
+                job,
+                raw: central.raw,
+                parsed: central.parsed,
+            };
+        }
+    }
+    // 3. Recover via scan: trigger jobName follows `{slug}:{bareName}` for
+    //    agent-scoped jobs even when older triggers omit agentSlug.
+    if (!explicitSlug && trigger.jobName.includes(':')) {
+        const [slug, ...rest] = trigger.jobName.split(':');
+        const inferredBare = rest.join(':');
+        if (slug && inferredBare) {
+            const agentCronPath = path.join(agentsDir, slug, 'CRON.md');
+            const file = readJobsFromFile(agentCronPath);
+            if (file) {
+                const job = file.jobs.find((j) => String(j.name ?? '') === inferredBare);
+                if (job) {
+                    return {
+                        agentSlug: slug,
+                        cronPath: agentCronPath,
+                        bareName: inferredBare,
+                        job,
+                        raw: file.raw,
+                        parsed: file.parsed,
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Apply the recipe's mutator to the job's frontmatter and write the CRON.md
+ * (central or agent-scoped, whichever the lookup resolved to) back atomically.
+ * Returns true if a change was actually written.
+ */
+function applyCronEdit(lookup, recipe) {
     if (!recipe.apply)
         return false;
-    const lookup = loadCronJob(jobName, cronPath);
-    if (!lookup) {
-        logger.warn({ jobName }, 'Job not found in CRON.md — cannot apply fix');
-        return false;
-    }
     const changed = recipe.apply(lookup.job);
     if (!changed)
         return false;
-    // Re-stringify with the existing content body preserved.
     const updated = matter.stringify(lookup.parsed.content, lookup.parsed.data);
-    writeFileSync(cronPath, updated);
+    writeFileSync(lookup.cronPath, updated);
     return true;
 }
 function writePendingChange(record, dir) {
@@ -152,6 +225,7 @@ export class SelfImproveLoop {
     triggersDir;
     pendingDir;
     cronPath;
+    agentsDir;
     dispatcher;
     watchEnabled;
     timer = null;
@@ -165,6 +239,7 @@ export class SelfImproveLoop {
         this.triggersDir = opts.triggersDir ?? TRIGGERS_DIR;
         this.pendingDir = opts.pendingDir ?? PENDING_CHANGES_DIR;
         this.cronPath = opts.cronPath ?? CRON_PATH;
+        this.agentsDir = opts.agentsDir ?? AGENTS_ROOT;
         this.watchEnabled = opts.disableWatch !== true;
     }
     start() {
@@ -286,23 +361,32 @@ export class SelfImproveLoop {
     }
     async processOne(trigger, counts) {
         const recipe = classifyFailure(trigger.recentErrors);
-        const lookup = loadCronJob(trigger.jobName, this.cronPath);
-        const agentSlug = lookup?.agentSlug;
+        const lookup = loadCronJob(trigger, this.cronPath, this.agentsDir);
+        const agentSlug = trigger.agentSlug ?? lookup?.agentSlug;
         if (recipe.category === 'safe-cron-config') {
-            const applied = applyCronEdit(trigger.jobName, recipe, this.cronPath);
+            if (!lookup) {
+                // Job vanished from CRON files (renamed/deleted). Nothing to fix.
+                counts.noop++;
+                logger.warn({ jobName: trigger.jobName, agentSlug }, 'Job not found in any CRON.md — cannot apply fix');
+                return;
+            }
+            const applied = applyCronEdit(lookup, recipe);
             if (applied) {
                 counts.applied++;
+                const where = lookup.agentSlug
+                    ? `\`agents/${lookup.agentSlug}/CRON.md\``
+                    : '`CRON.md`';
                 await this.notifyAgent(agentSlug, [
                     `🔧 **Auto-fixed** \`${trigger.jobName}\` after ${trigger.consecutiveErrors} consecutive failures.`,
                     '',
                     recipe.description,
                     '',
-                    'I\'ll watch the next run to confirm it lands cleanly.',
+                    `Edit applied to ${where}. I'll watch the next run to confirm it lands cleanly.`,
                 ].join('\n'));
             }
             else {
                 counts.noop++;
-                logger.info({ jobName: trigger.jobName }, 'Fix recipe applied is already in place — trigger removed without further action');
+                logger.info({ jobName: trigger.jobName, agentSlug }, 'Fix recipe applied is already in place — trigger removed without further action');
             }
             return;
         }

package/dist/cli/dashboard.js

@@ -15255,6 +15255,12 @@ function switchBuildTab(tab) {
     if (typeof _ensureDrawflowLoaded === 'function') {
       _ensureDrawflowLoaded().catch(function() { /* */ });
     }
+    // Populate the Owner picker once per session — agents rarely change
+    // mid-session, so the cost is minimal and the dropdown is ready by
+    // the time the user clicks New.
+    if (typeof populateBuilderOwnerPicker === 'function') {
+      populateBuilderOwnerPicker().catch(function() { /* */ });
+    }
     // Focus chat input
     setTimeout(function() {
       var bi = document.getElementById('builder-input');
@@ -15263,10 +15269,10 @@ function switchBuildTab(tab) {
   }
 }
 
-// "New" button in the Build header strip — context-aware: prompts for a
-// name and creates the right artifact for the active tab. Workflows + Crons
-// route through the workflow_create surface; Skills falls back to the
-// existing chat-based Skill Studio reset.
+// "New" button in the Build header strip — context-aware. Crons open the
+// dedicated cron modal so the entry lands in CRON.md (not as a one-step
+// workflow file). Workflows route through /api/builder/workflows. Owner is
+// read from the header's Owner picker — empty string means global.
 async function newFromBuildHeader() {
   var activeTab = document.querySelector('#build-tabs button.active')?.getAttribute('data-build-tab') || 'workflows';
   if (activeTab === 'skills') {
@@ -15279,22 +15285,72 @@ async function newFromBuildHeader() {
     toast('Pick a template to fork from the cards.', 'info');
     return;
   }
-  var noun = activeTab === 'crons' ? 'cron' : 'workflow';
-  var name = prompt('Name your new ' + noun + ':');
+  var owner = (document.getElementById('builder-owner') || {}).value || '';
+  if (activeTab === 'crons') {
+    if (typeof openCreateCronModal === 'function') {
+      openCreateCronModal(owner);
+      return;
+    }
+  }
+  var name = prompt('Name your new workflow:');
   if (!name || !name.trim()) return;
   try {
     var body = { name: name.trim() };
-    if (activeTab === 'crons') body.schedule = '0 9 * * *';  // sensible default; user edits in canvas
+    if (owner) body.agent = owner;
     var r = await apiJson('POST', '/api/builder/workflows', body);
     if (r && r.error) { toast('Create failed: ' + r.error, 'error'); return; }
     if (r && r.id) {
-      await refreshBuilderCanvasPicker(activeTab === 'crons' ? 'cron' : 'workflow');
+      await refreshBuilderCanvasPicker('workflow');
       await openBuilderWorkflow(r.id);
-      toast('Created ' + noun + ': ' + name, 'success');
+      toast('Created workflow: ' + name + (owner ? ' (' + owner + ')' : ''), 'success');
     }
   } catch (err) { toast('Create error: ' + err, 'error'); }
 }
 
+// Owner picker — populated from /api/agents on first build-tab activation
+// and refreshed on demand. Empty value = Clementine/global; any other value
+// is the agent slug for scoped reads/writes.
+var _builderOwnerPickerLoaded = false;
+async function populateBuilderOwnerPicker(force) {
+  if (_builderOwnerPickerLoaded && !force) return;
+  var sel = document.getElementById('builder-owner');
+  if (!sel) return;
+  try {
+    var r = await apiFetch('/api/agents');
+    var agents = r.ok ? await r.json() : [];
+    var prev = sel.value;
+    var opts = '<option value="">Clementine (global)</option>';
+    if (Array.isArray(agents)) {
+      for (var i = 0; i < agents.length; i++) {
+        var slug = agents[i] && agents[i].slug;
+        if (!slug) continue;
+        var label = agents[i].name ? (agents[i].name + ' (' + slug + ')') : slug;
+        opts += '<option value="' + esc(slug) + '">' + esc(label) + '</option>';
+      }
+    }
+    sel.innerHTML = opts;
+    if (prev) sel.value = prev;
+    _builderOwnerPickerLoaded = true;
+  } catch (err) {
+    // Leave the default global option in place; not fatal.
+  }
+}
+
+// Mirror the visible owner selection into the legacy hidden builder-agent
+// input + label so chat/skill/agent flows that already read those keep
+// working, then refresh the canvas picker so the list re-filters.
+async function onBuilderOwnerChange() {
+  var sel = document.getElementById('builder-owner');
+  var owner = sel ? sel.value : '';
+  var hidden = document.getElementById('builder-agent');
+  var label = document.getElementById('builder-agent-label');
+  if (hidden) hidden.value = owner || '';
+  if (label) label.textContent = owner ? 'Owner: ' + owner : '';
+  var typeSel = document.getElementById('builder-type');
+  var type = typeSel && typeSel.value === 'cron' ? 'cron' : 'workflow';
+  await refreshBuilderCanvasPicker(type);
+}
+
 // ── Build templates: fork a starter pattern into a new workflow ─────
 async function forkBuildTemplate(templateId) {
   var templates = {
@@ -19503,10 +19559,19 @@ async function refreshBuilderCanvasPicker(type) {
   var picker = document.getElementById('builder-canvas-picker');
   if (!picker) return;
   try {
+    var owner = (document.getElementById('builder-owner') || {}).value || '';
     var r = await apiFetch('/api/builder/workflows');
     var d = await r.json();
-    var items = (d.workflows || []).filter(function(w) { return w.origin === type; });
-    var opts = '<option value="">' + (items.length ? '— pick a ' + type + ' —' : '(none yet)') + '</option>';
+    var items = (d.workflows || []).filter(function(w) {
+      if (w.origin !== type) return false;
+      // Owner filter: empty owner = Clementine/global only; named owner =
+      // agent-scoped entries for that slug only. The serializer reports
+      // scope='agent' for entries living under <AGENTS_DIR>/<slug>/.
+      if (owner) return w.scope === 'agent' && w.agentSlug === owner;
+      return w.scope !== 'agent';
+    });
+    var ownerLabel = owner ? '@' + owner : 'global';
+    var opts = '<option value="">' + (items.length ? '— pick a ' + type + ' (' + ownerLabel + ') —' : '(none yet for ' + ownerLabel + ')') + '</option>';
     for (var i = 0; i < items.length; i++) {
       var w = items[i];
       var lbl = w.name + (w.schedule ? '  ·  ' + w.schedule : '') + (w.enabled ? '' : '  · off');
@@ -21227,8 +21292,8 @@ async function refreshMemoryHealth() {
       html += '<div style="font-weight:600;margin-bottom:4px">Retrieval running on sparse vectors for ' + missing.toLocaleString() + ' chunks</div>';
       html += '<div style="font-size:12px;color:var(--text-muted)">Backfill builds 768-dim neural embeddings for semantic search. First run downloads ~440MB.</div>';
       html += '</div>';
-      html += '<button class="btn-sm" onclick="memoryHealthAction(\'reembed-dense\', { limit: 200 })" title="Embed up to 200 chunks now">Backfill 200</button>';
-      html += '<button class="btn-sm" onclick="memoryHealthAction(\'reembed-dense\', { limit: 2000 })" title="Embed up to 2000 chunks now (slower)">Backfill 2000</button>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'reembed-dense\\', { limit: 200 })" title="Embed up to 200 chunks now">Backfill 200</button>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'reembed-dense\\', { limit: 2000 })" title="Embed up to 2000 chunks now (slower)">Backfill 2000</button>';
       html += '</div></div>';
     }
 

package/dist/gateway/cron-scheduler.js

@@ -1184,19 +1184,27 @@ export class CronScheduler {
             if (advice.shouldEscalate) {
                 this.logAdvisorEvent('escalation', job.name, advice.escalationReason ?? 'Escalated to unleashed');
             }
-            // Write targeted self-improvement trigger when consecutive errors are high
+            // Write targeted self-improvement trigger when consecutive errors are high.
+            // Include agentSlug + bareName so the self-improve loop can locate jobs
+            // defined in per-agent CRON.md files (vault/00-System/agents/{slug}/CRON.md)
+            // rather than only the central one.
             if (consErrors >= 3) {
                 try {
                     const triggerDir = path.join(BASE_DIR, 'self-improve', 'triggers');
                     mkdirSync(triggerDir, { recursive: true });
                     const triggerPath = path.join(triggerDir, `${job.name.replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+                    const bareName = job.agentSlug && job.name.startsWith(`${job.agentSlug}:`)
+                        ? job.name.slice(job.agentSlug.length + 1)
+                        : job.name;
                     writeFileSync(triggerPath, JSON.stringify({
                         jobName: job.name,
+                        bareName,
+                        agentSlug: job.agentSlug,
                         consecutiveErrors: consErrors,
                         recentErrors: this.runLog.readRecent(job.name, 3).map(e => e.error?.slice(0, 200)),
                         triggeredAt: new Date().toISOString(),
                     }, null, 2));
-                    logger.info({ job: job.name, consErrors }, 'Wrote self-improvement trigger for failing job');
+                    logger.info({ job: job.name, agentSlug: job.agentSlug, consErrors }, 'Wrote self-improvement trigger for failing job');
                 }
                 catch { /* non-fatal */ }
             }

package/dist/gateway/heartbeat-scheduler.d.ts

@@ -23,6 +23,7 @@ export declare class HeartbeatScheduler {
     private lastDenseBackfillAt;
     private denseBackfillInFlight;
     private lastSalienceDecayDate;
+    private lastMemoryPulseDate;
     /** Wire up the cron scheduler so daily plan suggestions can be applied. */
     setCronScheduler(cs: CronScheduler): void;
     private getLastAgentSiRun;
@@ -53,6 +54,14 @@ export declare class HeartbeatScheduler {
      * HeartbeatState. Pinned chunks exempt; soft-deleted and superseded skipped.
      */
     private maybeRunSalienceDecay;
+    /**
+     * Weekly Memory Pulse — once-per-week observability report on the memory
+     * subsystem. Aggregates the same signals visible on Brain → Health
+     * (coverage, recent writes, supersedes, recall contribution) into a
+     * compact message and dispatches it. Skipped if nothing meaningful
+     * happened this week (avoids empty noise on quiet weeks).
+     */
+    private maybeSendMemoryPulse;
     private runInsightCheck;
     /** Called when user replies to a proactive message — resets cooldown. */
     recordInsightAcknowledged(): void;

package/dist/gateway/heartbeat-scheduler.js

@@ -33,6 +33,7 @@ export class HeartbeatScheduler {
     lastDenseBackfillAt = 0;
     denseBackfillInFlight = false;
     lastSalienceDecayDate = '';
+    lastMemoryPulseDate = '';
     /** Wire up the cron scheduler so daily plan suggestions can be applied. */
     setCronScheduler(cs) { this.cronScheduler = cs; }
     getLastAgentSiRun(slug) {
@@ -53,6 +54,8 @@ export class HeartbeatScheduler {
             this.lastConsolidationDate = this.lastState.lastConsolidationDate;
         if (this.lastState.lastSalienceDecayDate)
             this.lastSalienceDecayDate = this.lastState.lastSalienceDecayDate;
+        if (this.lastState.lastMemoryPulseDate)
+            this.lastMemoryPulseDate = this.lastState.lastMemoryPulseDate;
         if (this.lastState.lastAgentSiRuns) {
             this.lastAgentSiRuns = new Map(Object.entries(this.lastState.lastAgentSiRuns));
         }
@@ -305,6 +308,9 @@ export class HeartbeatScheduler {
             }).catch(err => {
                 logger.warn({ err }, 'Weekly review failed');
             });
+            // Memory Pulse — weekly observability report on the 5-phase memory
+            // system. Skipped if nothing happened (avoids empty noise on quiet weeks).
+            this.maybeSendMemoryPulse();
         }
         // First Monday of month: monthly assessment (between 8-9 PM)
         if (now.getDay() === 1 && now.getDate() <= 7 && hour >= 20 && hour < 21) {
@@ -805,6 +811,74 @@ export class HeartbeatScheduler {
             logger.debug({ err }, 'Salience decay sweep failed (non-fatal)');
         }
     }
+    /**
+     * Weekly Memory Pulse — once-per-week observability report on the memory
+     * subsystem. Aggregates the same signals visible on Brain → Health
+     * (coverage, recent writes, supersedes, recall contribution) into a
+     * compact message and dispatches it. Skipped if nothing meaningful
+     * happened this week (avoids empty noise on quiet weeks).
+     */
+    maybeSendMemoryPulse() {
+        const today = todayISO();
+        if (this.lastMemoryPulseDate === today)
+            return;
+        const store = this.gateway.getMemoryStore();
+        if (!store)
+            return;
+        try {
+            const stats = store.getMemoryStats();
+            const supersedeStats = typeof store.getSupersedeStats === 'function'
+                ? store.getSupersedeStats()
+                : { superseded: 0 };
+            const graphStats = typeof store.getGraphStats === 'function'
+                ? store.getGraphStats({ lookbackHours: 24 * 7 })
+                : { wikilinkCount: 0, recallContributionByType: {}, tracesAnalyzed: 0 };
+            const recentWrites = typeof store.getRecentWrites === 'function'
+                ? store
+                    .getRecentWrites(500)
+                : [];
+            const weekAgoIso = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+            const writesThisWeek = recentWrites.filter(w => w.extractedAt > weekAgoIso);
+            const supersedesThisWeek = writesThisWeek.filter(w => w.status === 'superseded').length;
+            const dedupedThisWeek = writesThisWeek.filter(w => w.status === 'dedup_skipped').length;
+            const writesWithSalience = writesThisWeek.filter(w => w.salienceHint != null).length;
+            // Skip if nothing happened (no writes, no traces) — don't spam empty reports
+            if (writesThisWeek.length === 0 && graphStats.tracesAnalyzed === 0)
+                return;
+            const coveragePct = stats.totalChunks > 0
+                ? Math.round((stats.chunksWithDenseEmbeddings / stats.totalChunks) * 100)
+                : 0;
+            const cb = graphStats.recallContributionByType;
+            const totalMatches = Object.values(cb).reduce((a, b) => a + b, 0);
+            const pctOf = (n) => totalMatches > 0 ? Math.round((n / totalMatches) * 100) : 0;
+            const lines = [
+                `**Memory Pulse — last 7 days**`,
+                ``,
+                `**Coverage:** ${coveragePct}% semantic (${stats.chunksWithDenseEmbeddings.toLocaleString()}/${stats.totalChunks.toLocaleString()} chunks)`,
+            ];
+            if (writesThisWeek.length > 0) {
+                lines.push(`**Writes:** ${writesThisWeek.length} captured`
+                    + (writesWithSalience > 0 ? `, ${writesWithSalience} with salience hint` : '')
+                    + (dedupedThisWeek > 0 ? `, ${dedupedThisWeek} reinforced` : ''));
+            }
+            if (supersedesThisWeek > 0 || supersedeStats.superseded > 0) {
+                lines.push(`**Self-correction:** ${supersedesThisWeek} this week, ${supersedeStats.superseded} all-time`);
+            }
+            if (graphStats.tracesAnalyzed > 0 && totalMatches > 0) {
+                lines.push(`**Recall mix:** ${pctOf(cb.fts ?? 0)}% lexical · ${pctOf(cb.vector ?? 0)}% semantic · ${pctOf(cb.graph ?? 0)}% graph · ${pctOf(cb.recency ?? 0)}% recent`);
+            }
+            lines.push(``);
+            lines.push(`Full breakdown on the dashboard: Brain → Health.`);
+            this.dispatcher.send(lines.join('\n')).catch(err => logger.debug({ err }, 'Failed to send memory pulse'));
+            this.lastMemoryPulseDate = today;
+            this.lastState.lastMemoryPulseDate = today;
+            this.saveState();
+            logger.info({ coveragePct, writesThisWeek: writesThisWeek.length, supersedesThisWeek }, 'Memory Pulse sent');
+        }
+        catch (err) {
+            logger.debug({ err }, 'Memory Pulse failed (non-fatal)');
+        }
+    }
     async runInsightCheck() {
         // Initialize insight state if needed
         if (!this.lastState.insightState) {

package/dist/types.d.ts

@@ -216,6 +216,7 @@ export interface HeartbeatState {
     lastAgentSiRuns?: Record<string, string>;
     lastSkillDecayDate?: string;
     lastSalienceDecayDate?: string;
+    lastMemoryPulseDate?: string;
     /** Proactive insight engine state */
     insightState?: {
         sentToday: string[];

package/package.json

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