clementine-agent 1.8.2 → 1.9.1

package/dist/agent/assistant.js

@@ -379,13 +379,20 @@ const AUTO_MEMORY_PROMPT = `You are a memory extraction agent. Your ONLY job is
 
 {current_memory}
 
+## Current User Model (already known — DO NOT re-extract these)
+
+{current_user_model}
+
 ## Where to save what (memory routing):
 
 **Always-in-context core memory** (use the user_model tool — these stay top-of-mind in every future session):
 - **Lasting facts about ${OWNER}** (role, location, identifiers, durable preferences, communication style) → user_model(action="append", slot="user_facts", content=...)
 - **Active goals/intents** (what ${OWNER} is trying to accomplish right now) → user_model(action="append", slot="goals", content=...)
 - **Key people/projects** (recurring relationships) → user_model(action="append", slot="relationships", content=...)
-- Use action="replace" instead of "append" if you're updating an existing fact rather than adding a new one. Slots are capped at 2000 chars — older content rolls off on append.
+- **DEFAULT to action="append"** — it adds the new fact alongside what's already there.
+- Only use action="replace" when CORRECTING an existing fact, and you MUST include the FULL slot content (everything from "Current User Model" above, with the correction applied). \`replace\` overwrites the entire slot — passing only the new fact wipes everything else.
+- Never use action="clear" from this extractor. Clearing is a deliberate user action, not a memory-extraction outcome.
+- Slots are capped at 2000 chars — older content rolls off on append automatically.
 
 **Vault notes** (use memory_write/note_create — durable but retrieved on demand):
 - **People mentioned** — names, relationships, context → create or update person notes in 02-People/
@@ -1340,6 +1347,32 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
                 parts.push(`## Recent Corrections (apply immediately)\n\n${lines.join('\n')}`);
             }
         }
+        // Inject recent feedback signals (closes the feedback → behavior loop).
+        // Without this block, user thumbs-down + comments live in the feedback
+        // table and never reach the agent's awareness — only the skill-suppress
+        // filter consumed them. We surface aggregates + the last few commented
+        // negatives so the agent can self-adjust on the next turn. Skipped when
+        // there's nothing to report (no noise).
+        if (this.memoryStore?.getRecentFeedbackSignals) {
+            try {
+                const sig = this.memoryStore.getRecentFeedbackSignals({ days: 14, limit: 3 });
+                if (sig.negative > 0) {
+                    const lines = [];
+                    const total = sig.positive + sig.negative;
+                    const ratio = total > 0 ? Math.round((sig.negative / total) * 100) : 0;
+                    lines.push(`Last 14 days: ${sig.negative} negative / ${sig.positive} positive (${ratio}% negative).`);
+                    if (sig.negativesWithComments.length > 0) {
+                        lines.push('Recent negative comments — adjust accordingly:');
+                        for (const n of sig.negativesWithComments) {
+                            const comment = n.comment.length > 200 ? n.comment.slice(0, 200) + '…' : n.comment;
+                            lines.push(`- (${n.channel}) ${comment}`);
+                        }
+                    }
+                    parts.push(`## Recent feedback signals\n\n${lines.join('\n')}`);
+                }
+            }
+            catch { /* non-fatal */ }
+        }
         // Proactive skill injection: match user message against skill triggers
         if (this._lastUserMessage && !isAutonomous) {
             try {
@@ -1612,6 +1645,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep',
             'WebSearch', 'WebFetch',
             mcpTool('working_memory'),
+            mcpTool('user_model'),
             mcpTool('memory_read'),
             mcpTool('memory_write'),
             mcpTool('memory_search'),
@@ -3657,10 +3691,23 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     // Non-fatal — proceed without corrections
                 }
             }
+            // Render current user_model state so the extractor can: (a) skip
+            // re-extracting facts already there, (b) safely use action="replace"
+            // by passing the full slot content with a correction applied. Scoped
+            // to the active agent — Clementine sees global slots, hired agents
+            // see their own per-agent slots.
+            let currentUserModel = '(empty — no slots populated yet)';
+            try {
+                const rendered = this.memoryStore?.renderUserModel?.(profile?.slug ?? null);
+                if (rendered && rendered.trim())
+                    currentUserModel = rendered;
+            }
+            catch { /* non-fatal */ }
             const memPrompt = AUTO_MEMORY_PROMPT
                 .replace('{user_message}', userMessage)
                 .replace('{assistant_response}', truncatedResponse)
                 .replace('{current_memory}', currentMemory || '(empty — no existing memory yet)')
+                .replace('{current_user_model}', currentUserModel)
                 .replace('{recent_corrections}', correctionsText);
             const userMessageSnippet = userMessage.slice(0, 500);
             const stream = query({
@@ -3680,6 +3727,13 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         mcpTool('task_add'),
                         mcpTool('note_take'),
                         mcpTool('memory_read'),
+                        // Auto-extractor needs user_model to populate the always-in-context
+                        // core slots (user_facts, goals, relationships, agent_persona).
+                        // The MCP server boots with CLEMENTINE_TEAM_AGENT=<slug>, so writes
+                        // are scoped to the active agent automatically — Clementine's
+                        // sessions populate global slots, hired-agent sessions populate
+                        // that agent's per-agent slots.
+                        mcpTool('user_model'),
                     ],
                     mcpServers: {
                         [TOOLS_SERVER]: {

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;
@@ -35,6 +48,13 @@ export interface FixRecipe {
     category: FixCategory;
     /** Description of what this fix does, for DMs. */
     description: string;
+    /**
+     * Frontmatter keys this recipe may touch. Used to snapshot prior values
+     * before apply() runs so an ineffective fix can be reverted by post-fix
+     * verification without restoring fields the recipe never owned. Required
+     * for safe-cron-config recipes that participate in autoApply verification.
+     */
+    fields?: readonly string[];
     /**
      * For safe-cron-config: a function that mutates the job's frontmatter
      * entry in-place. Returns true if any change was made (false = idempotent
@@ -61,6 +81,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 +98,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 = [
     {
@@ -54,6 +55,7 @@ const PATTERNS = [
         recipe: () => ({
             category: 'safe-cron-config',
             description: 'Hit max-turns ceiling repeatedly. Switching to unleashed mode (multi-phase) so the job can complete its workflow.',
+            fields: ['mode', 'max_hours'],
             apply: (job) => {
                 let changed = false;
                 if (job.mode !== 'unleashed') {
@@ -108,37 +110,118 @@ 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 the captured prevFields snapshot when a change was written, or
+ * null when no change was needed (idempotent re-apply). prevFields uses
+ * `null` to represent "field was absent before the fix" — the revert path
+ * deletes the key in that case.
+ */
+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;
+        return null;
+    // Snapshot only the fields the recipe declared it would touch — over-broad
+    // snapshots would clobber concurrent edits during a revert.
+    const prevFields = {};
+    for (const key of recipe.fields ?? []) {
+        prevFields[key] = key in lookup.job ? lookup.job[key] : null;
     }
     const changed = recipe.apply(lookup.job);
     if (!changed)
-        return false;
-    // Re-stringify with the existing content body preserved.
+        return null;
     const updated = matter.stringify(lookup.parsed.content, lookup.parsed.data);
-    writeFileSync(cronPath, updated);
-    return true;
+    writeFileSync(lookup.cronPath, updated);
+    return prevFields;
 }
 function writePendingChange(record, dir) {
     mkdirSync(dir, { recursive: true });
@@ -152,6 +235,7 @@ export class SelfImproveLoop {
     triggersDir;
     pendingDir;
     cronPath;
+    agentsDir;
     dispatcher;
     watchEnabled;
     timer = null;
@@ -165,6 +249,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 +371,48 @@ 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 (applied) {
+            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 prevFields = applyCronEdit(lookup, recipe);
+            if (prevFields) {
                 counts.applied++;
+                // Register the edit for post-fix verification. The verifier watches
+                // the next AUTOAPPLY_VERDICT_WINDOW non-skipped runs and reverts
+                // prevFields if 0 succeed. Lazy import avoids pulling the gateway
+                // graph into the agent layer at module-load time.
+                try {
+                    const { recordAutoApplyForVerification } = await import('../gateway/fix-verification.js');
+                    recordAutoApplyForVerification(trigger.jobName, {
+                        kind: 'cron-config',
+                        file: lookup.cronPath,
+                        bareName: lookup.bareName,
+                        prevFields,
+                    });
+                }
+                catch (err) {
+                    logger.warn({ err, jobName: trigger.jobName }, 'Failed to register cron-config autoApply for verification (non-fatal)');
+                }
+                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}. Verifying over the next 3 runs — I'll revert automatically if it doesn't help.`,
                 ].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

@@ -6603,6 +6603,15 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         const stateFile = path.join(siDir, 'state.json');
         const logFile = path.join(siDir, 'experiment-log.jsonl');
         const pendingDir = path.join(siDir, 'pending-changes');
+        // Active failure triggers — written by cron-scheduler when a job hits
+        // 3+ consecutive errors; consumed by self-improve-loop on its next tick.
+        // Surfacing them here gives the user a "work in progress" view between
+        // tick boundaries (event-driven debounce + 1h fallback).
+        const triggersDir = path.join(siDir, 'triggers');
+        // Pending fix verifications — auto-applied fixes that are soaking
+        // through the 3-run verdict window (cron-config / advisor-rule /
+        // prompt-override). Reverts automatically if 0 succeed.
+        const verificationsFile = path.join(BASE_DIR, 'cron', 'fix-verifications.json');
         let state = null;
         if (existsSync(stateFile)) {
             try {
@@ -6632,7 +6641,29 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             }
             catch { /* ignore */ }
         }
-        res.json({ state, experiments, pending });
+        let triggers = [];
+        if (existsSync(triggersDir)) {
+            try {
+                triggers = readdirSync(triggersDir).filter(f => f.endsWith('.json'))
+                    .map(f => { try {
+                    return JSON.parse(readFileSync(path.join(triggersDir, f), 'utf-8'));
+                }
+                catch {
+                    return null;
+                } })
+                    .filter(Boolean);
+            }
+            catch { /* ignore */ }
+        }
+        let verifications = [];
+        if (existsSync(verificationsFile)) {
+            try {
+                const raw = JSON.parse(readFileSync(verificationsFile, 'utf-8'));
+                verifications = Object.values(raw.pending ?? {});
+            }
+            catch { /* ignore */ }
+        }
+        res.json({ state, experiments, pending, triggers, verifications });
     });
     app.post('/api/self-improve/run', async (_req, res) => {
         try {
@@ -12667,8 +12698,8 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
 
         <!-- User Model — MemGPT-style core memory blocks always loaded into context -->
         <div class="tab-pane" id="tab-intelligence-user-model">
-          <div style="color:var(--muted,#888);margin-bottom:12px;font-size:13px">
-            What the agent always knows about you. These slots load into every conversation's context (above retrieved memory). Edit directly to correct or steer.
+          <div style="color:var(--muted,#888);margin-bottom:12px;font-size:13px;max-width:760px">
+            <strong style="color:var(--text)">Always-in-context core memory.</strong> Four small slots (capped at 2000 chars each) that load into <em>every</em> conversation — distinct from MEMORY.md and the chunk store. The agent appends here automatically as you talk; you can also edit directly to correct or steer. Use the Scope dropdown to view per-agent slots (each hired agent maintains their own).
           </div>
           <div style="display:flex;gap:8px;margin-bottom:12px;align-items:center;flex-wrap:wrap">
             <label style="font-size:13px;color:var(--text-secondary)">Scope:</label>
@@ -12930,14 +12961,34 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
           </div>
         </div>
         <div class="tab-pane" id="tab-intelligence-learning">
-          <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
-            <div style="font-size:13px;color:var(--text-secondary)">Self-improvement runs nightly at 1 AM. You can also trigger it manually.</div>
+          <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px;gap:12px;flex-wrap:wrap">
+            <div style="font-size:13px;color:var(--text-secondary);max-width:680px">
+              Self-improvement runs nightly at 1 AM. The autonomous loop also auto-fixes failing crons (3+ consecutive errors) and verifies each fix over the next 3 runs &mdash; reverting automatically if it doesn't help.
+            </div>
             <button class="btn-sm btn-primary" onclick="siRunCycle()" id="si-run-btn">Run Now</button>
           </div>
           <div class="grid-2" id="si-status-cards">
             <div class="skel-block"><div class="skel-row med"></div><div class="skel-row short"></div></div>
             <div class="skel-block"><div class="skel-row med"></div><div class="skel-row short"></div></div>
           </div>
+          <div class="card" style="margin-top:16px">
+            <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
+              <span>Active failures</span>
+              <span class="tab-badge" id="tab-si-triggers" style="display:none;background:#ef4444;color:#fff">0</span>
+            </div>
+            <div class="card-body" id="si-triggers-list" style="padding:0">
+              <div class="empty-state" style="padding:14px">No active failures &mdash; nothing has tripped 3+ consecutive errors.</div>
+            </div>
+          </div>
+          <div class="card" style="margin-top:16px">
+            <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
+              <span>Verifying fixes</span>
+              <span class="tab-badge" id="tab-si-verifying" style="display:none;background:#f59e0b;color:#000">0</span>
+            </div>
+            <div class="card-body" id="si-verifying-list" style="padding:0">
+              <div class="empty-state" style="padding:14px">No fixes currently soaking. Auto-fixes are verified over 3 runs and reverted if 0 succeed.</div>
+            </div>
+          </div>
           <div class="card" style="margin-top:16px">
             <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
               <span>Pending Proposals</span>
@@ -19109,7 +19160,20 @@ async function loadUserModel() {
       relationships: 'People, projects, channels they regularly interact with.',
       agent_persona: 'For multi-agent: this agent\\'s self-identity in its working relationship with the user.',
     };
+    // First-run hint: when every slot is empty, show a single explainer
+    // banner above the (still editable) textareas so the user understands
+    // both what this is and how to populate it. Suppressed once anything
+    // is in place — at that point the metadata on each card is enough.
+    var allEmpty = d.blocks.every(function(b) { return !(b.content || '').trim(); });
     var html = '<div style="display:flex;flex-direction:column;gap:14px">';
+    if (allEmpty) {
+      html += '<div class="card" style="padding:14px;border-left:3px solid var(--accent,#f59e0b);background:var(--bg-input,#1a1a1a)">' +
+        '<div style="font-weight:600;margin-bottom:6px">No core memory yet for this scope</div>' +
+        '<div style="font-size:12px;color:var(--text-secondary);line-height:1.5">' +
+          'These slots auto-populate as you chat — the agent extracts durable facts about you (your role, active goals, recurring people/projects) and appends them after each exchange. ' +
+          'You can also seed from existing memory in one click, or type directly into any slot below and click Save.' +
+        '</div></div>';
+    }
     for (var i = 0; i < d.blocks.length; i++) {
       var b = d.blocks[i];
       var label = labelMap[b.slot] || b.slot;
@@ -21291,6 +21355,7 @@ async function refreshMemoryHealth() {
       html += '<div style="flex:1;min-width:240px">';
       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 style="font-size:11px;color:var(--text-muted);margin-top:4px">Auto-backfill runs every 6h (~100 chunks/cycle). Use the buttons below to push faster.</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>';
@@ -24409,12 +24474,77 @@ async function refreshSelfImprove() {
     const state = d.state;
     const experiments = d.experiments || [];
     const pending = d.pending || [];
+    const triggers = d.triggers || [];
+    const verifications = d.verifications || [];
 
-    // Update tab badge
+    // Update tab badge — combine human-attention queues so the sidebar
+    // count reflects "things that need you to look at", not just proposals.
+    const attentionCount = pending.length + triggers.length;
     const badge = document.getElementById('nav-si-pending');
-    if (badge) badge.textContent = pending.length || '0';
+    if (badge) badge.textContent = attentionCount || '0';
     var _sib = document.getElementById('tab-si-pending');
     if (_sib) { _sib.textContent = pending.length || '0'; _sib.style.display = pending.length > 0 ? '' : 'none'; }
+    var _sit = document.getElementById('tab-si-triggers');
+    if (_sit) { _sit.textContent = triggers.length || '0'; _sit.style.display = triggers.length > 0 ? '' : 'none'; }
+    var _siv = document.getElementById('tab-si-verifying');
+    if (_siv) { _siv.textContent = verifications.length || '0'; _siv.style.display = verifications.length > 0 ? '' : 'none'; }
+
+    // Active failure triggers — jobs at 3+ consecutive errors; the loop
+    // will pick these up on its next tick (event-driven; ~2s debounce).
+    const triggersEl = document.getElementById('si-triggers-list');
+    if (triggersEl) {
+      if (triggers.length === 0) {
+        triggersEl.innerHTML = '<div class="empty-state" style="padding:14px">No active failures &mdash; nothing has tripped 3+ consecutive errors.</div>';
+      } else {
+        triggersEl.innerHTML = triggers.map(function(t) {
+          var owner = t.agentSlug ? '@' + esc(t.agentSlug) : 'global';
+          var when = t.triggeredAt ? new Date(t.triggeredAt).toLocaleString() : '—';
+          var firstError = (t.recentErrors && t.recentErrors[0]) ? String(t.recentErrors[0]).slice(0, 200) : '';
+          return '<div style="padding:12px;border-bottom:1px solid var(--border)">' +
+            '<div style="display:flex;justify-content:space-between;align-items:baseline;gap:8px;flex-wrap:wrap">' +
+              '<div><strong>' + esc(t.jobName || '—') + '</strong> ' +
+              '<span style="font-size:11px;color:var(--text-muted)">&middot; owner: ' + owner + '</span> ' +
+              '<span style="font-size:11px;color:var(--danger,#ef4444)">&middot; ' + (t.consecutiveErrors || 0) + ' consecutive errors</span></div>' +
+              '<span style="font-size:11px;color:var(--text-muted)">' + esc(when) + '</span>' +
+            '</div>' +
+            (firstError ? '<div style="margin-top:6px;font-size:12px;color:var(--text-secondary);font-family:ui-monospace,monospace">' + esc(firstError) + '</div>' : '') +
+          '</div>';
+        }).join('');
+      }
+    }
+
+    // Pending fix verifications — auto-fixes soaking through the 3-run window.
+    const verifyEl = document.getElementById('si-verifying-list');
+    if (verifyEl) {
+      if (verifications.length === 0) {
+        verifyEl.innerHTML = '<div class="empty-state" style="padding:14px">No fixes currently soaking. Auto-fixes are verified over 3 runs and reverted if 0 succeed.</div>';
+      } else {
+        verifyEl.innerHTML = verifications.map(function(v) {
+          var outcomes = v.postRunOutcomes || [];
+          var dots = '';
+          for (var i = 0; i < 3; i++) {
+            var o = outcomes[i];
+            var color = o === 'ok' ? 'var(--success,#10b981)' : o === 'error' || o === 'retried' ? 'var(--danger,#ef4444)' : 'var(--border)';
+            dots += '<span title="' + (o || 'pending') + '" style="display:inline-block;width:10px;height:10px;border-radius:50%;background:' + color + ';margin-right:4px"></span>';
+          }
+          var kind = v.autoApply && v.autoApply.kind ? v.autoApply.kind : 'hand-edit';
+          var when = v.recordedAt ? new Date(v.recordedAt).toLocaleString() : '—';
+          var fileLabel = v.autoApply && v.autoApply.file ? v.autoApply.file.split('/').slice(-3).join('/') : '';
+          return '<div style="padding:12px;border-bottom:1px solid var(--border)">' +
+            '<div style="display:flex;justify-content:space-between;align-items:baseline;gap:8px;flex-wrap:wrap">' +
+              '<div><strong>' + esc(v.jobName || '—') + '</strong> ' +
+              '<span style="font-size:11px;color:var(--text-muted)">&middot; ' + esc(kind) + '</span></div>' +
+              '<div style="font-size:11px;color:var(--text-muted)">' + esc(when) + '</div>' +
+            '</div>' +
+            '<div style="margin-top:8px;display:flex;align-items:center;gap:10px;font-size:12px;color:var(--text-secondary)">' +
+              '<span>' + dots + '</span>' +
+              '<span>' + outcomes.length + ' / 3 runs sampled</span>' +
+              (fileLabel ? '<span style="font-family:ui-monospace,monospace;color:var(--text-muted)">' + esc(fileLabel) + '</span>' : '') +
+            '</div>' +
+          '</div>';
+        }).join('');
+      }
+    }
 
     // Status cards
     const cards = document.getElementById('si-status-cards');

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/fix-verification.d.ts

@@ -26,9 +26,13 @@ interface PendingVerification {
 /**
  * Tracks an autoApply that's currently being verified. When the verdict
  * window closes negatively, revertFix() uses these fields to undo.
+ *
+ * - `advisor-rule` and `prompt-override` revert by deleting the written file.
+ * - `cron-config` reverts by re-applying the captured `prevFields` to the
+ *   named job inside CRON.md (deleting CRON.md would be catastrophic).
  */
 export interface AutoApplyTracker {
-    kind: 'advisor-rule' | 'prompt-override';
+    kind: 'advisor-rule' | 'prompt-override' | 'cron-config';
     /** Absolute path of the file the apply wrote. */
     file: string;
     /** advisor-rule only: the rule's id, used by the loader's hot-reload. */
@@ -36,6 +40,11 @@ export interface AutoApplyTracker {
     /** prompt-override only: scope label for the verdict message. */
     scope?: 'global' | 'agent' | 'job';
     scopeKey?: string;
+    /** cron-config only: bare job name as written in the CRON.md frontmatter. */
+    bareName?: string;
+    /** cron-config only: original values for the fields that were mutated.
+     * Use null for "field was absent (delete on revert)". */
+    prevFields?: Record<string, unknown>;
 }
 /**
  * Compare an old and new jobs list and record verifications for any job that:

package/dist/gateway/fix-verification.js

@@ -141,11 +141,19 @@ export function recordAutoApplyForVerification(jobName, tracker) {
     logger.info({ job: jobName, kind: tracker.kind, file: tracker.file }, 'Recorded autoApply for verification — will track next runs');
 }
 /**
- * Undo an autoApply by deleting the file the apply wrote. Best-effort:
- * a missing file is not an error (might have been hand-deleted). Returns
- * true if a file was actually removed.
+ * Undo an autoApply. Dispatches on `tracker.kind`:
+ *
+ *   - advisor-rule / prompt-override: delete the file the apply wrote.
+ *   - cron-config: re-apply the captured `prevFields` to the named job
+ *     in CRON.md (never delete CRON.md).
+ *
+ * Best-effort throughout: a missing file or vanished job is not an error.
+ * Returns true if a meaningful change was made.
  */
 function revertAutoApply(tracker) {
+    if (tracker.kind === 'cron-config') {
+        return revertCronConfig(tracker);
+    }
     try {
         if (existsSync(tracker.file)) {
             // Use unlinkSync from fs — kept dynamic to avoid a top-of-file import
@@ -161,6 +169,55 @@ function revertAutoApply(tracker) {
     }
     return false;
 }
+/**
+ * Restore the previous values of the fields the cron-config autoApply mutated.
+ * A `null` in `prevFields` means the field was absent before the fix and
+ * should be deleted on revert.
+ */
+function revertCronConfig(tracker) {
+    if (!tracker.bareName || !tracker.prevFields) {
+        logger.warn({ tracker }, 'cron-config revert missing bareName/prevFields — skipping');
+        return false;
+    }
+    try {
+        if (!existsSync(tracker.file)) {
+            logger.warn({ file: tracker.file }, 'cron-config revert: file missing — skipping');
+            return false;
+        }
+        const { readFileSync, writeFileSync } = require('node:fs');
+        const matter = require('gray-matter');
+        const raw = readFileSync(tracker.file, 'utf-8');
+        const parsed = matter(raw);
+        const jobs = (parsed.data.jobs ?? []);
+        const job = jobs.find((j) => String(j.name ?? '') === tracker.bareName);
+        if (!job) {
+            logger.warn({ file: tracker.file, bareName: tracker.bareName }, 'cron-config revert: job not found — already removed/renamed');
+            return false;
+        }
+        let mutated = false;
+        for (const [key, prev] of Object.entries(tracker.prevFields)) {
+            if (prev === null || prev === undefined) {
+                if (key in job) {
+                    delete job[key];
+                    mutated = true;
+                }
+            }
+            else if (job[key] !== prev) {
+                job[key] = prev;
+                mutated = true;
+            }
+        }
+        if (!mutated)
+            return false;
+        writeFileSync(tracker.file, matter.stringify(parsed.content, parsed.data));
+        logger.warn({ file: tracker.file, bareName: tracker.bareName }, 'Reverted cron-config autoApply — fix did not help');
+        return true;
+    }
+    catch (err) {
+        logger.warn({ err, file: tracker.file }, 'Failed to revert cron-config autoApply');
+        return false;
+    }
+}
 /**
  * After a cron run completes, check whether we were waiting on a fix
  * verification for this job. Two flows:

package/dist/memory/maintenance.d.ts

@@ -34,8 +34,14 @@ export declare function maybeVacuum(store: any): {
  */
 export declare function runStartupMaintenance(store: any): Promise<void>;
 /**
- * Start periodic maintenance on a 6-hour interval.
- * Returns the interval handle for cleanup on shutdown.
+ * Run one full periodic-maintenance cycle. Exported so tests can drive it
+ * without waiting on setInterval. `startPeriodicMaintenance` schedules
+ * this on the 6h cadence.
+ */
+export declare function runPeriodicCycle(store: any, llmCall?: (prompt: string) => Promise<string>): Promise<void>;
+/**
+ * Start periodic maintenance on a 6-hour interval. Returns the interval
+ * handle for cleanup on shutdown.
  */
 export declare function startPeriodicMaintenance(store: any, llmCall?: (prompt: string) => Promise<string>): ReturnType<typeof setInterval>;
 //# sourceMappingURL=maintenance.d.ts.map

package/dist/memory/maintenance.js

@@ -14,6 +14,16 @@ import { runIntegrityProbes } from './integrity.js';
 const logger = pino({ name: 'clementine.maintenance' });
 const PERIODIC_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const VACUUM_META_KEY = 'last_vacuum_at';
+/**
+ * Number of chunks to dense-embed per periodic cycle. With 4 cycles/day
+ * that's 400 chunks/day — fast enough to cover a 3,500-chunk vault in
+ * ~9 days, slow enough that the GPU/CPU load barely registers. Override
+ * via env for power users with very large vaults.
+ */
+const PERIODIC_DENSE_BATCH = (() => {
+    const raw = parseInt(process.env.CLEMENTINE_DENSE_BATCH ?? '', 10);
+    return Number.isFinite(raw) && raw > 0 ? raw : 100;
+})();
 /**
  * Janitor pass — keeps the store bounded. Safe to call repeatedly.
  * Idempotent within a single run; surfaces totals for logging.
@@ -155,104 +165,128 @@ export async function runStartupMaintenance(store) {
     logger.info({ durationMs: Date.now() - start }, 'Startup maintenance complete');
 }
 /**
- * Start periodic maintenance on a 6-hour interval.
- * Returns the interval handle for cleanup on shutdown.
+ * Run one full periodic-maintenance cycle. Exported so tests can drive it
+ * without waiting on setInterval. `startPeriodicMaintenance` schedules
+ * this on the 6h cadence.
  */
-export function startPeriodicMaintenance(store, llmCall) {
-    const runCycle = async () => {
-        const start = Date.now();
-        logger.info('Starting periodic memory maintenance');
-        // 1. Decay + prune
+export async function runPeriodicCycle(store, llmCall) {
+    const start = Date.now();
+    logger.info('Starting periodic memory maintenance');
+    // 1. Decay + prune
+    try {
+        store.decaySalience?.();
+    }
+    catch (err) {
+        logger.warn({ err }, 'Periodic decay failed');
+    }
+    try {
+        store.pruneStaleData?.();
+    }
+    catch (err) {
+        logger.warn({ err }, 'Periodic prune failed');
+    }
+    // 2. Rebuild vocab + backfill embeddings
+    try {
+        store.buildEmbeddings?.();
+    }
+    catch (err) {
+        logger.warn({ err }, 'Periodic embedding build failed');
+    }
+    // 2b. Idle dense-embedding backfill — process up to PERIODIC_DENSE_BATCH
+    // chunks per cycle so coverage drifts toward 100% without anyone running
+    // the CLI. The first time the dense model loads inside this process it
+    // pulls ~440MB; subsequent cycles reuse the loaded model. Failures
+    // (network, missing model dir, etc.) fall through silently because the
+    // backfill is best-effort — query-time still has TF-IDF as fallback.
+    if (typeof store.backfillDenseEmbeddings === 'function') {
         try {
-            store.decaySalience?.();
+            const result = await store.backfillDenseEmbeddings({ limit: PERIODIC_DENSE_BATCH });
+            if (result.embedded > 0) {
+                logger.info(result, 'Periodic dense embedding backfill');
+            }
         }
         catch (err) {
-            logger.warn({ err }, 'Periodic decay failed');
+            logger.warn({ err }, 'Periodic dense embedding backfill failed');
         }
+    }
+    // 3. Consolidation (dedup, summarize, extract principles)
+    if (llmCall) {
         try {
-            store.pruneStaleData?.();
+            const { runConsolidation } = await import('./consolidation.js');
+            const result = await runConsolidation(store, llmCall);
+            logger.info(result, 'Consolidation cycle complete');
         }
         catch (err) {
-            logger.warn({ err }, 'Periodic prune failed');
+            logger.warn({ err }, 'Consolidation failed');
         }
-        // 2. Rebuild vocab + backfill embeddings
+        // 4. Re-backfill embeddings for any new summary chunks from consolidation
         try {
             store.buildEmbeddings?.();
         }
         catch (err) {
-            logger.warn({ err }, 'Periodic embedding build failed');
-        }
-        // 3. Consolidation (dedup, summarize, extract principles)
-        if (llmCall) {
-            try {
-                const { runConsolidation } = await import('./consolidation.js');
-                const result = await runConsolidation(store, llmCall);
-                logger.info(result, 'Consolidation cycle complete');
-            }
-            catch (err) {
-                logger.warn({ err }, 'Consolidation failed');
-            }
-            // 4. Re-backfill embeddings for any new summary chunks from consolidation
-            try {
-                store.buildEmbeddings?.();
-            }
-            catch (err) {
-                logger.warn({ err }, 'Post-consolidation embedding build failed');
-            }
+            logger.warn({ err }, 'Post-consolidation embedding build failed');
         }
-        // 5. Extraction log pruning (legacy 90-day rule retained alongside cap)
-        try {
-            const conn = store.conn;
-            if (conn) {
-                conn.prepare(`DELETE FROM memory_extractions
+    }
+    // 5. Extraction log pruning (legacy 90-day rule retained alongside cap)
+    try {
+        const conn = store.conn;
+        if (conn) {
+            conn.prepare(`DELETE FROM memory_extractions
            WHERE extracted_at < datetime('now', '-90 days')
            AND status != 'active'`).run();
-            }
         }
-        catch { /* non-fatal */ }
-        // 6. Janitor — bounded growth.
-        try {
-            const result = runJanitor(store);
-            if (result.softDeleted || result.physicallyDeleted || result.outcomesPruned || result.extractionsCapped) {
-                logger.info(result, 'Janitor pass complete');
-            }
-        }
-        catch (err) {
-            logger.warn({ err }, 'Periodic janitor failed');
+    }
+    catch { /* non-fatal */ }
+    // 6. Janitor — bounded growth.
+    try {
+        const result = runJanitor(store);
+        if (result.softDeleted || result.physicallyDeleted || result.outcomesPruned || result.extractionsCapped) {
+            logger.info(result, 'Janitor pass complete');
         }
-        // 6b. Integrity probes — FTS health, orphan derived_from, embedding gaps.
+    }
+    catch (err) {
+        logger.warn({ err }, 'Periodic janitor failed');
+    }
+    // 6b. Integrity probes — FTS health, orphan derived_from, embedding gaps.
+    try {
+        const report = runIntegrityProbes(store);
+        // Persist for the dashboard so the "last integrity check" surface
+        // doesn't depend on log scraping.
         try {
-            const report = runIntegrityProbes(store);
-            // Persist for the dashboard so the "last integrity check" surface
-            // doesn't depend on log scraping.
-            try {
-                store.setMaintenanceMeta?.('last_integrity_report', JSON.stringify({ ...report, ranAt: new Date().toISOString() }));
-            }
-            catch { /* meta write is best-effort */ }
-            if (!report.ftsOk || report.ftsRebuilt || report.orphanRefsNulled > 0 || report.missingEmbeddings > 0) {
-                logger.info(report, 'Integrity probes complete');
-            }
+            store.setMaintenanceMeta?.('last_integrity_report', JSON.stringify({ ...report, ranAt: new Date().toISOString() }));
         }
-        catch (err) {
-            logger.warn({ err }, 'Integrity probes failed');
-        }
-        // 7. VACUUM — idle-gated, at most once per vacuumIntervalDays.
-        try {
-            const vac = maybeVacuum(store);
-            if (vac) {
-                logger.info({
-                    sizeBeforeBytes: vac.sizeBeforeBytes,
-                    sizeAfterBytes: vac.sizeAfterBytes,
-                    reclaimedBytes: vac.sizeBeforeBytes - vac.sizeAfterBytes,
-                    durationMs: vac.durationMs,
-                }, 'VACUUM complete');
-            }
+        catch { /* meta write is best-effort */ }
+        if (!report.ftsOk || report.ftsRebuilt || report.orphanRefsNulled > 0 || report.missingEmbeddings > 0) {
+            logger.info(report, 'Integrity probes complete');
         }
-        catch (err) {
-            logger.warn({ err }, 'Periodic VACUUM failed');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Integrity probes failed');
+    }
+    // 7. VACUUM — idle-gated, at most once per vacuumIntervalDays.
+    try {
+        const vac = maybeVacuum(store);
+        if (vac) {
+            logger.info({
+                sizeBeforeBytes: vac.sizeBeforeBytes,
+                sizeAfterBytes: vac.sizeAfterBytes,
+                reclaimedBytes: vac.sizeBeforeBytes - vac.sizeAfterBytes,
+                durationMs: vac.durationMs,
+            }, 'VACUUM complete');
         }
-        logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
-    };
-    return setInterval(runCycle, PERIODIC_INTERVAL_MS);
+    }
+    catch (err) {
+        logger.warn({ err }, 'Periodic VACUUM failed');
+    }
+    logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
+}
+/**
+ * Start periodic maintenance on a 6-hour interval. Returns the interval
+ * handle for cleanup on shutdown.
+ */
+export function startPeriodicMaintenance(store, llmCall) {
+    return setInterval(() => {
+        runPeriodicCycle(store, llmCall).catch(err => logger.warn({ err }, 'Periodic maintenance cycle threw — continuing'));
+    }, PERIODIC_INTERVAL_MS);
 }
 //# sourceMappingURL=maintenance.js.map

package/dist/memory/store.d.ts

@@ -1040,6 +1040,31 @@ export declare class MemoryStore {
      * skill retrieved in that session. Window: last 60 days.
      */
     getSkillsToSuppress(agentSlug?: string): Set<string>;
+    /**
+     * Get a compact "recent feedback signal" snapshot for prompt injection.
+     * Closes the feedback → behavior loop: the agent sees the last week's
+     * negative pattern in its system prompt instead of feedback being
+     * write-only.
+     *
+     * - `negative` / `positive`: counts in the window
+     * - `negativesWithComments`: up to `limit` most recent negatives that
+     *   carry a non-empty comment (these are the actionable ones — silent
+     *   👎 reactions don't tell the agent what to fix)
+     * - `behavioralChannel` is excluded because behavioral-corrections are
+     *   already pushed to hotCorrections directly
+     */
+    getRecentFeedbackSignals(opts?: {
+        days?: number;
+        limit?: number;
+    }): {
+        negative: number;
+        positive: number;
+        negativesWithComments: Array<{
+            comment: string;
+            channel: string;
+            createdAt: string;
+        }>;
+    };
     /**
      * Get aggregate feedback statistics.
      */

package/dist/memory/store.js

@@ -3995,6 +3995,62 @@ export class MemoryStore {
         }
         return suppressed;
     }
+    /**
+     * Get a compact "recent feedback signal" snapshot for prompt injection.
+     * Closes the feedback → behavior loop: the agent sees the last week's
+     * negative pattern in its system prompt instead of feedback being
+     * write-only.
+     *
+     * - `negative` / `positive`: counts in the window
+     * - `negativesWithComments`: up to `limit` most recent negatives that
+     *   carry a non-empty comment (these are the actionable ones — silent
+     *   👎 reactions don't tell the agent what to fix)
+     * - `behavioralChannel` is excluded because behavioral-corrections are
+     *   already pushed to hotCorrections directly
+     */
+    getRecentFeedbackSignals(opts = {}) {
+        const days = Math.max(1, opts.days ?? 14);
+        const limit = Math.max(1, Math.min(opts.limit ?? 3, 10));
+        const since = `datetime('now', '-${days} days')`;
+        let negative = 0;
+        let positive = 0;
+        let negativesWithComments = [];
+        try {
+            const rows = this.conn
+                .prepare(`SELECT rating, COUNT(*) as cnt FROM feedback
+           WHERE created_at >= ${since}
+             AND channel != 'behavioral-correction'
+             AND channel != 'preference-learned'
+           GROUP BY rating`)
+                .all();
+            for (const row of rows) {
+                if (row.rating === 'negative')
+                    negative = row.cnt;
+                else if (row.rating === 'positive')
+                    positive = row.cnt;
+            }
+            const commented = this.conn
+                .prepare(`SELECT comment, channel, created_at
+           FROM feedback
+           WHERE rating = 'negative'
+             AND comment IS NOT NULL
+             AND TRIM(comment) != ''
+             AND channel != 'behavioral-correction'
+             AND created_at >= ${since}
+           ORDER BY created_at DESC, id DESC
+           LIMIT ?`)
+                .all(limit);
+            negativesWithComments = commented.map((r) => ({
+                comment: r.comment,
+                channel: r.channel,
+                createdAt: r.created_at,
+            }));
+        }
+        catch {
+            // Empty / legacy schema — return zeros
+        }
+        return { negative, positive, negativesWithComments };
+    }
     /**
      * Get aggregate feedback statistics.
      */

package/package.json

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