clementine-agent 1.8.1 → 1.8.2

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

@@ -26,19 +26,6 @@
  */
 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;
@@ -74,11 +61,6 @@ 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.
@@ -91,7 +73,6 @@ 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 { AGENTS_DIR, BASE_DIR, SYSTEM_DIR } from '../config.js';
+import { 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,7 +46,6 @@ 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 = [
     {
@@ -109,108 +108,36 @@ export function classifyFailure(recentErrors) {
         description: 'Unrecognized failure pattern. Owner needs to inspect the trigger file.',
     };
 }
-function readJobsFromFile(cronPath) {
+function loadCronJob(jobName, cronPath) {
     if (!existsSync(cronPath))
         return null;
     const raw = readFileSync(cronPath, 'utf-8');
     const parsed = matter(raw);
     const jobs = (parsed.data.jobs ?? []);
-    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;
-}
-/**
- * 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 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;
+    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 };
 }
 /**
- * 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.
+ * Apply the recipe's mutator to the job's frontmatter and write CRON.md
+ * back atomically. Returns true if a change was actually written.
  */
-function applyCronEdit(lookup, recipe) {
+function applyCronEdit(jobName, recipe, cronPath) {
     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(lookup.cronPath, updated);
+    writeFileSync(cronPath, updated);
     return true;
 }
 function writePendingChange(record, dir) {
@@ -225,7 +152,6 @@ export class SelfImproveLoop {
     triggersDir;
     pendingDir;
     cronPath;
-    agentsDir;
     dispatcher;
     watchEnabled;
     timer = null;
@@ -239,7 +165,6 @@ 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() {
@@ -361,32 +286,23 @@ export class SelfImproveLoop {
     }
     async processOne(trigger, counts) {
         const recipe = classifyFailure(trigger.recentErrors);
-        const lookup = loadCronJob(trigger, this.cronPath, this.agentsDir);
-        const agentSlug = trigger.agentSlug ?? lookup?.agentSlug;
+        const lookup = loadCronJob(trigger.jobName, this.cronPath);
+        const agentSlug = lookup?.agentSlug;
         if (recipe.category === 'safe-cron-config') {
-            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);
+            const applied = applyCronEdit(trigger.jobName, recipe, this.cronPath);
             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,
                     '',
-                    `Edit applied to ${where}. I'll watch the next run to confirm it lands cleanly.`,
+                    'I\'ll watch the next run to confirm it lands cleanly.',
                 ].join('\n'));
             }
             else {
                 counts.noop++;
-                logger.info({ jobName: trigger.jobName, agentSlug }, 'Fix recipe applied is already in place — trigger removed without further action');
+                logger.info({ jobName: trigger.jobName }, 'Fix recipe applied is already in place — trigger removed without further action');
             }
             return;
         }

package/dist/cli/browser.d.ts

@@ -32,5 +32,24 @@ export declare function cmdBrowserEnable(): Promise<void>;
  */
 export declare function maybePromptBrowserHarness(): Promise<void>;
 export declare function cmdBrowserDisable(): Promise<void>;
+/**
+ * Non-interactive connect — meant for callers that aren't a TTY (MCP tool,
+ * daemon-internal callers). Returns a structured result instead of prompting
+ * or printing decorative output. Caller decides how to surface failures.
+ *
+ * Behavior:
+ *   - CDP already up → { ok: true, alreadyConnected: true }
+ *   - No Chrome running → launch with flag, poll, return result
+ *   - Chrome running without flag → if allowQuitChrome=false, refuse with
+ *     a clear message; if true, quit + relaunch (DESTRUCTIVE — closes tabs).
+ */
+export declare function runConnectNonInteractive(opts?: {
+    allowQuitChrome?: boolean;
+}): Promise<{
+    ok: boolean;
+    message: string;
+    alreadyConnected?: boolean;
+    needsForceQuit?: boolean;
+}>;
 export declare function cmdBrowserConnect(): Promise<void>;
 //# sourceMappingURL=browser.d.ts.map

package/dist/cli/browser.js

@@ -354,11 +354,85 @@ export async function cmdBrowserDisable() {
     console.log();
 }
 /**
- * Core connect logic — quits any running Chrome and relaunches with
- * --remote-debugging-port=9222 so browser-harness can connect.
+ * Non-interactive connect — meant for callers that aren't a TTY (MCP tool,
+ * daemon-internal callers). Returns a structured result instead of prompting
+ * or printing decorative output. Caller decides how to surface failures.
  *
- * Returns true when CDP is reachable on :9222 at the end, false otherwise.
- * Never calls process.exit so it's safe to call from the auto-prompt flow.
+ * Behavior:
+ *   - CDP already up → { ok: true, alreadyConnected: true }
+ *   - No Chrome running → launch with flag, poll, return result
+ *   - Chrome running without flag → if allowQuitChrome=false, refuse with
+ *     a clear message; if true, quit + relaunch (DESTRUCTIVE — closes tabs).
+ */
+export async function runConnectNonInteractive(opts = {}) {
+    if (await probeCdp()) {
+        return { ok: true, alreadyConnected: true, message: 'Already connected — Chrome is running with remote debugging on :9222.' };
+    }
+    if (process.platform !== 'darwin' && process.platform !== 'linux') {
+        return {
+            ok: false,
+            message: 'Auto-connect is only supported on macOS and Linux. Launch Chrome manually with --remote-debugging-port=9222.',
+        };
+    }
+    if (isChromeRunning() && !opts.allowQuitChrome) {
+        return {
+            ok: false,
+            needsForceQuit: true,
+            message: 'Chrome is running without remote debugging. Connecting requires quitting Chrome and relaunching with --remote-debugging-port=9222 (this closes your current Chrome windows). Re-run with force_quit=true to proceed, or quit Chrome yourself first and call this again.',
+        };
+    }
+    if (isChromeRunning() && opts.allowQuitChrome) {
+        try {
+            if (process.platform === 'darwin') {
+                execSync('osascript -e \'tell application "Google Chrome" to quit\'', { stdio: 'pipe' });
+            }
+            else {
+                try {
+                    execSync('pkill -TERM -x "google-chrome|chromium|chrome"', { stdio: 'pipe' });
+                }
+                catch { /* ok */ }
+            }
+            for (let i = 0; i < 15; i++) {
+                if (!isChromeRunning())
+                    break;
+                await new Promise(r => setTimeout(r, 300));
+            }
+        }
+        catch {
+            return { ok: false, message: 'Failed to quit Chrome. Quit it manually and try again.' };
+        }
+    }
+    try {
+        if (process.platform === 'darwin') {
+            execSync('open -na "Google Chrome" --args --remote-debugging-port=9222', { stdio: 'pipe' });
+        }
+        else {
+            const candidates = ['google-chrome', 'chromium', 'chrome'];
+            const bin = candidates.find(commandExists);
+            if (!bin) {
+                return { ok: false, message: 'No Chrome / Chromium binary found in PATH.' };
+            }
+            execSync(`nohup ${bin} --remote-debugging-port=9222 >/dev/null 2>&1 &`, { stdio: 'pipe' });
+        }
+    }
+    catch (e) {
+        return { ok: false, message: `Failed to launch Chrome: ${String(e).slice(0, 200)}` };
+    }
+    for (let i = 0; i < 24; i++) {
+        await new Promise(r => setTimeout(r, 250));
+        if (await probeCdp()) {
+            return { ok: true, message: 'Connected — Chrome is running with remote debugging on :9222.' };
+        }
+    }
+    return {
+        ok: false,
+        message: 'Chrome launched, but CDP socket isn\'t responding yet. Check that Chrome started successfully, then verify with: curl http://localhost:9222/json/version',
+    };
+}
+/**
+ * Interactive CLI connect — wraps runConnectNonInteractive with TTY prompts
+ * and decorative output. Used by `clementine browser connect` and the auto-
+ * prompt flow.
  */
 async function runConnect(opts = {}) {
     // 1. Already connected? Done.

package/dist/gateway/cron-scheduler.js

@@ -1184,27 +1184,19 @@ 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.
-            // 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.
+            // Write targeted self-improvement trigger when consecutive errors are high
             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, agentSlug: job.agentSlug, consErrors }, 'Wrote self-improvement trigger for failing job');
+                    logger.info({ job: job.name, consErrors }, 'Wrote self-improvement trigger for failing job');
                 }
                 catch { /* non-fatal */ }
             }

package/dist/tools/admin-tools.js

@@ -1873,5 +1873,13 @@ export function registerAdminTools(server) {
         logger.info({ jobName: job_name, runCount: updated.runCount }, 'Cron progress saved');
         return textResult(`Progress saved for "${job_name}" (run #${updated.runCount}). ${(completedItems?.length ?? 0)} items completed, ${(updated.pendingItems?.length ?? 0)} pending.`);
     });
+    // ── Browser harness — chat-driven Chrome connect ────────────────────
+    server.tool('browser_connect', 'Connect Chrome to the browser harness via CDP. Idempotent — if Chrome is already running with remote debugging on :9222 this is a no-op. If no Chrome is running, launches Chrome with --remote-debugging-port=9222. If Chrome is running normally without the flag, refuses unless force_quit=true (which closes the user\'s open tabs). Use this so the user can connect from any chat channel without dropping to the terminal.', {
+        force_quit: z.boolean().optional().describe('If true, quit any running Chrome before relaunching with the debug flag. DESTRUCTIVE — closes the user\'s open tabs. Only set after the user has explicitly confirmed they want this. Defaults to false.'),
+    }, async ({ force_quit }) => {
+        const { runConnectNonInteractive } = await import('../cli/browser.js');
+        const result = await runConnectNonInteractive({ allowQuitChrome: !!force_quit });
+        return textResult(result.message);
+    });
 }
 //# sourceMappingURL=admin-tools.js.map

package/package.json

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