clementine-agent 1.8.1 → 1.9.0

package/dist/agent/assistant.js

@@ -1340,6 +1340,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 {

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

@@ -48,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

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

@@ -55,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') {
@@ -201,17 +202,26 @@ function loadCronJob(trigger, cronPath, agentsDir) {
 /**
  * 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.
+ * 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;
+        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;
+        return null;
     const updated = matter.stringify(lookup.parsed.content, lookup.parsed.data);
     writeFileSync(lookup.cronPath, updated);
-    return true;
+    return prevFields;
 }
 function writePendingChange(record, dir) {
     mkdirSync(dir, { recursive: true });
@@ -370,9 +380,25 @@ export class SelfImproveLoop {
                 logger.warn({ jobName: trigger.jobName, agentSlug }, 'Job not found in any CRON.md — cannot apply fix');
                 return;
             }
-            const applied = applyCronEdit(lookup, recipe);
-            if (applied) {
+            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`';
@@ -381,7 +407,7 @@ export class SelfImproveLoop {
                     '',
                     recipe.description,
                     '',
-                    `Edit applied to ${where}. 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 {

package/dist/cli/browser.d.ts

@@ -32,5 +32,24 @@ export declare function cmdBrowserEnable(): Promise<void>;
  */
 export declare function maybePromptBrowserHarness(): Promise<void>;
 export declare function cmdBrowserDisable(): Promise<void>;
+/**
+ * Non-interactive connect — meant for callers that aren't a TTY (MCP tool,
+ * daemon-internal callers). Returns a structured result instead of prompting
+ * or printing decorative output. Caller decides how to surface failures.
+ *
+ * Behavior:
+ *   - CDP already up → { ok: true, alreadyConnected: true }
+ *   - No Chrome running → launch with flag, poll, return result
+ *   - Chrome running without flag → if allowQuitChrome=false, refuse with
+ *     a clear message; if true, quit + relaunch (DESTRUCTIVE — closes tabs).
+ */
+export declare function runConnectNonInteractive(opts?: {
+    allowQuitChrome?: boolean;
+}): Promise<{
+    ok: boolean;
+    message: string;
+    alreadyConnected?: boolean;
+    needsForceQuit?: boolean;
+}>;
 export declare function cmdBrowserConnect(): Promise<void>;
 //# sourceMappingURL=browser.d.ts.map

package/dist/cli/browser.js

@@ -354,11 +354,85 @@ export async function cmdBrowserDisable() {
     console.log();
 }
 /**
- * Core connect logic — quits any running Chrome and relaunches with
- * --remote-debugging-port=9222 so browser-harness can connect.
+ * Non-interactive connect — meant for callers that aren't a TTY (MCP tool,
+ * daemon-internal callers). Returns a structured result instead of prompting
+ * or printing decorative output. Caller decides how to surface failures.
  *
- * Returns true when CDP is reachable on :9222 at the end, false otherwise.
- * Never calls process.exit so it's safe to call from the auto-prompt flow.
+ * Behavior:
+ *   - CDP already up → { ok: true, alreadyConnected: true }
+ *   - No Chrome running → launch with flag, poll, return result
+ *   - Chrome running without flag → if allowQuitChrome=false, refuse with
+ *     a clear message; if true, quit + relaunch (DESTRUCTIVE — closes tabs).
+ */
+export async function runConnectNonInteractive(opts = {}) {
+    if (await probeCdp()) {
+        return { ok: true, alreadyConnected: true, message: 'Already connected — Chrome is running with remote debugging on :9222.' };
+    }
+    if (process.platform !== 'darwin' && process.platform !== 'linux') {
+        return {
+            ok: false,
+            message: 'Auto-connect is only supported on macOS and Linux. Launch Chrome manually with --remote-debugging-port=9222.',
+        };
+    }
+    if (isChromeRunning() && !opts.allowQuitChrome) {
+        return {
+            ok: false,
+            needsForceQuit: true,
+            message: 'Chrome is running without remote debugging. Connecting requires quitting Chrome and relaunching with --remote-debugging-port=9222 (this closes your current Chrome windows). Re-run with force_quit=true to proceed, or quit Chrome yourself first and call this again.',
+        };
+    }
+    if (isChromeRunning() && opts.allowQuitChrome) {
+        try {
+            if (process.platform === 'darwin') {
+                execSync('osascript -e \'tell application "Google Chrome" to quit\'', { stdio: 'pipe' });
+            }
+            else {
+                try {
+                    execSync('pkill -TERM -x "google-chrome|chromium|chrome"', { stdio: 'pipe' });
+                }
+                catch { /* ok */ }
+            }
+            for (let i = 0; i < 15; i++) {
+                if (!isChromeRunning())
+                    break;
+                await new Promise(r => setTimeout(r, 300));
+            }
+        }
+        catch {
+            return { ok: false, message: 'Failed to quit Chrome. Quit it manually and try again.' };
+        }
+    }
+    try {
+        if (process.platform === 'darwin') {
+            execSync('open -na "Google Chrome" --args --remote-debugging-port=9222', { stdio: 'pipe' });
+        }
+        else {
+            const candidates = ['google-chrome', 'chromium', 'chrome'];
+            const bin = candidates.find(commandExists);
+            if (!bin) {
+                return { ok: false, message: 'No Chrome / Chromium binary found in PATH.' };
+            }
+            execSync(`nohup ${bin} --remote-debugging-port=9222 >/dev/null 2>&1 &`, { stdio: 'pipe' });
+        }
+    }
+    catch (e) {
+        return { ok: false, message: `Failed to launch Chrome: ${String(e).slice(0, 200)}` };
+    }
+    for (let i = 0; i < 24; i++) {
+        await new Promise(r => setTimeout(r, 250));
+        if (await probeCdp()) {
+            return { ok: true, message: 'Connected — Chrome is running with remote debugging on :9222.' };
+        }
+    }
+    return {
+        ok: false,
+        message: 'Chrome launched, but CDP socket isn\'t responding yet. Check that Chrome started successfully, then verify with: curl http://localhost:9222/json/version',
+    };
+}
+/**
+ * Interactive CLI connect — wraps runConnectNonInteractive with TTY prompts
+ * and decorative output. Used by `clementine browser connect` and the auto-
+ * prompt flow.
  */
 async function runConnect(opts = {}) {
     // 1. Already connected? Done.

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 {
@@ -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>
@@ -21291,6 +21342,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 +24461,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/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/dist/tools/admin-tools.js

@@ -1873,5 +1873,13 @@ export function registerAdminTools(server) {
         logger.info({ jobName: job_name, runCount: updated.runCount }, 'Cron progress saved');
         return textResult(`Progress saved for "${job_name}" (run #${updated.runCount}). ${(completedItems?.length ?? 0)} items completed, ${(updated.pendingItems?.length ?? 0)} pending.`);
     });
+    // ── Browser harness — chat-driven Chrome connect ────────────────────
+    server.tool('browser_connect', 'Connect Chrome to the browser harness via CDP. Idempotent — if Chrome is already running with remote debugging on :9222 this is a no-op. If no Chrome is running, launches Chrome with --remote-debugging-port=9222. If Chrome is running normally without the flag, refuses unless force_quit=true (which closes the user\'s open tabs). Use this so the user can connect from any chat channel without dropping to the terminal.', {
+        force_quit: z.boolean().optional().describe('If true, quit any running Chrome before relaunching with the debug flag. DESTRUCTIVE — closes the user\'s open tabs. Only set after the user has explicitly confirmed they want this. Defaults to false.'),
+    }, async ({ force_quit }) => {
+        const { runConnectNonInteractive } = await import('../cli/browser.js');
+        const result = await runConnectNonInteractive({ allowQuitChrome: !!force_quit });
+        return textResult(result.message);
+    });
 }
 //# sourceMappingURL=admin-tools.js.map

package/package.json

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