clementine-agent 1.0.20 → 1.0.21

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,67 @@
+/**
+ * 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.
+ */
+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'>[];
+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

package/dist/gateway/claim-tracker.js

@@ -0,0 +1,351 @@
+/**
+ * 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 { randomBytes } from 'node:crypto';
+import path from 'node:path';
+import pino from 'pino';
+import { BASE_DIR, MEMORY_DB_PATH, VAULT_DIR } from '../config.js';
+const logger = pino({ name: 'clementine.claim-tracker' });
+/**
+ * Parse common time expressions into an absolute ISO timestamp.
+ * Intentionally narrow — only handles shapes we're confident about.
+ * Returns null for "soon", "later", "in a bit" type phrases.
+ */
+function parseDueAt(expr, now = new Date()) {
+    const s = expr.trim().toLowerCase();
+    // "tomorrow at 8am" / "tomorrow at 8:30 am" / "tomorrow at 5pm"
+    const tomorrowRe = /^tomorrow(?:\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm))?$/;
+    const tm = s.match(tomorrowRe);
+    if (tm) {
+        const d = new Date(now);
+        d.setDate(d.getDate() + 1);
+        if (tm[1]) {
+            let h = Number(tm[1]);
+            const min = Number(tm[2] ?? '0');
+            if (tm[3] === 'pm' && h < 12)
+                h += 12;
+            if (tm[3] === 'am' && h === 12)
+                h = 0;
+            d.setHours(h, min, 0, 0);
+        }
+        else {
+            d.setHours(9, 0, 0, 0); // default to 9am if no specific time
+        }
+        return d.toISOString();
+    }
+    // "at 8am" / "at 4:30pm" / "8am" — today, roll to tomorrow if past
+    const todayRe = /^(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/;
+    const today = s.match(todayRe);
+    if (today) {
+        const d = new Date(now);
+        let h = Number(today[1]);
+        const min = Number(today[2] ?? '0');
+        if (today[3] === 'pm' && h < 12)
+            h += 12;
+        if (today[3] === 'am' && h === 12)
+            h = 0;
+        d.setHours(h, min, 0, 0);
+        if (d.getTime() < now.getTime())
+            d.setDate(d.getDate() + 1); // next occurrence
+        return d.toISOString();
+    }
+    // "in 30 minutes" / "in 2 hours"
+    const relRe = /^in\s+(\d+)\s*(min(?:ute)?s?|hours?|hrs?)$/;
+    const rel = s.match(relRe);
+    if (rel) {
+        const n = Number(rel[1]);
+        const unit = rel[2];
+        const ms = unit.startsWith('min') ? n * 60_000 : n * 3_600_000;
+        return new Date(now.getTime() + ms).toISOString();
+    }
+    return null;
+}
+const PATTERNS = [
+    // "I scheduled market-leader-followup for tomorrow at 8:30am"
+    // "I've scheduled the reply-detection job for 8am tomorrow"
+    // "Scheduled the X for tomorrow at 9am"
+    {
+        type: 'scheduled',
+        re: /(?:I(?:'ve|\s+have)?\s+)?scheduled\s+(?:the\s+)?(\S[^,.!?\n]+?)(?:\s+job)?\s+(?:for|at|on)\s+([^,.!?\n]+)/i,
+        extract: (m) => {
+            const subject = m[1].trim().slice(0, 200);
+            const due = parseDueAt(m[2].trim());
+            return due ? { subject, dueAt: due } : { subject };
+        },
+        verifyStrategy: 'cron_run_check',
+    },
+    // "I fixed X" / "Fixed Y" / "I've applied the fix"
+    // Ambiguous. We look for short, declarative "fixed <noun phrase>" at the
+    // start of a sentence or after a period.
+    {
+        type: 'fixed',
+        re: /(?:^|[.!?]\s+)(?:I(?:'ve|\s+have)?\s+)?(?:fixed|resolved|applied\s+the\s+fix\s+for)\s+([\w-][\w\s:-]{2,80})/i,
+        extract: (m) => ({ subject: m[1].trim().slice(0, 200) }),
+        verifyStrategy: 'config_inspect',
+    },
+    // "I'll send the email at 4pm" / "I will run X tomorrow morning"
+    // Must have a time anchor to be meaningful.
+    {
+        type: 'will_do',
+        re: /\bI(?:'ll|\s+will)\s+(\w+\s+\S[^,.!?\n]{0,80}?)\s+(?:at|by|in|on|tomorrow|today)\s+([^,.!?\n]+)/i,
+        extract: (m) => {
+            const subject = m[1].trim().slice(0, 200);
+            const due = parseDueAt(m[2].trim());
+            return due ? { subject, dueAt: due } : { subject };
+        },
+        verifyStrategy: 'manual',
+    },
+    // "Sent email to X" / "I sent the email to..."
+    {
+        type: 'sent',
+        re: /(?:^|[.!?]\s+)(?:I(?:'ve|\s+have)?\s+)?sent\s+(?:an?\s+|the\s+)?(email|message|DM|notification)\s+to\s+([^,.!?\n]{2,80})/i,
+        extract: (m) => ({ subject: `${m[1]} to ${m[2].trim()}`.slice(0, 200) }),
+        verifyStrategy: 'manual',
+    },
+];
+/**
+ * Extract claims from a message. Returns empty array if nothing matched.
+ * Caller supplies sessionKey for traceability. Never throws.
+ */
+export function extractClaims(text, sessionKey, agentSlug) {
+    if (!text || typeof text !== 'string')
+        return [];
+    // Skip fix-verification DMs we emit ourselves — those are meta-claims that
+    // would re-enter this pipeline and create infinite loops.
+    if (text.startsWith('**[Fix verification]**'))
+        return [];
+    if (text.startsWith('🚨 **') && text.includes('cron job') && text.includes('failing'))
+        return [];
+    if (text.startsWith('⚡ **Circuit breaker') || text.startsWith('✅ **Circuit breaker'))
+        return [];
+    if (text.startsWith('🛑 **Cron auto-disabled**'))
+        return [];
+    const out = [];
+    const seenSubjects = new Set();
+    for (const p of PATTERNS) {
+        const m = text.match(p.re);
+        if (!m)
+            continue;
+        const extracted = p.extract(m);
+        if (!extracted)
+            continue;
+        // De-dup within a single message (two patterns hitting the same text)
+        const key = `${p.type}:${extracted.subject.toLowerCase()}`;
+        if (seenSubjects.has(key))
+            continue;
+        seenSubjects.add(key);
+        out.push({
+            id: randomBytes(6).toString('hex'),
+            sessionKey: sessionKey ?? null,
+            messageSnippet: text.slice(0, 400),
+            claimType: p.type,
+            subject: extracted.subject,
+            dueAt: extracted.dueAt ?? null,
+            verifyStrategy: p.verifyStrategy,
+            agentSlug: agentSlug ?? null,
+        });
+    }
+    return out;
+}
+// ── Persistence ──────────────────────────────────────────────────────
+async function getStore() {
+    const { MemoryStore } = await import('../memory/store.js');
+    const store = new MemoryStore(MEMORY_DB_PATH, VAULT_DIR);
+    store.initialize();
+    return store;
+}
+export async function recordClaims(claims) {
+    if (claims.length === 0)
+        return;
+    try {
+        const store = await getStore();
+        const db = store.conn;
+        const stmt = db.prepare(`INSERT OR IGNORE INTO claims
+       (id, session_key, message_snippet, claim_type, subject, due_at, verify_strategy, status, agent_slug)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)`);
+        const tx = db.transaction((rows) => {
+            for (const c of rows) {
+                stmt.run(c.id, c.sessionKey, c.messageSnippet, c.claimType, c.subject, c.dueAt, c.verifyStrategy, c.agentSlug);
+            }
+        });
+        tx(claims);
+        store.close();
+        logger.info({ count: claims.length, types: claims.map(c => c.claimType) }, 'Recorded claims');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to record claims');
+    }
+}
+export async function listClaims(opts = {}) {
+    try {
+        const store = await getStore();
+        const db = store.conn;
+        const where = [];
+        const params = [];
+        if (opts.status) {
+            where.push('status = ?');
+            params.push(opts.status);
+        }
+        if (opts.sinceHours) {
+            where.push(`extracted_at >= datetime('now', ?)`);
+            params.push(`-${opts.sinceHours} hours`);
+        }
+        const sql = `SELECT id, session_key AS sessionKey, message_snippet AS messageSnippet, claim_type AS claimType,
+                        subject, due_at AS dueAt, verify_strategy AS verifyStrategy, status, verdict,
+                        extracted_at AS extractedAt, verified_at AS verifiedAt, agent_slug AS agentSlug
+                 FROM claims
+                 ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
+                 ORDER BY extracted_at DESC
+                 LIMIT ?`;
+        params.push(opts.limit ?? 50);
+        const rows = db.prepare(sql).all(...params);
+        store.close();
+        return rows;
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to list claims');
+        return [];
+    }
+}
+export async function setClaimStatus(id, status, verdict) {
+    try {
+        const store = await getStore();
+        const db = store.conn;
+        const result = db.prepare(`UPDATE claims SET status = ?, verdict = ?, verified_at = datetime('now') WHERE id = ?`).run(status, verdict ?? null, id);
+        store.close();
+        return result.changes > 0;
+    }
+    catch (err) {
+        logger.warn({ err, id }, 'Failed to set claim status');
+        return false;
+    }
+}
+/**
+ * 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 async function trustScore(lastN = 30) {
+    try {
+        const store = await getStore();
+        const db = store.conn;
+        const rows = db.prepare(`SELECT status FROM claims
+       WHERE status IN ('verified', 'failed')
+       ORDER BY extracted_at DESC
+       LIMIT ?`).all(lastN);
+        store.close();
+        const verified = rows.filter(r => r.status === 'verified').length;
+        const failed = rows.filter(r => r.status === 'failed').length;
+        const total = verified + failed;
+        if (total < 3)
+            return { score: null, verified, failed, total };
+        return { score: verified / total, verified, failed, total };
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to compute trust score');
+        return null;
+    }
+}
+// ── Auto-verification ────────────────────────────────────────────────
+/**
+ * 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 async function verifyDueClaims(now = Date.now()) {
+    const pending = await listClaims({ status: 'pending', limit: 100 });
+    let verified = 0;
+    let failed = 0;
+    let expired = 0;
+    for (const c of pending) {
+        // Only verify claims whose due time has passed
+        if (c.dueAt) {
+            const dueMs = Date.parse(c.dueAt);
+            if (Number.isFinite(dueMs) && dueMs > now)
+                continue;
+        }
+        else {
+            // Claims without due_at: give them 24h grace period then mark expired
+            const extractedMs = Date.parse(c.extractedAt);
+            if (Number.isFinite(extractedMs) && now - extractedMs > 24 * 3600_000 && c.verifyStrategy === 'manual') {
+                await setClaimStatus(c.id, 'expired', 'No due time set and 24h elapsed — no automatic verification available.');
+                expired++;
+                continue;
+            }
+            continue; // still in grace period
+        }
+        if (c.verifyStrategy === 'cron_run_check') {
+            const verdict = await verifyCronScheduledClaim(c, now);
+            if (verdict === 'verified') {
+                await setClaimStatus(c.id, 'verified', 'Run observed at or after due time.');
+                verified++;
+            }
+            else if (verdict === 'failed') {
+                await setClaimStatus(c.id, 'failed', 'No run observed after due time (gave 1h grace).');
+                failed++;
+            }
+            // null = not ready yet, leave pending
+        }
+        // Other strategies: left pending for manual verification
+    }
+    return { verified, failed, expired };
+}
+/**
+ * For a "scheduled" claim, check the cron run log. If an entry exists
+ * at or after due_at, claim is verified. If >1h past due with no run,
+ * it's failed. If not yet time or within grace, null.
+ */
+async function verifyCronScheduledClaim(claim, now) {
+    if (!claim.dueAt)
+        return null;
+    const dueMs = Date.parse(claim.dueAt);
+    if (!Number.isFinite(dueMs))
+        return null;
+    const graceMs = 60 * 60 * 1000; // 1h grace window
+    if (now < dueMs + 60_000)
+        return null; // not yet time
+    // Derive the job name from the subject. The subject is free-text from the
+    // DM, so we match permissively against known job names in cron/runs/.
+    const { existsSync, readdirSync, readFileSync } = await import('node:fs');
+    const runsDir = path.join(BASE_DIR, 'cron', 'runs');
+    if (!existsSync(runsDir))
+        return now > dueMs + graceMs ? 'failed' : null;
+    const subjectLower = claim.subject.toLowerCase();
+    const files = readdirSync(runsDir).filter(f => f.endsWith('.jsonl'));
+    for (const file of files) {
+        const bare = file.replace(/\.jsonl$/, '').replace(/_/g, '-').toLowerCase();
+        // Match if subject contains the job name or vice versa
+        if (!subjectLower.includes(bare) && !bare.includes(subjectLower.split(/\s+/)[0]))
+            continue;
+        try {
+            const lines = readFileSync(path.join(runsDir, file), 'utf-8').trim().split('\n').filter(Boolean);
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const entry = JSON.parse(lines[i]);
+                const ms = Date.parse(entry.startedAt);
+                if (Number.isFinite(ms) && ms >= dueMs && ms <= dueMs + graceMs) {
+                    // Found a run in the due window
+                    return entry.status === 'ok' ? 'verified' : 'failed';
+                }
+                if (ms < dueMs)
+                    break; // older than due — no point scanning further back
+            }
+        }
+        catch { /* skip malformed */ }
+    }
+    // No matching run found within grace window
+    return now > dueMs + graceMs ? 'failed' : null;
+}
+//# sourceMappingURL=claim-tracker.js.map

package/dist/gateway/heartbeat-scheduler.js

@@ -112,6 +112,15 @@ export class HeartbeatScheduler {
                 logger.warn({ err }, 'Failure sweep failed');
             });
         }).catch(err => logger.warn({ err }, 'Failure sweep import failed'));
+        // Claim verification sweep — auto-verify pending claims whose due
+        // times have passed (e.g. "I scheduled X for 8am" → check at 9am).
+        import('./claim-tracker.js').then(({ verifyDueClaims }) => {
+            verifyDueClaims().then(({ verified, failed, expired }) => {
+                if (verified + failed + expired > 0) {
+                    logger.info({ verified, failed, expired }, 'Claim verification sweep complete');
+                }
+            }).catch(err => logger.warn({ err }, 'Claim verification sweep failed'));
+        }).catch(err => logger.warn({ err }, 'Claim tracker import failed'));
         const now = new Date();
         const hour = now.getHours();
         // ── Nightly tasks: run regardless of active hours ─────────────────

package/dist/gateway/notifications.d.ts

@@ -23,6 +23,7 @@ export declare class NotificationDispatcher {
     send(text: string, context?: NotificationContext): Promise<SendResult>;
     /** Direct send without retry queueing (used by retry queue itself). */
     private sendDirect;
+    private _trackClaims;
     /** Stop the retry queue timer (for graceful shutdown). */
     shutdown(): void;
 }

package/dist/gateway/notifications.js

@@ -90,8 +90,24 @@ export class NotificationDispatcher {
                 logger.error({ err, channel: name }, `Failed to send notification via ${name}`);
             }
         }
+        // Extract and persist claims from successfully-delivered messages.
+        // Fire-and-forget — extraction errors never block delivery.
+        if (anySuccess) {
+            void this._trackClaims(capped, context);
+        }
         return { delivered: anySuccess, channelErrors };
     }
+    async _trackClaims(text, context) {
+        try {
+            const { extractClaims, recordClaims } = await import('./claim-tracker.js');
+            const claims = extractClaims(text, context?.sessionKey ?? null, context?.agentSlug ?? null);
+            if (claims.length > 0)
+                await recordClaims(claims);
+        }
+        catch (err) {
+            logger.debug({ err }, 'Claim extraction failed (non-fatal)');
+        }
+    }
     /** Stop the retry queue timer (for graceful shutdown). */
     shutdown() {
         this._retryQueue.stop();

package/dist/memory/store.js

@@ -418,6 +418,24 @@ export class MemoryStore {
       );
       CREATE INDEX IF NOT EXISTS idx_skill_usage_name ON skill_usage(skill_name, retrieved_at DESC);
       CREATE INDEX IF NOT EXISTS idx_skill_usage_time ON skill_usage(retrieved_at DESC);
+
+      CREATE TABLE IF NOT EXISTS claims (
+        id TEXT PRIMARY KEY,
+        session_key TEXT,
+        message_snippet TEXT NOT NULL,
+        claim_type TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        due_at TEXT,
+        verify_strategy TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        verdict TEXT,
+        extracted_at TEXT NOT NULL DEFAULT (datetime('now')),
+        verified_at TEXT,
+        agent_slug TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_claims_status ON claims(status, extracted_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_claims_due ON claims(due_at) WHERE status = 'pending';
+      CREATE INDEX IF NOT EXISTS idx_claims_extracted ON claims(extracted_at DESC);
     `);
     }
     // ── Skill usage telemetry ─────────────────────────────────────────

package/package.json

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