clementine-agent 1.0.21 → 1.0.23

package/dist/agent/complexity-classifier.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Clementine TypeScript — Lightweight complexity classifier.
+ *
+ * Deterministic regex + length heuristics that decide whether a user
+ * message is "complex" enough to warrant planning-before-acting. No
+ * LLM call — gate is cheap enough to run on every message.
+ *
+ * When complex, the gateway injects a "plan-first" system-prompt
+ * directive so the agent proposes a numbered plan and waits for
+ * confirmation before diving in. Not perfect — the LLM still decides
+ * what "plan" means — but much more consistent than a generic
+ * SOUL.md directive that the model ignores half the time.
+ */
+export interface ComplexityVerdict {
+    complex: boolean;
+    reason: string;
+    signals: string[];
+}
+/**
+ * Classify complexity. Pure function — no LLM, no I/O.
+ */
+export declare function classifyComplexity(text: string): ComplexityVerdict;
+/**
+ * Build a system-prompt directive to inject when a complex message is
+ * detected. Prepended to Clementine's normal system prompt for this
+ * single query only. Short + declarative — meta-instructions are
+ * easier for the model to follow when they're terse.
+ */
+export declare function planFirstDirective(): string;
+//# sourceMappingURL=complexity-classifier.d.ts.map

package/dist/agent/complexity-classifier.js

@@ -0,0 +1,153 @@
+/**
+ * Clementine TypeScript — Lightweight complexity classifier.
+ *
+ * Deterministic regex + length heuristics that decide whether a user
+ * message is "complex" enough to warrant planning-before-acting. No
+ * LLM call — gate is cheap enough to run on every message.
+ *
+ * When complex, the gateway injects a "plan-first" system-prompt
+ * directive so the agent proposes a numbered plan and waits for
+ * confirmation before diving in. Not perfect — the LLM still decides
+ * what "plan" means — but much more consistent than a generic
+ * SOUL.md directive that the model ignores half the time.
+ */
+/**
+ * Action verbs that signal the user is asking Clementine to DO things
+ * (as opposed to asking questions or making small talk). Multiple
+ * action verbs in one message is a strong complexity signal.
+ */
+const ACTION_VERBS = [
+    'send', 'create', 'run', 'schedule', 'update', 'delete', 'add', 'remove',
+    'draft', 'write', 'post', 'publish', 'deploy', 'build', 'edit', 'move',
+    'rename', 'archive', 'restore', 'assign', 'delegate', 'email', 'message',
+    'invite', 'book', 'cancel', 'notify', 'alert', 'set up', 'tear down',
+    'process', 'review', 'approve', 'reject',
+    'extract', 'fetch', 'pull', 'gather', 'compile', 'summarize', 'analyze',
+    'generate', 'produce', 'export', 'import', 'upload', 'download', 'sync',
+];
+/**
+ * Chain markers — "do X and then Y" explicitly encode a multi-step
+ * task. A single occurrence in a DO-type message is a clear signal.
+ */
+const CHAIN_MARKERS = [
+    /\band\s+then\b/i,
+    /,\s+then\b/i, // "X, then Y"
+    /\bfirst\b[\s\S]{0,80}\bthen\b/i,
+    /\bafter\s+(that|which)\b/i,
+    /\bonce\s+(that|you)\b.*,/i,
+    /\bnext\b.*,/i,
+];
+/**
+ * Phrasings that explicitly ask for plan-first behavior. Triggers
+ * regardless of other heuristics.
+ */
+const EXPLICIT_PLAN_ASKS = [
+    /\bpropose\s+a\s+plan\b/i,
+    /\bwhat\s+(would|'d)\s+be\s+your\s+approach\b/i,
+    /\bplan\s+(this|it)\s+out\b/i,
+    /\blay\s+out\s+(a|the)\s+plan\b/i,
+    /\bwalk\s+me\s+through\s+(what|how)\b/i,
+];
+function countActionVerbs(text) {
+    const lower = text.toLowerCase();
+    let count = 0;
+    for (const v of ACTION_VERBS) {
+        const re = new RegExp(`\\b${v.replace(/\s+/g, '\\s+')}\\b`, 'g');
+        const matches = lower.match(re);
+        if (matches)
+            count += matches.length;
+    }
+    return count;
+}
+/**
+ * Rough entity count — quoted strings, @mentions, and capitalized
+ * multi-word phrases that look like proper nouns. Not perfect;
+ * designed to catch cases like "email John, Sarah, and Mike".
+ */
+function countEntities(text) {
+    let count = 0;
+    // Quoted strings
+    count += (text.match(/"[^"]{2,60}"/g) ?? []).length;
+    count += (text.match(/'[^']{2,60}'/g) ?? []).length;
+    // @mentions
+    count += (text.match(/@\w+/g) ?? []).length;
+    // Comma-separated name lists (e.g., "John, Sarah, and Mike")
+    const listMatch = text.match(/(?:[A-Z][a-z]{1,20},\s+){2,}(?:and\s+)?[A-Z][a-z]{1,20}/);
+    if (listMatch)
+        count += 3;
+    return count;
+}
+/**
+ * Classify complexity. Pure function — no LLM, no I/O.
+ */
+export function classifyComplexity(text) {
+    if (!text || typeof text !== 'string')
+        return { complex: false, reason: 'empty', signals: [] };
+    const trimmed = text.trim();
+    // Skip commands and very short messages
+    if (trimmed.length < 30)
+        return { complex: false, reason: 'too short', signals: [] };
+    if (trimmed.startsWith('!') || trimmed.startsWith('/'))
+        return { complex: false, reason: 'command', signals: [] };
+    const signals = [];
+    // Signal 1: explicit ask for plan-first
+    for (const re of EXPLICIT_PLAN_ASKS) {
+        if (re.test(trimmed)) {
+            return { complex: true, reason: 'user explicitly asked for a plan', signals: ['explicit-plan-ask'] };
+        }
+    }
+    // Signal 2: multiple action verbs
+    const verbs = countActionVerbs(trimmed);
+    if (verbs >= 3)
+        signals.push(`${verbs} action verbs`);
+    // Signal 3: chain markers
+    for (const re of CHAIN_MARKERS) {
+        if (re.test(trimmed)) {
+            signals.push('chain marker');
+            break;
+        }
+    }
+    // Signal 4: multiple entities
+    const entities = countEntities(trimmed);
+    if (entities >= 3)
+        signals.push(`${entities} entities`);
+    // Signal 5: long message with at least one action verb (big scope, not just a question)
+    if (trimmed.length > 400 && verbs >= 1)
+        signals.push('long + action');
+    // Gate: at least 2 signals fire, OR a single high-confidence signal
+    // (chain markers, explicit-plan-ask, or 3+ action verbs).
+    const highConfidenceSingles = [
+        verbs >= 3,
+        signals.includes('chain marker'),
+    ];
+    if (highConfidenceSingles.some(Boolean)) {
+        return { complex: true, reason: 'strong single signal', signals };
+    }
+    if (signals.length >= 2) {
+        return { complex: true, reason: 'multiple signals', signals };
+    }
+    return { complex: false, reason: 'below threshold', signals };
+}
+/**
+ * Build a system-prompt directive to inject when a complex message is
+ * detected. Prepended to Clementine's normal system prompt for this
+ * single query only. Short + declarative — meta-instructions are
+ * easier for the model to follow when they're terse.
+ */
+export function planFirstDirective() {
+    return [
+        '## PLAN BEFORE ACTING',
+        '',
+        'This request has multiple steps. Before doing any of them:',
+        '1. Write a numbered plan (3-7 steps, one line each).',
+        '2. Call out anything that needs my decision — which contact, which template, which timing.',
+        '3. End with: "Reply **go** to start, or tell me what to change."',
+        '4. STOP. Do NOT start executing the plan in this turn.',
+        '',
+        'When I reply "go" (or equivalent) in the next message, proceed with the plan.',
+        'If I edit the plan, revise and ask again.',
+        '',
+        'SKIP this protocol only if the request is actually a single step disguised as multiple (e.g., "send an email to Aaron about X and cc Sarah" is one email, not two).',
+    ].join('\n');
+}
+//# sourceMappingURL=complexity-classifier.js.map

package/dist/agent/insight-engine.js

@@ -168,6 +168,48 @@ export function gatherInsightSignals(gateway) {
         }
     }
     catch { /* non-fatal */ }
+    // 5. Broken jobs from the failure monitor. Any currently-flagged job
+    //    with a diagnosis is a real, actionable signal the owner should
+    //    see proactively rather than stumble across in the dashboard.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fm = require('../gateway/failure-monitor.js');
+        const broken = fm.computeBrokenJobs();
+        for (const b of broken.slice(0, 3)) {
+            const hint = b.diagnosis?.rootCause
+                ? ` — ${b.diagnosis.rootCause.slice(0, 120)}`
+                : '';
+            signals.push(`Broken cron job "${b.jobName}": ${b.errorCount48h}/${b.totalRuns48h} failures${hint}`);
+            if (b.diagnosis?.proposedFix?.autoApply) {
+                signals.push(`One-click fix available for "${b.jobName}" — ${b.diagnosis.proposedFix.details.slice(0, 100)}`);
+            }
+        }
+    }
+    catch { /* failure-monitor may not be loadable; fine */ }
+    // 6. Claim tracker — failed claims in the last N hours erode trust.
+    //    Surface them so the owner sees "Clementine said she'd do X; she
+    //    didn't" instead of silently swallowing the miss.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { MemoryStore } = require('../memory/store.js');
+        const { MEMORY_DB_PATH, VAULT_DIR } = require('../config.js');
+        if (existsSync(MEMORY_DB_PATH)) {
+            const store = new MemoryStore(MEMORY_DB_PATH, VAULT_DIR);
+            store.initialize();
+            const db = store.conn;
+            try {
+                const rows = db.prepare(`SELECT subject, claim_type FROM claims
+           WHERE status = 'failed' AND verified_at >= datetime('now', '-6 hours')
+           ORDER BY verified_at DESC LIMIT 3`).all();
+                for (const r of rows) {
+                    signals.push(`Failed claim: "${r.subject}" (${r.claim_type}) — I promised and didn't deliver`);
+                }
+            }
+            catch { /* table may not exist */ }
+            store.close();
+        }
+    }
+    catch { /* non-fatal */ }
     return signals;
 }
 /**

package/dist/agent/route-classifier.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Clementine TypeScript — Team-routing classifier.
+ *
+ * Decides whether a user message addressed to Clementine should be
+ * delegated to a specialist agent (Ross, Sasha, Nora, etc.) or handled
+ * by Clementine herself.
+ *
+ * CRITICAL safety rail: this classifier is ONLY invoked when the user
+ * is talking TO Clementine. Direct-to-agent messages (agent bot DMs,
+ * agent-scoped channels) bypass routing entirely — the session-key
+ * ownership check in gateway/router.ts enforces this before calling
+ * classifyRoute. Routing never crosses the boundary between different
+ * agent bots.
+ *
+ * Returns structured decision: {targetAgent, confidence, reasoning}.
+ * Caller decides what to do with confidence (auto-delegate, soft-suggest,
+ * or stay with Clementine).
+ */
+import type { AgentProfile } from '../types.js';
+import type { Gateway } from '../gateway/router.js';
+export interface RouteDecision {
+    targetAgent: string;
+    confidence: number;
+    reasoning: string;
+}
+/**
+ * Session keys eligible for routing. Any key NOT in this set is
+ * considered agent-scoped or system-scoped and never routes.
+ *
+ * - `discord:user:{ownerId}` — main bot DM with owner
+ * - `discord:channel:{channelId}:{ownerId}` — owner's main channel
+ *   (where Clementine's main bot is posted, without an agent slug
+ *   embedded in the key)
+ * - `slack:user:{userId}` / `slack:dm:{userId}` — Slack DM/owner channel
+ * - `dashboard:*` — web dashboard chat
+ * - `cli:*` — local CLI chat
+ *
+ * Rejected prefixes (routing NEVER fires):
+ * - `discord:agent:{slug}:*` — direct-to-agent DM
+ * - `discord:member:*`, `discord:member-dm:*` — member channels/DMs
+ * - Any `discord:channel:{channelId}:{slug}:{userId}` with an agent slug
+ *   embedded (5-part form, where position 3 is an agent slug)
+ * - `slack:agent:*`, `slack:channel:*:{slug}:*`
+ * - `team:*` — inter-agent messages travel via team-bus, never route
+ */
+export declare function isRoutable(sessionKey: string, ownerAgentSlugs: Set<string>): boolean;
+/**
+ * Classify a user message. Returns null if the call fails — caller
+ * should fall back to Clementine handling.
+ */
+export declare function classifyRoute(userMessage: string, agents: AgentProfile[], gateway: Gateway): Promise<RouteDecision | null>;
+//# sourceMappingURL=route-classifier.d.ts.map

package/dist/agent/route-classifier.js

@@ -0,0 +1,197 @@
+/**
+ * Clementine TypeScript — Team-routing classifier.
+ *
+ * Decides whether a user message addressed to Clementine should be
+ * delegated to a specialist agent (Ross, Sasha, Nora, etc.) or handled
+ * by Clementine herself.
+ *
+ * CRITICAL safety rail: this classifier is ONLY invoked when the user
+ * is talking TO Clementine. Direct-to-agent messages (agent bot DMs,
+ * agent-scoped channels) bypass routing entirely — the session-key
+ * ownership check in gateway/router.ts enforces this before calling
+ * classifyRoute. Routing never crosses the boundary between different
+ * agent bots.
+ *
+ * Returns structured decision: {targetAgent, confidence, reasoning}.
+ * Caller decides what to do with confidence (auto-delegate, soft-suggest,
+ * or stay with Clementine).
+ */
+import pino from 'pino';
+const logger = pino({ name: 'clementine.route-classifier' });
+/**
+ * Session keys eligible for routing. Any key NOT in this set is
+ * considered agent-scoped or system-scoped and never routes.
+ *
+ * - `discord:user:{ownerId}` — main bot DM with owner
+ * - `discord:channel:{channelId}:{ownerId}` — owner's main channel
+ *   (where Clementine's main bot is posted, without an agent slug
+ *   embedded in the key)
+ * - `slack:user:{userId}` / `slack:dm:{userId}` — Slack DM/owner channel
+ * - `dashboard:*` — web dashboard chat
+ * - `cli:*` — local CLI chat
+ *
+ * Rejected prefixes (routing NEVER fires):
+ * - `discord:agent:{slug}:*` — direct-to-agent DM
+ * - `discord:member:*`, `discord:member-dm:*` — member channels/DMs
+ * - Any `discord:channel:{channelId}:{slug}:{userId}` with an agent slug
+ *   embedded (5-part form, where position 3 is an agent slug)
+ * - `slack:agent:*`, `slack:channel:*:{slug}:*`
+ * - `team:*` — inter-agent messages travel via team-bus, never route
+ */
+export function isRoutable(sessionKey, ownerAgentSlugs) {
+    if (!sessionKey)
+        return false;
+    const parts = sessionKey.split(':');
+    // Agent-bot DMs and member sessions are always agent-scoped
+    if (parts[0] === 'discord') {
+        const kind = parts[1];
+        if (kind === 'agent' || kind === 'member' || kind === 'member-dm')
+            return false;
+        // 5-part discord:channel:{channelId}:{slug}:{userId} means agent in team chat
+        if (kind === 'channel' && parts.length >= 5 && ownerAgentSlugs.has(parts[3] ?? '')) {
+            return false;
+        }
+        // discord:user:* and the 4-part discord:channel:{channelId}:{userId} pass
+        return kind === 'user' || kind === 'channel';
+    }
+    if (parts[0] === 'slack') {
+        const kind = parts[1];
+        if (kind === 'agent')
+            return false;
+        // slack:channel:{channelId}:{slug}:{userId} — agent-scoped
+        if (kind === 'channel' && parts.length >= 5 && ownerAgentSlugs.has(parts[3] ?? '')) {
+            return false;
+        }
+        return kind === 'user' || kind === 'dm' || kind === 'channel';
+    }
+    if (parts[0] === 'telegram')
+        return parts[1] === 'user' || /^\d+$/.test(parts[1] ?? '');
+    if (parts[0] === 'dashboard')
+        return true;
+    if (parts[0] === 'cli')
+        return true;
+    // Anything else (team:*, cron:*, heartbeat-triggered, etc.) — no routing
+    return false;
+}
+/** Build the agent roster string for the classifier prompt. */
+function formatAgentRoster(agents) {
+    const lines = [];
+    // Clementine is always an option — the "stay with me" target
+    lines.push('- **clementine**: generalist assistant, calendar/inbox/planning, meta questions, small talk, anything not clearly a specialist task');
+    for (const a of agents) {
+        if (a.slug === 'clementine')
+            continue;
+        // Use name + description; truncate to keep the prompt tight
+        const desc = (a.description ?? '').slice(0, 200).replace(/\s+/g, ' ').trim();
+        lines.push(`- **${a.slug}** (${a.name}): ${desc}`);
+    }
+    return lines.join('\n');
+}
+function buildPrompt(userMessage, agents) {
+    return [
+        'You are Clementine\'s team dispatcher. Decide which team member should handle an incoming user message.',
+        '',
+        '## The team:',
+        formatAgentRoster(agents),
+        '',
+        '## The message:',
+        userMessage.slice(0, 1500),
+        '',
+        '## Decision rules',
+        '',
+        '- Default to **clementine** (the generalist) unless the request clearly matches a specialist agent\'s domain.',
+        '- Match on DOMAIN, not keywords. "Help me think about our outbound strategy" is strategic → Clementine. "Send a follow-up to Aaron about the Scorpion audit" is operational outbound → the SDR agent.',
+        '- If the user explicitly names an agent ("have Ross do X"), pick that agent at confidence 1.0.',
+        '- If the request is meta ("what agents do I have", "how did Ross do this week") → clementine.',
+        '- Small talk, greetings, casual chat → clementine.',
+        '- Ambiguous or multi-domain requests → clementine with lower confidence (she can delegate herself).',
+        '',
+        '## Confidence scale',
+        '- 0.9-1.0: Explicit address of a specific agent, or a textbook specialist task (e.g., "send a follow-up" → SDR)',
+        '- 0.7-0.9: Clear specialist domain but implicit (e.g., "draft a LinkedIn message" → SDR, "write a content brief" → CMO agent)',
+        '- 0.4-0.7: Plausibly specialist but could go to Clementine',
+        '- <0.4: Generalist task or ambiguous — clementine',
+        '',
+        '## Output schema (JSON only, no fences):',
+        '{',
+        '  "targetAgent": "slug (use \\"clementine\\" if no specialist match)",',
+        '  "confidence": 0.0-1.0,',
+        '  "reasoning": "one short sentence — what signal drove the choice"',
+        '}',
+    ].join('\n');
+}
+function parseResponse(raw) {
+    try {
+        const match = raw.match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        const parsed = JSON.parse(match[0]);
+        if (typeof parsed.targetAgent !== 'string')
+            return null;
+        const confidence = typeof parsed.confidence === 'number'
+            ? Math.max(0, Math.min(1, parsed.confidence))
+            : 0;
+        return {
+            targetAgent: parsed.targetAgent.trim().toLowerCase(),
+            confidence,
+            reasoning: typeof parsed.reasoning === 'string' ? parsed.reasoning.slice(0, 200) : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Classify a user message. Returns null if the call fails — caller
+ * should fall back to Clementine handling.
+ */
+export async function classifyRoute(userMessage, agents, gateway) {
+    // Only classify when there's at least one non-clementine agent available.
+    const specialists = agents.filter(a => a.slug !== 'clementine');
+    if (specialists.length === 0)
+        return null;
+    // Fast path: explicit slug mention anywhere in the message.
+    for (const a of specialists) {
+        const nameLower = a.name.toLowerCase();
+        const firstName = nameLower.split(/\s+/)[0];
+        // Only match on reasonable word boundaries; skip one-letter firsts
+        if (firstName.length < 3)
+            continue;
+        const wordRe = new RegExp(`\\b(${firstName}|${a.slug})\\b`, 'i');
+        if (wordRe.test(userMessage)) {
+            logger.debug({ slug: a.slug, trigger: 'explicit-mention' }, 'Fast-path routing decision');
+            return {
+                targetAgent: a.slug,
+                confidence: 1.0,
+                reasoning: `User explicitly addressed ${a.name} by name.`,
+            };
+        }
+    }
+    // LLM classifier for everything else.
+    const prompt = buildPrompt(userMessage, agents);
+    let raw;
+    try {
+        raw = await gateway.handleCronJob('route-classify', prompt, 1, // tier 1
+        3, // maxTurns — classifier doesn't need tools
+        'haiku');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Route classifier call failed');
+        return null;
+    }
+    const decision = parseResponse(raw);
+    if (!decision) {
+        logger.warn({ rawHead: raw.slice(0, 200) }, 'Route classifier returned unparseable response');
+        return null;
+    }
+    // Validate target exists in the roster; if not, treat as Clementine.
+    const allSlugs = new Set(agents.map(a => a.slug));
+    allSlugs.add('clementine');
+    if (!allSlugs.has(decision.targetAgent)) {
+        logger.warn({ decision }, 'Classifier returned unknown agent — treating as clementine');
+        decision.targetAgent = 'clementine';
+        decision.confidence = Math.min(decision.confidence, 0.3);
+    }
+    return decision;
+}
+//# sourceMappingURL=route-classifier.js.map

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`