clementine-agent 1.18.133 → 1.18.134

package/dist/agent/{self-improve-loop.d.ts → failure-fix-consumer.d.ts}

@@ -98,7 +98,7 @@ export interface SelfImproveLoopOptions {
     allowAutoApplySafeFixes?: boolean;
 }
 export declare function classifyFailure(recentErrors: string[]): FixRecipe;
-export declare class SelfImproveLoop {
+export declare class FailureFixConsumer {
     private readonly tickMs;
     private readonly triggersDir;
     private readonly pendingDir;
@@ -133,4 +133,4 @@ export declare class SelfImproveLoop {
     private processOne;
     private notifyAgent;
 }
-//# sourceMappingURL=self-improve-loop.d.ts.map
+//# sourceMappingURL=failure-fix-consumer.d.ts.map

package/dist/agent/{self-improve-loop.js → failure-fix-consumer.js}

@@ -29,7 +29,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import pino from 'pino';
 import { AGENTS_DIR, BASE_DIR, SYSTEM_DIR } from '../config.js';
-const logger = pino({ name: 'clementine.self-improve-loop' });
+const logger = pino({ name: 'clementine.failure-fix-consumer' });
 /**
  * Fallback tick interval. The loop is primarily event-driven via fs.watch
  * on the triggers directory — this is just a slow safety net for cases
@@ -231,7 +231,7 @@ function writePendingChange(record, dir) {
     return file;
 }
 // ── Main loop ────────────────────────────────────────────────────────
-export class SelfImproveLoop {
+export class FailureFixConsumer {
     tickMs;
     triggersDir;
     pendingDir;
@@ -503,4 +503,4 @@ export class SelfImproveLoop {
         }
     }
 }
-//# sourceMappingURL=self-improve-loop.js.map
+//# sourceMappingURL=failure-fix-consumer.js.map

package/dist/agent/self-improve.js

@@ -411,12 +411,18 @@ export class SelfImproveLoop {
                         consecutiveLow++;
                         continue;
                     }
-                    // Diversity safety net: skip if hypothesis targets an over-represented area:target
+                    // Diversity safety net: skip if hypothesis targets an over-represented area:target.
+                    // 1.18.134 — loosened cap from 3 to 5. The old cap caused the
+                    // loop to plateau immediately whenever it had ~3 ideas about
+                    // SOUL.md (which is a frequent attractor). At 5 the
+                    // hypothesizer gets a few more swings at the same area before
+                    // diversity kicks in — but still avoids monomania.
+                    const DIVERSITY_CAP = 5;
                     const proposalKey = `${proposal.area}:${proposal.target}`;
                     const proposalCount = history.filter(e => `${e.area}:${e.target}` === proposalKey).length
                         + this.getPendingChanges().filter(p => `${p.area}:${p.target}` === proposalKey).length;
-                    if (proposalCount >= 3) {
-                        logger.warn({ area: proposal.area, target: proposal.target, count: proposalCount }, 'Hypothesis over-targeted — skipping');
+                    if (proposalCount >= DIVERSITY_CAP) {
+                        logger.warn({ area: proposal.area, target: proposal.target, count: proposalCount, cap: DIVERSITY_CAP }, 'Hypothesis over-targeted — skipping');
                         consecutiveLow++;
                         continue;
                     }
@@ -440,8 +446,37 @@ export class SelfImproveLoop {
                     const before = await this.readCurrentState(proposal.area, proposal.target);
                     // Step 5: Evaluate
                     const evaluation = await this.withTimeout(this.evaluate(before, proposal.proposedChange, proposal.hypothesis), 60_000);
-                    const score = evaluation?.score ?? 0;
-                    const normalizedScore = score / 10; // Convert 0-10 to 0-1
+                    const llmScore = evaluation?.score ?? 0;
+                    const normalizedLlmScore = llmScore / 10; // Convert 0-10 to 0-1
+                    // 1.18.134 — blend the LLM evaluator score with an objective
+                    // signal pulled from real metrics. Karpathy's autoresearch uses
+                    // ONE objective metric (val_bpb); Clementine's LLM-only score
+                    // can drift, especially when proposals affect SOUL.md or
+                    // cosmetic prompt fields. The objective floor is computed from
+                    // the baseline metrics gathered at the start of THIS run:
+                    //
+                    //   objective = cronSuccessRate * feedbackPositiveRatio
+                    //
+                    // Both 0..1; product preserves the multiplicative penalty of
+                    // either metric being weak. We weight 70% LLM / 30% objective
+                    // — the LLM still drives most decisions, but a proposal can't
+                    // sail through on a 9/10 evaluator score when feedback is at
+                    // 35% positive (which is the current reality). Set the env
+                    // var SELF_IMPROVE_OBJECTIVE_WEIGHT to override (0..1).
+                    const objectiveWeightRaw = parseFloat(process.env.SELF_IMPROVE_OBJECTIVE_WEIGHT ?? '0.3');
+                    const objectiveWeight = Number.isFinite(objectiveWeightRaw) && objectiveWeightRaw >= 0 && objectiveWeightRaw <= 1
+                        ? objectiveWeightRaw : 0.3;
+                    const llmWeight = 1 - objectiveWeight;
+                    const objectiveScore = (state.baselineMetrics.cronSuccessRate || 0)
+                        * (state.baselineMetrics.feedbackPositiveRatio || 0);
+                    const normalizedScore = (normalizedLlmScore * llmWeight) + (objectiveScore * objectiveWeight);
+                    const score = normalizedScore * 10; // For display + reason text
+                    logger.debug({
+                        llm: normalizedLlmScore.toFixed(3),
+                        objective: objectiveScore.toFixed(3),
+                        blended: normalizedScore.toFixed(3),
+                        weight: objectiveWeight,
+                    }, 'Score blend');
                     const accepted = normalizedScore >= this.config.acceptThreshold;
                     // Surface gate: even when accepted, only score >= surfaceThreshold
                     // reaches the user's pending-changes inbox. Below that floor we

package/dist/index.js

@@ -754,11 +754,14 @@ async function asyncMain() {
     // output to their Discord channel.
     const { AgentHeartbeatManager } = await import('./gateway/agent-heartbeat-manager.js');
     const agentHeartbeats = new AgentHeartbeatManager(gateway.getAgentManager(), gateway);
-    // Self-improve loop — closes the gap between "trigger written" and
-    // "fix applied." Every 10 min, scans self-improve/triggers/, classifies
-    // failures, auto-applies safe cron-config fixes, escalates risky ones.
-    const { SelfImproveLoop } = await import('./agent/self-improve-loop.js');
-    const selfImproveLoop = new SelfImproveLoop(dispatcher);
+    // Failure-fix consumer (1.18.134 — renamed from "self-improve-loop"
+    // to disambiguate from the Karpathy autoresearch SelfImproveLoop in
+    // src/agent/self-improve.ts). Every 10 min, scans
+    // self-improve/triggers/, classifies failures, auto-applies safe
+    // cron-config fixes, escalates risky ones. Different concern from
+    // the autoresearch hypothesize/evaluate loop.
+    const { FailureFixConsumer } = await import('./agent/failure-fix-consumer.js');
+    const failureFixConsumer = new FailureFixConsumer(dispatcher);
     // ── Build channel tasks ──────────────────────────────────────────
     const channelTasks = [];
     const activeChannels = [];
@@ -856,7 +859,38 @@ async function asyncMain() {
     heartbeat.start();
     cronScheduler.start();
     agentHeartbeats.start();
-    selfImproveLoop.start();
+    failureFixConsumer.start();
+    // 1.18.134 — nightly Karpathy-autoresearch self-improve trigger.
+    // The Karpathy SelfImproveLoop (src/agent/self-improve.ts) was
+    // previously only triggered by /self-improve run or CLI. With no
+    // automatic schedule the loop ran ~3 times in the prior 4 days and
+    // sat plateaued. This wires a daily 3am trigger so it iterates on
+    // its own — matching Karpathy's continuous-iteration model.
+    // SELF_IMPROVE_HOUR env var overrides (0–23, default 3).
+    const selfImproveHour = (() => {
+        const raw = parseInt(process.env.SELF_IMPROVE_HOUR ?? '3', 10);
+        if (Number.isFinite(raw) && raw >= 0 && raw <= 23)
+            return raw;
+        return 3;
+    })();
+    // node-cron is already a dependency (used by cron-scheduler). Schedule
+    // a single daily tick — the SelfImproveLoop's own time/iteration caps
+    // and plateau detection bound the work; we don't need finer granularity.
+    try {
+        const nodeCron = (await import('node-cron')).default;
+        nodeCron.schedule(`0 ${selfImproveHour} * * *`, () => {
+            logger.info({ hour: selfImproveHour }, 'Nightly self-improve trigger firing');
+            gateway.handleSelfImprove('run').then((summary) => {
+                logger.info({ summary }, 'Nightly self-improve trigger complete');
+            }).catch((err) => {
+                logger.error({ err }, 'Nightly self-improve trigger failed');
+            });
+        }, { timezone: process.env.TZ || 'America/Los_Angeles' });
+        logger.info({ hour: selfImproveHour }, `Self-improve nightly trigger scheduled (${selfImproveHour}:00 daily)`);
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to schedule nightly self-improve trigger');
+    }
     // Background-task hygiene: any task left in 'running' is from a prior
     // process. Mark them aborted so the lifecycle is honest. (P6b will add
     // resumability; for now fail-fast is clearer than silently re-running.)
@@ -1086,7 +1120,7 @@ async function asyncMain() {
     heartbeat.stop();
     cronScheduler.stop();
     agentHeartbeats.stop();
-    selfImproveLoop.stop();
+    failureFixConsumer.stop();
     // ── Self-restart (enhanced with health check + rollback) ────────
     if (restartRequested) {
         // Clear our PID file BEFORE spawning the child, so ensureSingleton()

package/package.json

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