clementine-agent 1.0.20 → 1.0.22

package/dist/agent/self-improve.js

@@ -611,63 +611,108 @@ export class SelfImproveLoop {
     async hypothesize(metrics, history) {
         // Read targeted triggers (written by cron scheduler when jobs fail repeatedly)
         let targetedTriggers = '';
+        const triggerBullets = [];
+        // Source 1: explicit triggers written by the cron scheduler at 3+
+        // consecutive errors (legacy path — we still honor and drain).
         const triggersDir = path.join(SELF_IMPROVE_DIR, 'triggers');
         if (existsSync(triggersDir)) {
             const triggerFiles = readdirSync(triggersDir).filter(f => f.endsWith('.json'));
-            if (triggerFiles.length > 0) {
-                const triggers = triggerFiles.slice(0, 3).map(f => {
-                    try {
-                        const t = JSON.parse(readFileSync(path.join(triggersDir, f), 'utf-8'));
-                        // Clean up trigger after reading
-                        unlinkSync(path.join(triggersDir, f));
-                        return t;
-                    }
-                    catch {
-                        return null;
-                    }
-                }).filter(Boolean);
-                if (triggers.length > 0) {
-                    targetedTriggers = `\n\n## PRIORITY: Failing Jobs Needing Attention\n` +
-                        `These jobs have been failing repeatedly and need prompt/config fixes:\n` +
-                        triggers.map((t) => `- **${t.jobName}**: ${t.consecutiveErrors} consecutive errors. Recent: ${(t.recentErrors ?? []).join('; ')}`).join('\n') +
-                        `\n\nFocus your improvement hypothesis on fixing these jobs first.\n`;
+            const triggers = triggerFiles.slice(0, 3).map(f => {
+                try {
+                    const t = JSON.parse(readFileSync(path.join(triggersDir, f), 'utf-8'));
+                    unlinkSync(path.join(triggersDir, f));
+                    return t;
+                }
+                catch {
+                    return null;
                 }
+            }).filter(Boolean);
+            for (const t of triggers) {
+                triggerBullets.push(`- **${t.jobName}**: ${t.consecutiveErrors} consecutive errors. Recent: ${(t.recentErrors ?? []).join('; ')}`);
             }
         }
+        // Source 2: broken-jobs from the failure monitor. These are jobs the
+        // user hasn't applied a fix for yet — real, current gaps the hypothesizer
+        // should target. Complements the diversity constraint: even if the area
+        // has been over-targeted historically, a specific broken job is a fresh
+        // concrete signal.
+        try {
+            const { computeBrokenJobs } = await import('../gateway/failure-monitor.js');
+            const broken = computeBrokenJobs();
+            for (const b of broken.slice(0, 3)) {
+                const diagHint = b.diagnosis
+                    ? ` Diagnosis: ${b.diagnosis.rootCause.slice(0, 120)}`
+                    : '';
+                triggerBullets.push(`- **${b.jobName}**: ${b.errorCount48h}/${b.totalRuns48h} failed in 48h${b.circuitBreakerEngagedAt ? ' (breaker engaged)' : ''}.${diagHint}`);
+            }
+        }
+        catch { /* failure-monitor module optional */ }
+        if (triggerBullets.length > 0) {
+            targetedTriggers = `\n\n## PRIORITY: Failing Jobs Needing Attention\n` +
+                `These jobs have been failing recently and need prompt/config fixes:\n` +
+                triggerBullets.join('\n') +
+                `\n\nFocus your improvement hypothesis on fixing these jobs first.\n`;
+        }
         // Format experiment history for the prompt
         const historyText = history.slice(-20).map(e => `#${e.iteration} | ${e.area} | "${e.hypothesis.slice(0, 60)}" | ${(e.score * 10).toFixed(1)}/10 ${e.accepted ? '✅' : '❌'}`).join('\n') || '(no prior experiments)';
-        // Enforce diversity: count recent proposals per area:target AND per area
+        // Enforce diversity: count recent proposals per area:target AND per area.
+        // A pair is only "over-targeted" if its MOST RECENT attempt was within
+        // the last 30 days — otherwise it's fair game to retry with fresh data.
+        // Stops the saturation state where after ~60 experiments the loop has
+        // blocked every area:target pair permanently and produces no new
+        // hypotheses (the Apr 11-19 plateau).
+        const DIVERSITY_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+        const diversityCutoff = Date.now() - DIVERSITY_WINDOW_MS;
         const recentTargets = new Map();
         const recentAreas = new Map();
-        for (const e of history.slice(-10)) {
+        for (const e of history.slice(-50)) {
             const key = `${e.area}:${e.target}`;
-            recentTargets.set(key, (recentTargets.get(key) ?? 0) + 1);
-            recentAreas.set(e.area, (recentAreas.get(e.area) ?? 0) + 1);
+            const ts = Date.parse(e.startedAt);
+            const tsMs = Number.isFinite(ts) ? ts : 0;
+            const cur = recentTargets.get(key);
+            recentTargets.set(key, {
+                count: (cur?.count ?? 0) + 1,
+                newestMs: Math.max(cur?.newestMs ?? 0, tsMs),
+            });
+            const curA = recentAreas.get(e.area);
+            recentAreas.set(e.area, {
+                count: (curA?.count ?? 0) + 1,
+                newestMs: Math.max(curA?.newestMs ?? 0, tsMs),
+            });
         }
         for (const p of this.getPendingChanges()) {
             const key = `${p.area}:${p.target}`;
-            recentTargets.set(key, (recentTargets.get(key) ?? 0) + 1);
-            recentAreas.set(p.area, (recentAreas.get(p.area) ?? 0) + 1);
+            const now = Date.now();
+            const cur = recentTargets.get(key);
+            recentTargets.set(key, {
+                count: (cur?.count ?? 0) + 1,
+                newestMs: Math.max(cur?.newestMs ?? 0, now),
+            });
+            const curA = recentAreas.get(p.area);
+            recentAreas.set(p.area, {
+                count: (curA?.count ?? 0) + 1,
+                newestMs: Math.max(curA?.newestMs ?? 0, now),
+            });
         }
-        // Block area:target pairs with >= 2 recent proposals
+        // Block only when both (a) count is high enough AND (b) the last attempt
+        // was within the diversity window.
         const overTargeted = [...recentTargets.entries()]
-            .filter(([, count]) => count >= 2)
+            .filter(([, v]) => v.count >= 2 && v.newestMs > diversityCutoff)
             .map(([key]) => key);
-        // Block entire areas with >= 3 recent proposals
         const overTargetedAreas = [...recentAreas.entries()]
-            .filter(([, count]) => count >= 3)
+            .filter(([, v]) => v.count >= 3 && v.newestMs > diversityCutoff)
             .map(([area]) => area);
         // Build area coverage stats to nudge the LLM toward unexplored areas
         const allAreas = this.config.areas;
         const areaCoverage = allAreas.map(area => {
-            const count = recentAreas.get(area) ?? 0;
+            const count = recentAreas.get(area)?.count ?? 0;
             return `- ${area}: ${count} recent proposals`;
         }).join('\n');
         const diversityConstraint = `\n\n## AREA COVERAGE (target under-explored areas)\n${areaCoverage}\n` +
             (overTargeted.length > 0 || overTargetedAreas.length > 0
                 ? `\n## DIVERSITY CONSTRAINT\n` +
                     (overTargetedAreas.length > 0
-                        ? `These AREAS have been over-targeted and MUST NOT be chosen:\n${overTargetedAreas.map(a => `- ${a} (${recentAreas.get(a)} proposals)`).join('\n')}\n`
+                        ? `These AREAS have been over-targeted and MUST NOT be chosen:\n${overTargetedAreas.map(a => `- ${a} (${recentAreas.get(a)?.count ?? 0} proposals)`).join('\n')}\n`
                         : '') +
                     (overTargeted.length > 0
                         ? `These specific targets MUST NOT be re-targeted:\n${overTargeted.map(t => `- ${t}`).join('\n')}\n`

package/dist/cli/dashboard.js

@@ -2075,6 +2075,58 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ error: String(err) });
         }
     });
+    // ── Claims + trust score ────────────────────────────────────────
+    app.get('/api/claims', async (req, res) => {
+        try {
+            const { listClaims, trustScore } = await import('../gateway/claim-tracker.js');
+            const status = req.query.status;
+            const limit = Number(req.query.limit ?? 50);
+            const sinceHours = req.query.sinceHours ? Number(req.query.sinceHours) : undefined;
+            const validStatus = ['pending', 'verified', 'failed', 'expired', 'dismissed'];
+            const claims = await listClaims({
+                ...(status && validStatus.includes(status) ? { status: status } : {}),
+                limit: Number.isFinite(limit) ? limit : 50,
+                ...(sinceHours && Number.isFinite(sinceHours) ? { sinceHours } : {}),
+            });
+            const trust = await trustScore(30);
+            res.json({ claims, trust });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/claims/:id/mark-verified', async (req, res) => {
+        try {
+            const { setClaimStatus } = await import('../gateway/claim-tracker.js');
+            const verdict = typeof req.body?.verdict === 'string' ? req.body.verdict.slice(0, 400) : 'Manually verified by owner';
+            const ok = await setClaimStatus(req.params.id, 'verified', verdict);
+            res.json({ ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/claims/:id/mark-failed', async (req, res) => {
+        try {
+            const { setClaimStatus } = await import('../gateway/claim-tracker.js');
+            const verdict = typeof req.body?.verdict === 'string' ? req.body.verdict.slice(0, 400) : 'Manually marked as failed by owner';
+            const ok = await setClaimStatus(req.params.id, 'failed', verdict);
+            res.json({ ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/claims/:id/dismiss', async (req, res) => {
+        try {
+            const { setClaimStatus } = await import('../gateway/claim-tracker.js');
+            const ok = await setClaimStatus(req.params.id, 'dismissed', 'Dismissed — not a tracked promise');
+            res.json({ ok });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
     // ── Broken jobs (failure monitor) ───────────────────────────────
     app.get('/api/cron/broken-jobs', async (_req, res) => {
         try {
@@ -8903,6 +8955,10 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
       <div class="nav-item" data-page="intelligence">
         <span class="nav-icon">&#129504;</span> Intelligence
       </div>
+      <div class="nav-item" data-page="claims">
+        <span class="nav-icon">&#128274;</span> Trust &amp; Claims
+        <span class="nav-badge" id="nav-trust-score" style="display:none">--</span>
+      </div>
       <div class="nav-item" data-page="logs">
         <span class="nav-icon">&#128220;</span> Logs
       </div>
@@ -9337,6 +9393,32 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
       <div id="panel-sessions"><div class="empty-state">Loading...</div></div>
     </div>
 
+    <!-- ═══ Trust & Claims Page ═══ -->
+    <div class="page" id="page-claims">
+      <div class="page-title">Trust &amp; Claims</div>
+      <div class="card" style="margin-bottom:16px">
+        <div class="card-body" style="display:flex;align-items:center;gap:16px;padding:16px">
+          <div style="font-size:36px;font-weight:700" id="trust-score-big">--</div>
+          <div style="flex:1">
+            <div style="font-size:13px;font-weight:600">Clementine's trust score</div>
+            <div style="font-size:11px;color:var(--text-muted)" id="trust-score-detail">
+              Rolling over the last 30 verified or failed claims.
+            </div>
+          </div>
+          <div style="display:flex;gap:6px">
+            <button class="btn-sm" onclick="refreshClaims('all')" id="claims-filter-all" style="padding:4px 10px">All</button>
+            <button class="btn-sm" onclick="refreshClaims('pending')" id="claims-filter-pending" style="padding:4px 10px">Pending</button>
+            <button class="btn-sm" onclick="refreshClaims('verified')" id="claims-filter-verified" style="padding:4px 10px">Verified</button>
+            <button class="btn-sm" onclick="refreshClaims('failed')" id="claims-filter-failed" style="padding:4px 10px">Failed</button>
+          </div>
+        </div>
+      </div>
+      <div class="card">
+        <div class="card-header">Recent claims</div>
+        <div class="card-body" id="panel-claims"><div class="empty-state">Loading...</div></div>
+      </div>
+    </div>
+
     <!-- ═══ Logs Page ═══ -->
     <div class="page" id="page-logs">
       <div class="page-title">Logs</div>
@@ -10376,6 +10458,7 @@ function navigateTo(page, opts) {
     document.getElementById('builder-input').focus();
   }
   if (page === 'automations') { refreshCron(); refreshTimers(); refreshSelfImprove(); refreshSkills(); refreshBrokenJobs(); }
+  if (page === 'claims') { refreshClaims(); }
   if (page === 'intelligence') { refreshMemory(); }
   if (page === 'settings') { refreshSettings(); refreshRemoteAccess(); refreshSalesforce(); refreshClaudeIntegrations(); refreshMcpServers(); }
   if (page === 'logs') refreshLogs();
@@ -16210,6 +16293,129 @@ async function expandSkill(name) {
   } catch(e) { toast('Failed to load skill', 'error'); }
 }
 
+// ── Trust & Claims ────────────────────────
+var _claimsFilter = 'all';
+
+function formatTrustScore(trust) {
+  if (!trust) return { big: '--', detail: 'No claims recorded yet.' };
+  if (trust.score === null) {
+    return {
+      big: trust.total === 0 ? '--' : String(trust.total),
+      detail: trust.total === 0
+        ? 'No verified or failed claims yet. Score activates after 3+ verdicts.'
+        : 'Only ' + trust.total + ' verdict' + (trust.total === 1 ? '' : 's') + ' so far \u2014 score activates at 3+.',
+    };
+  }
+  var pct = Math.round(trust.score * 100);
+  return {
+    big: pct + '%',
+    detail: trust.verified + ' verified, ' + trust.failed + ' failed over last ' + trust.total + ' judged claims.',
+  };
+}
+
+async function refreshClaims(filter) {
+  if (filter && filter !== _claimsFilter) _claimsFilter = filter;
+  try {
+    var url = '/api/claims?limit=100';
+    if (_claimsFilter && _claimsFilter !== 'all') url += '&status=' + encodeURIComponent(_claimsFilter);
+    var r = await apiFetch(url);
+    var d = await r.json();
+
+    // Trust score
+    var t = formatTrustScore(d.trust);
+    var big = document.getElementById('trust-score-big');
+    var detail = document.getElementById('trust-score-detail');
+    if (big) big.textContent = t.big;
+    if (detail) detail.textContent = t.detail;
+    var navBadge = document.getElementById('nav-trust-score');
+    if (navBadge) {
+      if (d.trust && d.trust.score !== null) {
+        navBadge.textContent = Math.round(d.trust.score * 100) + '%';
+        navBadge.style.display = '';
+      } else {
+        navBadge.style.display = 'none';
+      }
+    }
+
+    // Filter-button highlighting
+    ['all', 'pending', 'verified', 'failed'].forEach(function(k) {
+      var btn = document.getElementById('claims-filter-' + k);
+      if (!btn) return;
+      if (k === _claimsFilter) {
+        btn.style.background = 'var(--accent)';
+        btn.style.color = 'white';
+        btn.style.border = '1px solid var(--accent)';
+      } else {
+        btn.style.background = 'var(--bg-tertiary)';
+        btn.style.color = 'var(--text-primary)';
+        btn.style.border = '1px solid var(--border)';
+      }
+    });
+
+    var claims = d.claims || [];
+    var container = document.getElementById('panel-claims');
+    if (!container) return;
+    if (claims.length === 0) {
+      container.innerHTML = '<div class="empty-state">No claims in this view.</div>';
+      return;
+    }
+
+    var statusColor = {
+      pending: '#f59e0b',
+      verified: '#22c55e',
+      failed: '#ef4444',
+      expired: '#6b7280',
+      dismissed: '#6b7280',
+    };
+
+    var html = '<div style="display:flex;flex-direction:column;gap:8px">';
+    for (var c of claims) {
+      var color = statusColor[c.status] || '#6b7280';
+      var due = c.dueAt ? ' \u00b7 due ' + timeAgo(c.dueAt) : '';
+      var ver = c.verifiedAt ? ' \u00b7 verdict ' + timeAgo(c.verifiedAt) : '';
+      var actions = c.status === 'pending'
+        ? '<span style="margin-left:auto;display:flex;gap:4px">'
+          + '<button onclick="markClaim(\\x27' + esc(c.id) + '\\x27,\\x27verified\\x27)" style="background:none;border:1px solid var(--border);border-radius:3px;padding:2px 8px;font-size:11px;color:#22c55e;cursor:pointer">Verified</button>'
+          + '<button onclick="markClaim(\\x27' + esc(c.id) + '\\x27,\\x27failed\\x27)" style="background:none;border:1px solid var(--border);border-radius:3px;padding:2px 8px;font-size:11px;color:#ef4444;cursor:pointer">Failed</button>'
+          + '<button onclick="markClaim(\\x27' + esc(c.id) + '\\x27,\\x27dismissed\\x27)" style="background:none;border:1px solid var(--border);border-radius:3px;padding:2px 8px;font-size:11px;color:var(--text-muted);cursor:pointer">Dismiss</button>'
+          + '</span>'
+        : '';
+      var verdictLine = c.verdict ? '<div style="font-size:11px;color:var(--text-muted);margin-top:4px;font-style:italic">\u201c' + esc(c.verdict) + '\u201d</div>' : '';
+      html += '<div style="padding:10px;border:1px solid var(--border);border-left:3px solid ' + color + ';border-radius:6px;background:var(--bg-secondary)">'
+        + '<div style="display:flex;align-items:center;gap:8px;flex-wrap:wrap">'
+        + '<span style="font-size:10px;padding:1px 6px;background:' + color + '33;color:' + color + ';border-radius:3px;text-transform:uppercase;letter-spacing:0.5px">' + esc(c.status) + '</span>'
+        + '<span style="font-size:10px;color:var(--text-muted)">' + esc(c.claimType) + '</span>'
+        + '<strong style="font-size:13px">' + esc(c.subject) + '</strong>'
+        + '<span style="font-size:10px;color:var(--text-muted);margin-left:auto">' + timeAgo(c.extractedAt) + due + ver + '</span>'
+        + '</div>'
+        + '<div style="font-size:11px;color:var(--text-secondary);margin-top:6px">' + esc(c.messageSnippet.slice(0, 300)) + '</div>'
+        + verdictLine
+        + actions
+        + '</div>';
+    }
+    html += '</div>';
+    container.innerHTML = html;
+  } catch (e) {
+    var c = document.getElementById('panel-claims');
+    if (c) c.innerHTML = '<div class="empty-state" style="color:var(--red)">Failed to load claims</div>';
+  }
+}
+
+async function markClaim(id, status) {
+  var endpoint = status === 'verified' ? 'mark-verified' : status === 'failed' ? 'mark-failed' : 'dismiss';
+  try {
+    var res = await apiJson('POST', '/api/claims/' + encodeURIComponent(id) + '/' + endpoint, {});
+    if (res && res.ok) {
+      toast('Claim marked ' + status, 'success');
+      refreshClaims();
+    } else {
+      toast('Failed to update claim', 'error');
+    }
+  } catch (e) {
+    toast('Error: ' + String(e), 'error');
+  }
+}
+
 async function applyBrokenJobFix(jobName) {
   try {
     // First: dry-run to get the actual diff to show in the confirm dialog
@@ -17903,6 +18109,17 @@ async function refreshSalesforce() {
     refreshAll();
     refreshTeamNav();
   }
+  // Lightweight trust-score fetch for the nav badge (any page benefits from this)
+  try {
+    var tr = await apiFetch('/api/claims?limit=1');
+    var td = await tr.json();
+    var navBadge = document.getElementById('nav-trust-score');
+    if (navBadge && td && td.trust && td.trust.score !== null) {
+      navBadge.textContent = Math.round(td.trust.score * 100) + '%';
+      navBadge.style.display = '';
+    }
+  } catch(e) { /* non-fatal */ }
+
   // Populate agent filter from init data (avoid separate /api/office call)
   if (d && d.office) {
     try {

package/dist/gateway/claim-tracker.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Clementine TypeScript — Claim tracking.
+ *
+ * Every outbound DM passes through the notification dispatcher. This
+ * module parses those messages for claims Clementine makes (promises,
+ * fixes, scheduled actions) and persists them to a SQLite table so we
+ * can verify them later and compute a rolling trust score.
+ *
+ * The bluntest answer to "you told me you fixed it twice and it wasn't
+ * fixed" — every claim is now recorded, some auto-verified, all
+ * reviewable in the dashboard.
+ *
+ * Extraction is regex-only to keep cost at $0 per DM. For nuanced
+ * claims the dashboard's manual verify/fail path covers the gap.
+ */
+import type { Gateway } from './router.js';
+export type ClaimType = 'scheduled' | 'fixed' | 'will_do' | 'sent' | 'added' | 'unknown';
+export type VerifyStrategy = 'cron_run_check' | 'config_inspect' | 'manual';
+export type ClaimStatus = 'pending' | 'verified' | 'failed' | 'expired' | 'dismissed';
+export interface Claim {
+    id: string;
+    sessionKey: string | null;
+    messageSnippet: string;
+    claimType: ClaimType;
+    subject: string;
+    dueAt: string | null;
+    verifyStrategy: VerifyStrategy;
+    status: ClaimStatus;
+    verdict: string | null;
+    extractedAt: string;
+    verifiedAt: string | null;
+    agentSlug: string | null;
+}
+/**
+ * Extract claims from a message. Returns empty array if nothing matched.
+ * Caller supplies sessionKey for traceability. Never throws.
+ */
+export declare function extractClaims(text: string, sessionKey?: string | null, agentSlug?: string | null): Omit<Claim, 'status' | 'extractedAt' | 'verifiedAt' | 'verdict'>[];
+/**
+ * Drain the LLM-fallback queue: pick up to N enqueued DMs, ask Haiku
+ * to extract claims via the same shape the regex patterns use, persist
+ * any found. Best-effort — errors just leave the queue unchanged for
+ * the next sweep.
+ */
+export declare function drainLLMFallback(gateway: Gateway, maxPerSweep?: number): Promise<number>;
+export declare function recordClaims(claims: Omit<Claim, 'status' | 'extractedAt' | 'verifiedAt' | 'verdict'>[]): Promise<void>;
+export declare function listClaims(opts?: {
+    status?: ClaimStatus;
+    limit?: number;
+    sinceHours?: number;
+}): Promise<Claim[]>;
+export declare function setClaimStatus(id: string, status: ClaimStatus, verdict?: string): Promise<boolean>;
+/**
+ * Rolling trust score over the last N verified-or-failed claims.
+ * Ignores 'pending', 'expired', and 'dismissed' — only signal from
+ * actual verdicts. Returns null when there's not enough data (<3
+ * judged claims) to be meaningful.
+ */
+export declare function trustScore(lastN?: number): Promise<{
+    score: number | null;
+    verified: number;
+    failed: number;
+    total: number;
+} | null>;
+/**
+ * Sweep pending claims whose due_at has passed and try to verify them.
+ * Returns count of claims verified/failed. Safe to call repeatedly —
+ * only processes pending claims.
+ */
+export declare function verifyDueClaims(now?: number): Promise<{
+    verified: number;
+    failed: number;
+    expired: number;
+}>;
+//# sourceMappingURL=claim-tracker.d.ts.map