clementine-agent 1.1.1 → 1.1.3

package/dist/agent/execution-advisor.d.ts

@@ -24,7 +24,15 @@ export interface ReflectionEntry {
     gap: string;
     commNote: string;
 }
+export type AdvisorRulesMode = 'off' | 'shadow' | 'primary';
 export declare function getExecutionAdvice(jobName: string, job: CronJobDefinition): ExecutionAdvice;
+/**
+ * Mode-parameterized variant of getExecutionAdvice. Public so tests can
+ * exercise primary mode without mutating module-level env state.
+ */
+export declare function getExecutionAdviceWithMode(jobName: string, job: CronJobDefinition, mode: AdvisorRulesMode): ExecutionAdvice;
+/** Test-only: clear the rule-init flag so subsequent calls re-init. */
+export declare function _resetAdvisorRulesInit(): void;
 export declare function checkTurnLimitHits(runs: ReturnType<CronRunLog['readRecent']>, job: CronJobDefinition, advice: ExecutionAdvice): void;
 export declare function checkReflectionQuality(reflections: ReflectionEntry[], job: CronJobDefinition, advice: ExecutionAdvice): void;
 export declare function checkTimeoutHits(runs: ReturnType<CronRunLog['readRecent']>, job: CronJobDefinition, advice: ExecutionAdvice): void;

package/dist/agent/execution-advisor.js

@@ -11,8 +11,12 @@ import pino from 'pino';
 import { ADVISOR_RULES_LOADER, CRON_REFLECTIONS_DIR, ADVISOR_LOG_PATH } from '../config.js';
 import { CronRunLog } from '../gateway/heartbeat.js';
 import { evolvePrompt } from './prompt-evolver.js';
+import { loadAdvisorRules, getLoadedRules, watchUserRulesDir, } from './advisor-rules/loader.js';
+import { buildRuleContext } from './advisor-rules/context.js';
+import { applyRules } from './advisor-rules/engine.js';
 const logger = pino({ name: 'clementine.execution-advisor' });
 const shadowLogger = pino({ name: 'clementine.advisor-rules-shadow' });
+const primaryLogger = pino({ name: 'clementine.advisor-rules-primary' });
 // ── Tier caps for maxTurns ──────────────────────────────────────────
 export const TIER_MAX_TURNS = {
     1: 15,
@@ -22,8 +26,32 @@ export const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
 export const MAX_TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes
 export const CIRCUIT_BREAKER_COOLDOWN_MS = 60 * 60 * 1000; // 1 hour between retry probes
 export const DEFAULT_MAX_TURNS_FALLBACK = 5; // when job.maxTurns is unset
-// ── Core function ───────────────────────────────────────────────────
 export function getExecutionAdvice(jobName, job) {
+    return getExecutionAdviceWithMode(jobName, job, ADVISOR_RULES_LOADER);
+}
+/**
+ * Mode-parameterized variant of getExecutionAdvice. Public so tests can
+ * exercise primary mode without mutating module-level env state.
+ */
+export function getExecutionAdviceWithMode(jobName, job, mode) {
+    // Primary mode: rule engine is the source of truth. Falls through to the
+    // legacy TS path only if the loader is unavailable for some reason.
+    if (mode === 'primary') {
+        if (ensureRulesInitialized()) {
+            return computePrimaryAdvice(jobName, job);
+        }
+        primaryLogger.warn({ jobName }, 'Primary rule engine unavailable — falling back to legacy TS path');
+    }
+    const advice = computeLegacyAdvice(jobName, job);
+    // Shadow mode: run the YAML rule engine on the same job, log any divergence
+    // from the legacy TS advice. Non-throwing — never affects the returned advice.
+    if (mode === 'shadow' && ensureRulesInitialized()) {
+        runShadowComparison(jobName, job, advice);
+    }
+    return advice;
+}
+// ── Legacy TS path (kept as fallback for primary mode) ──────────────
+function computeLegacyAdvice(jobName, job) {
     const advice = {
         adjustedMaxTurns: null,
         adjustedModel: null,
@@ -101,67 +129,65 @@ export function getExecutionAdvice(jobName, job) {
     catch (err) {
         logger.warn({ err, job: jobName }, 'Execution advisor error — proceeding with defaults');
     }
-    // Shadow mode: run the YAML rule engine on the same job, log any divergence
-    // from the legacy TS advice. Non-throwing — never affects the returned advice.
-    if (ADVISOR_RULES_LOADER === 'shadow') {
-        runShadowComparison(jobName, job, advice);
-    }
     return advice;
 }
-// ── Shadow-mode comparison ──────────────────────────────────────────
-let shadowInitialized = false;
-let shadowAvailable = false;
-let shadowDeps = null;
-async function ensureShadowInitialized() {
-    if (shadowInitialized)
-        return;
-    shadowInitialized = true;
+// ── Rule-engine path ────────────────────────────────────────────────
+let rulesInitialized = false;
+let rulesAvailable = false;
+/** Sync init for the rule loader. Idempotent. Safe to call from any mode. */
+function ensureRulesInitialized() {
+    if (rulesInitialized)
+        return rulesAvailable;
+    rulesInitialized = true;
     try {
-        const [loaderMod, contextMod, engineMod] = await Promise.all([
-            import('./advisor-rules/loader.js'),
-            import('./advisor-rules/context.js'),
-            import('./advisor-rules/engine.js'),
-        ]);
-        shadowDeps = {
-            loadAdvisorRules: loaderMod.loadAdvisorRules,
-            getLoadedRules: loaderMod.getLoadedRules,
-            watchUserRulesDir: loaderMod.watchUserRulesDir,
-            buildRuleContext: contextMod.buildRuleContext,
-            applyRules: engineMod.applyRules,
-        };
-        shadowDeps.loadAdvisorRules();
-        shadowDeps.watchUserRulesDir();
-        shadowAvailable = true;
-        shadowLogger.info('Advisor rules shadow mode initialized');
+        loadAdvisorRules();
+        watchUserRulesDir();
+        rulesAvailable = true;
+        primaryLogger.info({ ruleCount: getLoadedRules().length }, 'Advisor rules initialized');
+    }
+    catch (err) {
+        primaryLogger.warn({ err }, 'Failed to initialize advisor rules — TS path will be used');
+        rulesAvailable = false;
+    }
+    return rulesAvailable;
+}
+function computePrimaryAdvice(jobName, job) {
+    try {
+        const rules = getLoadedRules();
+        const ctx = buildRuleContext(jobName, job);
+        const { advice, traces } = applyRules(rules, ctx);
+        const fired = traces.filter(t => t.fired).map(t => t.ruleId);
+        if (fired.length > 0) {
+            primaryLogger.debug({ jobName, firedRules: fired }, 'Rule engine produced advice');
+        }
+        return advice;
     }
     catch (err) {
-        shadowLogger.warn({ err }, 'Failed to initialize advisor rules shadow mode');
+        primaryLogger.warn({ err, jobName }, 'Rule engine threw — falling back to legacy TS path for this call');
+        return computeLegacyAdvice(jobName, job);
     }
 }
 function runShadowComparison(jobName, job, tsAdvice) {
-    // Fire-and-forget: kicks off async init the first time, then runs comparison
-    // synchronously on subsequent calls. Never throws.
-    ensureShadowInitialized()
-        .then(() => {
-        if (!shadowAvailable || !shadowDeps)
-            return;
-        try {
-            const rules = shadowDeps.getLoadedRules();
-            const ctx = shadowDeps.buildRuleContext(jobName, job);
-            const { advice: yamlAdvice, traces } = shadowDeps.applyRules(rules, ctx);
-            const diffs = diffAdvice(tsAdvice, yamlAdvice);
-            if (diffs.length > 0) {
-                shadowLogger.warn({ jobName, diffs, firedRules: traces.filter(t => t.fired).map(t => t.ruleId) }, 'Shadow advisor diverged from TS path');
-            }
-            else {
-                shadowLogger.debug({ jobName, firedRules: traces.filter(t => t.fired).map(t => t.ruleId) }, 'Shadow advisor matches TS path');
-            }
+    try {
+        const rules = getLoadedRules();
+        const ctx = buildRuleContext(jobName, job);
+        const { advice: yamlAdvice, traces } = applyRules(rules, ctx);
+        const diffs = diffAdvice(tsAdvice, yamlAdvice);
+        if (diffs.length > 0) {
+            shadowLogger.warn({ jobName, diffs, firedRules: traces.filter(t => t.fired).map(t => t.ruleId) }, 'Shadow advisor diverged from TS path');
         }
-        catch (err) {
-            shadowLogger.warn({ err, jobName }, 'Shadow advisor run failed');
+        else {
+            shadowLogger.debug({ jobName, firedRules: traces.filter(t => t.fired).map(t => t.ruleId) }, 'Shadow advisor matches TS path');
         }
-    })
-        .catch(() => { });
+    }
+    catch (err) {
+        shadowLogger.warn({ err, jobName }, 'Shadow advisor run failed');
+    }
+}
+/** Test-only: clear the rule-init flag so subsequent calls re-init. */
+export function _resetAdvisorRulesInit() {
+    rulesInitialized = false;
+    rulesAvailable = false;
 }
 function diffAdvice(a, b) {
     const fields = [

package/dist/cli/dashboard.js

@@ -7124,6 +7124,23 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.json({ byType: {}, totalOutcomes: 0 });
         }
     });
+    app.get('/api/advisor/status', async (_req, res) => {
+        try {
+            const { ADVISOR_RULES_LOADER } = await import('../config.js');
+            const { loadAdvisorRules } = await import('../agent/advisor-rules/loader.js');
+            const rules = loadAdvisorRules();
+            const builtinCount = rules.filter(r => r._sourcePath?.includes('/builtin/')).length;
+            res.json({
+                mode: ADVISOR_RULES_LOADER,
+                ruleCount: rules.length,
+                builtinCount,
+                userCount: rules.length - builtinCount,
+            });
+        }
+        catch (err) {
+            res.json({ mode: 'off', ruleCount: 0, builtinCount: 0, userCount: 0, error: String(err) });
+        }
+    });
     // ── Remote access API ────────────────────────────────────────────
     app.get('/api/remote-access', (_req, res) => {
         const config = loadRemoteConfig();
@@ -19927,12 +19944,34 @@ async function refreshHomeSessions() {
 // ── Execution Analytics ───────────────────
 async function refreshAdvisorAnalytics() {
   try {
-    const r = await apiFetch('/api/advisor/analytics');
+    const [statusR, r] = await Promise.all([
+      apiFetch('/api/advisor/status'),
+      apiFetch('/api/advisor/analytics'),
+    ]);
+    const status = await statusR.json();
     const data = await r.json();
     const container = document.getElementById('advisor-analytics-content');
 
     let html = '';
 
+    // Mode chip — surfaces the active rule-engine mode at a glance.
+    const modeColors = { off: 'var(--gray)', shadow: 'var(--blue)', primary: 'var(--green)' };
+    const modeColor = modeColors[status.mode] || 'var(--gray)';
+    const modeHints = {
+      off: 'Legacy TS path is the source of truth.',
+      shadow: 'Rule engine runs alongside the TS path; divergences are logged.',
+      primary: 'Rule engine is the source of truth.',
+    };
+    const modeHint = modeHints[status.mode] || '';
+    html += '<div style="display:flex;align-items:center;gap:12px;margin-bottom:16px;padding:10px 14px;background:var(--bg-elev);border-radius:8px;border-left:3px solid ' + modeColor + '">';
+    html += '<span style="font-size:11px;text-transform:uppercase;letter-spacing:0.05em;color:var(--text-dim)">Advisor mode</span>';
+    html += '<span style="font-weight:600;color:' + modeColor + '">' + esc(status.mode) + '</span>';
+    html += '<span style="font-size:12px;color:var(--text-dim)">' + esc(modeHint) + '</span>';
+    html += '<span style="margin-left:auto;font-size:11px;color:var(--text-dim)">' + status.ruleCount + ' rule' + (status.ruleCount === 1 ? '' : 's') + ' loaded';
+    if (status.userCount > 0) html += ' (' + status.userCount + ' user)';
+    html += '</span>';
+    html += '</div>';
+
     // Summary cards row
     html += '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin-bottom:20px">';
     const stats = [