clementine-agent 1.8.0 → 1.8.1

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

@@ -26,6 +26,19 @@
  */
 export interface TriggerFile {
     jobName: string;
+    /**
+     * Bare job name (without `{agentSlug}:` prefix). Set by cron-scheduler
+     * for agent-scoped jobs so the loop can look the job up in
+     * agents/{agentSlug}/CRON.md. Optional for backward compat with
+     * triggers written before this field existed.
+     */
+    bareName?: string;
+    /**
+     * Owning agent slug, set by cron-scheduler. When present, the loop
+     * applies fixes to vault/00-System/agents/{agentSlug}/CRON.md instead
+     * of the central CRON.md. Falls back to scanning if absent (older triggers).
+     */
+    agentSlug?: string;
     consecutiveErrors: number;
     recentErrors: string[];
     triggeredAt: string;
@@ -61,6 +74,11 @@ export interface SelfImproveLoopOptions {
     triggersDir?: string;
     pendingDir?: string;
     cronPath?: string;
+    /**
+     * Override the agents root (vault/00-System/agents). When a trigger
+     * has agentSlug, the loop reads/writes `${agentsDir}/${agentSlug}/CRON.md`.
+     */
+    agentsDir?: string;
     /**
      * Disable the fs.watch event-driven path. Tests use this so they can
      * call tick() directly without racing the watcher.
@@ -73,6 +91,7 @@ export declare class SelfImproveLoop {
     private readonly triggersDir;
     private readonly pendingDir;
     private readonly cronPath;
+    private readonly agentsDir;
     private readonly dispatcher;
     private readonly watchEnabled;
     private timer;

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

@@ -28,7 +28,7 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, watch, wr
 import path from 'node:path';
 import matter from 'gray-matter';
 import pino from 'pino';
-import { BASE_DIR, SYSTEM_DIR } from '../config.js';
+import { AGENTS_DIR, BASE_DIR, SYSTEM_DIR } from '../config.js';
 const logger = pino({ name: 'clementine.self-improve-loop' });
 /**
  * Fallback tick interval. The loop is primarily event-driven via fs.watch
@@ -46,6 +46,7 @@ const WATCH_DEBOUNCE_MS = 2000;
 const TRIGGERS_DIR = path.join(BASE_DIR, 'self-improve', 'triggers');
 const PENDING_CHANGES_DIR = path.join(BASE_DIR, 'self-improve', 'pending-changes');
 const CRON_PATH = path.join(SYSTEM_DIR, 'CRON.md');
+const AGENTS_ROOT = AGENTS_DIR;
 // ── Pattern recognition ──────────────────────────────────────────────
 const PATTERNS = [
     {
@@ -108,36 +109,108 @@ export function classifyFailure(recentErrors) {
         description: 'Unrecognized failure pattern. Owner needs to inspect the trigger file.',
     };
 }
-function loadCronJob(jobName, cronPath) {
+function readJobsFromFile(cronPath) {
     if (!existsSync(cronPath))
         return null;
     const raw = readFileSync(cronPath, 'utf-8');
     const parsed = matter(raw);
     const jobs = (parsed.data.jobs ?? []);
-    const job = jobs.find((j) => String(j.name ?? '') === jobName);
-    if (!job)
-        return null;
-    const agentSlug = typeof job.agentSlug === 'string' ? job.agentSlug : (typeof job.agent_slug === 'string' ? job.agent_slug : undefined);
-    return { agentSlug, job, raw, parsed };
+    return { raw, parsed, jobs };
+}
+function readAgentSlug(job) {
+    if (typeof job.agentSlug === 'string')
+        return job.agentSlug;
+    if (typeof job.agent_slug === 'string')
+        return job.agent_slug;
+    return undefined;
 }
 /**
- * Apply the recipe's mutator to the job's frontmatter and write CRON.md
- * back atomically. Returns true if a change was actually written.
+ * Locate a job's frontmatter entry in either the central CRON.md or an
+ * agent-scoped CRON.md. Search priority:
+ *
+ *   1. If trigger.agentSlug is set, look in agents/{slug}/CRON.md by bareName.
+ *   2. Otherwise look in central CRON.md by exact name.
+ *   3. Fall back to scanning agents/* for the bareName (covers older triggers
+ *      that lack agentSlug — the cron-scheduler-prefixed jobName like
+ *      `slug:name` lets us recover the slug).
  */
-function applyCronEdit(jobName, recipe, cronPath) {
+function loadCronJob(trigger, cronPath, agentsDir) {
+    const explicitSlug = trigger.agentSlug;
+    const bare = trigger.bareName ?? (explicitSlug && trigger.jobName.startsWith(`${explicitSlug}:`)
+        ? trigger.jobName.slice(explicitSlug.length + 1)
+        : trigger.jobName);
+    // 1. Agent-scoped file when slug is known
+    if (explicitSlug) {
+        const agentCronPath = path.join(agentsDir, explicitSlug, 'CRON.md');
+        const file = readJobsFromFile(agentCronPath);
+        if (file) {
+            const job = file.jobs.find((j) => String(j.name ?? '') === bare);
+            if (job) {
+                return {
+                    agentSlug: explicitSlug,
+                    cronPath: agentCronPath,
+                    bareName: bare,
+                    job,
+                    raw: file.raw,
+                    parsed: file.parsed,
+                };
+            }
+        }
+    }
+    // 2. Central CRON.md by full jobName (handles globally-defined jobs and
+    //    legacy jobs tagged with agentSlug field directly in the central file)
+    const central = readJobsFromFile(cronPath);
+    if (central) {
+        const job = central.jobs.find((j) => String(j.name ?? '') === trigger.jobName);
+        if (job) {
+            return {
+                agentSlug: explicitSlug ?? readAgentSlug(job),
+                cronPath,
+                bareName: String(job.name ?? ''),
+                job,
+                raw: central.raw,
+                parsed: central.parsed,
+            };
+        }
+    }
+    // 3. Recover via scan: trigger jobName follows `{slug}:{bareName}` for
+    //    agent-scoped jobs even when older triggers omit agentSlug.
+    if (!explicitSlug && trigger.jobName.includes(':')) {
+        const [slug, ...rest] = trigger.jobName.split(':');
+        const inferredBare = rest.join(':');
+        if (slug && inferredBare) {
+            const agentCronPath = path.join(agentsDir, slug, 'CRON.md');
+            const file = readJobsFromFile(agentCronPath);
+            if (file) {
+                const job = file.jobs.find((j) => String(j.name ?? '') === inferredBare);
+                if (job) {
+                    return {
+                        agentSlug: slug,
+                        cronPath: agentCronPath,
+                        bareName: inferredBare,
+                        job,
+                        raw: file.raw,
+                        parsed: file.parsed,
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Apply the recipe's mutator to the job's frontmatter and write the CRON.md
+ * (central or agent-scoped, whichever the lookup resolved to) back atomically.
+ * Returns true if a change was actually written.
+ */
+function applyCronEdit(lookup, recipe) {
     if (!recipe.apply)
         return false;
-    const lookup = loadCronJob(jobName, cronPath);
-    if (!lookup) {
-        logger.warn({ jobName }, 'Job not found in CRON.md — cannot apply fix');
-        return false;
-    }
     const changed = recipe.apply(lookup.job);
     if (!changed)
         return false;
-    // Re-stringify with the existing content body preserved.
     const updated = matter.stringify(lookup.parsed.content, lookup.parsed.data);
-    writeFileSync(cronPath, updated);
+    writeFileSync(lookup.cronPath, updated);
     return true;
 }
 function writePendingChange(record, dir) {
@@ -152,6 +225,7 @@ export class SelfImproveLoop {
     triggersDir;
     pendingDir;
     cronPath;
+    agentsDir;
     dispatcher;
     watchEnabled;
     timer = null;
@@ -165,6 +239,7 @@ export class SelfImproveLoop {
         this.triggersDir = opts.triggersDir ?? TRIGGERS_DIR;
         this.pendingDir = opts.pendingDir ?? PENDING_CHANGES_DIR;
         this.cronPath = opts.cronPath ?? CRON_PATH;
+        this.agentsDir = opts.agentsDir ?? AGENTS_ROOT;
         this.watchEnabled = opts.disableWatch !== true;
     }
     start() {
@@ -286,23 +361,32 @@ export class SelfImproveLoop {
     }
     async processOne(trigger, counts) {
         const recipe = classifyFailure(trigger.recentErrors);
-        const lookup = loadCronJob(trigger.jobName, this.cronPath);
-        const agentSlug = lookup?.agentSlug;
+        const lookup = loadCronJob(trigger, this.cronPath, this.agentsDir);
+        const agentSlug = trigger.agentSlug ?? lookup?.agentSlug;
         if (recipe.category === 'safe-cron-config') {
-            const applied = applyCronEdit(trigger.jobName, recipe, this.cronPath);
+            if (!lookup) {
+                // Job vanished from CRON files (renamed/deleted). Nothing to fix.
+                counts.noop++;
+                logger.warn({ jobName: trigger.jobName, agentSlug }, 'Job not found in any CRON.md — cannot apply fix');
+                return;
+            }
+            const applied = applyCronEdit(lookup, recipe);
             if (applied) {
                 counts.applied++;
+                const where = lookup.agentSlug
+                    ? `\`agents/${lookup.agentSlug}/CRON.md\``
+                    : '`CRON.md`';
                 await this.notifyAgent(agentSlug, [
                     `🔧 **Auto-fixed** \`${trigger.jobName}\` after ${trigger.consecutiveErrors} consecutive failures.`,
                     '',
                     recipe.description,
                     '',
-                    'I\'ll watch the next run to confirm it lands cleanly.',
+                    `Edit applied to ${where}. I'll watch the next run to confirm it lands cleanly.`,
                 ].join('\n'));
             }
             else {
                 counts.noop++;
-                logger.info({ jobName: trigger.jobName }, 'Fix recipe applied is already in place — trigger removed without further action');
+                logger.info({ jobName: trigger.jobName, agentSlug }, 'Fix recipe applied is already in place — trigger removed without further action');
             }
             return;
         }

package/dist/cli/dashboard.js

@@ -21292,8 +21292,8 @@ async function refreshMemoryHealth() {
       html += '<div style="font-weight:600;margin-bottom:4px">Retrieval running on sparse vectors for ' + missing.toLocaleString() + ' chunks</div>';
       html += '<div style="font-size:12px;color:var(--text-muted)">Backfill builds 768-dim neural embeddings for semantic search. First run downloads ~440MB.</div>';
       html += '</div>';
-      html += '<button class="btn-sm" onclick="memoryHealthAction(\'reembed-dense\', { limit: 200 })" title="Embed up to 200 chunks now">Backfill 200</button>';
-      html += '<button class="btn-sm" onclick="memoryHealthAction(\'reembed-dense\', { limit: 2000 })" title="Embed up to 2000 chunks now (slower)">Backfill 2000</button>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'reembed-dense\\', { limit: 200 })" title="Embed up to 200 chunks now">Backfill 200</button>';
+      html += '<button class="btn-sm" onclick="memoryHealthAction(\\'reembed-dense\\', { limit: 2000 })" title="Embed up to 2000 chunks now (slower)">Backfill 2000</button>';
       html += '</div></div>';
     }
 

package/dist/gateway/cron-scheduler.js

@@ -1184,19 +1184,27 @@ export class CronScheduler {
             if (advice.shouldEscalate) {
                 this.logAdvisorEvent('escalation', job.name, advice.escalationReason ?? 'Escalated to unleashed');
             }
-            // Write targeted self-improvement trigger when consecutive errors are high
+            // Write targeted self-improvement trigger when consecutive errors are high.
+            // Include agentSlug + bareName so the self-improve loop can locate jobs
+            // defined in per-agent CRON.md files (vault/00-System/agents/{slug}/CRON.md)
+            // rather than only the central one.
             if (consErrors >= 3) {
                 try {
                     const triggerDir = path.join(BASE_DIR, 'self-improve', 'triggers');
                     mkdirSync(triggerDir, { recursive: true });
                     const triggerPath = path.join(triggerDir, `${job.name.replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
+                    const bareName = job.agentSlug && job.name.startsWith(`${job.agentSlug}:`)
+                        ? job.name.slice(job.agentSlug.length + 1)
+                        : job.name;
                     writeFileSync(triggerPath, JSON.stringify({
                         jobName: job.name,
+                        bareName,
+                        agentSlug: job.agentSlug,
                         consecutiveErrors: consErrors,
                         recentErrors: this.runLog.readRecent(job.name, 3).map(e => e.error?.slice(0, 200)),
                         triggeredAt: new Date().toISOString(),
                     }, null, 2));
-                    logger.info({ job: job.name, consErrors }, 'Wrote self-improvement trigger for failing job');
+                    logger.info({ job: job.name, agentSlug: job.agentSlug, consErrors }, 'Wrote self-improvement trigger for failing job');
                 }
                 catch { /* non-fatal */ }
             }

package/package.json

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