clementine-agent 1.0.96 → 1.0.98

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

@@ -59,8 +59,15 @@ export declare class SelfImproveLoop {
     private parseJsonResponse;
     private withTimeout;
 }
+/** Validate that a proposed change has valid syntax for its target area. */
 export declare function validateProposal(area: string, target: string, proposedChange: string): {
     valid: boolean;
     error?: string;
 };
+/**
+ * Resolve the on-disk path for a prompt-override `target` string.
+ * Accepted forms: 'global', 'agent:<slug>', 'job:<jobName>'. Returns null
+ * for malformed targets.
+ */
+export declare function promptOverridePathForTarget(target: string): string | null;
 //# sourceMappingURL=self-improve.d.ts.map

package/dist/agent/self-improve.js

@@ -11,9 +11,10 @@
 import { randomBytes } from 'node:crypto';
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from 'node:fs';
 import matter from 'gray-matter';
+import { load as yamlLoad } from 'js-yaml';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, SELF_IMPROVE_DIR, SOUL_FILE, AGENTS_FILE, CRON_FILE, WORKFLOWS_DIR, VAULT_DIR, MEMORY_DB_PATH, AGENTS_DIR, PKG_DIR, CRON_REFLECTIONS_DIR, GOALS_DIR, } from '../config.js';
+import { BASE_DIR, SELF_IMPROVE_DIR, SOUL_FILE, AGENTS_FILE, CRON_FILE, WORKFLOWS_DIR, VAULT_DIR, MEMORY_DB_PATH, AGENTS_DIR, CRON_REFLECTIONS_DIR, GOALS_DIR, } from '../config.js';
 import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.self-improve' });
 // ── Defaults ─────────────────────────────────────────────────────────
@@ -23,9 +24,13 @@ const DEFAULT_CONFIG = {
     maxDurationMs: 3_600_000, // 1 hour
     acceptThreshold: 0.7,
     plateauLimit: 3,
-    // 'source' deprecated — self-improvement should produce data (cron, workflow, etc.),
-    // not engine TS edits. Re-add only with CLEMENTINE_ALLOW_SOURCE_EDITS=1.
-    areas: ['soul', 'cron', 'workflow', 'memory', 'agent', 'communication', 'goal'],
+    // 'source' deprecated — self-improvement produces data, not engine TS edits.
+    // 'advisor-rule' writes YAML to ~/.clementine/advisor-rules/user/.
+    // 'prompt-override' writes markdown to ~/.clementine/prompt-overrides/.
+    areas: [
+        'soul', 'cron', 'workflow', 'memory', 'agent', 'communication', 'goal',
+        'advisor-rule', 'prompt-override',
+    ],
     autoApply: true,
     sourceMode: 'skip',
 };
@@ -132,20 +137,22 @@ function checkDrift(proposedContent) {
     return { ok: similarity >= DRIFT_SIMILARITY_THRESHOLD, similarity };
 }
 /** Classify the risk level of a proposed change.
- * - low: agent prompts, individual cron job prompts — auto-apply safe
+ * - low: agent prompts, individual cron job prompts, advisor rules, prompt overrides
  * - medium: SOUL.md, AGENTS.md, MEMORY.md — needs owner approval
- * - high: source code — stays blocked
+ * - high: source code — stays blocked (deprecated path; kept for back-compat)
  */
 function classifyRisk(area) {
     switch (area) {
-        case 'agent': return 'low'; // Agent-scoped, easily reversible
-        case 'cron': return 'low'; // Cron prompt tweaks, low blast radius
-        case 'workflow': return 'low'; // Workflow definitions, scoped
+        case 'agent': return 'low';
+        case 'cron': return 'low';
+        case 'workflow': return 'low';
+        case 'advisor-rule': return 'low'; // YAML files, hot-reloaded, easily deleted
+        case 'prompt-override': return 'low'; // Markdown files, hot-reloaded, easily deleted
         case 'soul': return 'medium'; // Core personality — needs approval
         case 'communication': return 'medium'; // Global operating instructions
         case 'memory': return 'medium'; // Memory config
-        case 'source': return 'high'; // Code changes — always blocked in auto mode
         case 'goal': return 'medium'; // New goals need owner review before activating
+        case 'source': return 'high'; // Deprecated — quarantined in Phase 1
         default: return 'high';
     }
 }
@@ -836,7 +843,15 @@ export class SelfImproveLoop {
             `Area notes:\n` +
             `- For "goal": target = "{owner}/{goal-slug}" (e.g. "clementine/improve-reply-rates" or "ross-the-sdr/book-demos"). ` +
             `Propose when you observe a pattern in completed tasks or cron runs that suggests a missing or stale goal. ` +
-            `The proposedChange must be a JSON goal object with at minimum: title, description, priority, reviewFrequency.\n\n` +
+            `The proposedChange must be a JSON goal object with at minimum: title, description, priority, reviewFrequency.\n` +
+            `- For "advisor-rule": target = ruleId in kebab-case (e.g. "skip-turn-bump-on-unleashed"). ` +
+            `Use when the fix is a behavioral rule that affects ALL jobs matching some scope, not just one cron job. ` +
+            `Examples: "for unleashed jobs, never bump maxTurns" or "for ross-the-sdr, double timeout on max_turns". ` +
+            `The proposedChange must be a full advisor rule YAML body with: schemaVersion: 1, id (must match target), description, priority (use 100+ to override builtins), appliesTo, when[], then[]. ` +
+            `User rules at priority 100+ override engine builtins of the same id.\n` +
+            `- For "prompt-override": target = "global", "agent:<slug>", or "job:<jobName>" (e.g. "job:market-leader-followup"). ` +
+            `Use when a job/agent needs more standing guidance — markdown that gets prepended to its prompt. ` +
+            `The proposedChange is the markdown body (optionally with gray-matter frontmatter for priority/position).\n\n` +
             `Return your answer as a JSON object matching the schema: { "results": [ ... ] }. Up to 3 items. If absolutely nothing actionable today, return { "results": [] }.`;
         const analysisResult = await this.assistant.runPlanStep('si-analyze', analysisPrompt, {
             tier: 2,
@@ -915,10 +930,6 @@ export class SelfImproveLoop {
                 const agentFile = path.join(AGENTS_DIR, target, 'agent.md');
                 return existsSync(agentFile) ? readFileSync(agentFile, 'utf-8') : '';
             }
-            case 'source': {
-                const srcFile = path.join(PKG_DIR, 'src', target);
-                return existsSync(srcFile) ? readFileSync(srcFile, 'utf-8') : '';
-            }
             case 'communication':
                 return existsSync(AGENTS_FILE) ? readFileSync(AGENTS_FILE, 'utf-8') : '';
             case 'memory': {
@@ -946,6 +957,23 @@ export class SelfImproveLoop {
                     return '(no goals yet for this owner)';
                 return goals.map((g) => `[${g.status ?? 'unknown'}] ${g.title}: ${(g.description ?? '').slice(0, 120)}`).join('\n');
             }
+            case 'advisor-rule': {
+                // target = ruleId (kebab-case). Show user override file if present, else builtin.
+                const userPath = path.join(BASE_DIR, 'advisor-rules', 'user', `${target}.yaml`);
+                if (existsSync(userPath))
+                    return readFileSync(userPath, 'utf-8');
+                const builtinPath = path.join(BASE_DIR, 'advisor-rules', 'builtin', `${target}.yaml`);
+                if (existsSync(builtinPath))
+                    return readFileSync(builtinPath, 'utf-8');
+                return '(no existing advisor rule for this id — proposing a new one)';
+            }
+            case 'prompt-override': {
+                // target = 'global' | 'agent:<slug>' | 'job:<jobName>'
+                const filePath = promptOverridePathForTarget(target);
+                if (filePath && existsSync(filePath))
+                    return readFileSync(filePath, 'utf-8');
+                return '(no existing prompt override for this scope — proposing a new one)';
+            }
             default:
                 return '';
         }
@@ -1011,38 +1039,10 @@ export class SelfImproveLoop {
         if (!targetPath) {
             return `Cannot resolve target path for area=${pending.area}, target=${pending.target}`;
         }
-        // Route source changes through the safe pipeline
+        // 'source' area is deprecated (Phase 1 quarantine). Reject up-front so a
+        // misbehaving proposal cannot reach the safeSourceEdit primitive.
         if (pending.area === 'source') {
-            const { safeSourceEdit } = await import('./safe-restart.js');
-            const result = await safeSourceEdit(PKG_DIR, [
-                { relativePath: `src/${pending.target}`, content: pending.proposedChange },
-            ], { experimentId, reason: `self-improve: ${pending.hypothesis.slice(0, 60)}`, description: pending.hypothesis });
-            if (!result.success) {
-                return `Source edit failed: ${result.error}${result.preflightErrors ? '\n' + result.preflightErrors.join('\n') : ''}`;
-            }
-            // Update experiment log — mark as approved
-            this.updateExperimentStatus(experimentId, 'approved');
-            try {
-                unlinkSync(pendingFile);
-            }
-            catch { /* ignore */ }
-            const state = this.loadState();
-            state.pendingApprovals = Math.max(0, state.pendingApprovals - 1);
-            this.saveState(state);
-            // Schedule impact measurement for 24h later
-            try {
-                appendFileSync(IMPACT_CHECKS_FILE, JSON.stringify({
-                    experimentId,
-                    area: pending.area,
-                    target: pending.target,
-                    appliedAt: new Date().toISOString(),
-                    checkAfterMs: 24 * 60 * 60 * 1000,
-                }) + '\n');
-            }
-            catch (err) {
-                logger.warn({ err }, 'Failed to schedule impact check');
-            }
-            return `Applied source change to ${pending.target} — restart triggered.`;
+            return 'source area is deprecated — propose advisor-rule or prompt-override instead';
         }
         // Goal area: parse JSON, inject required fields, ensure parent dir exists
         if (pending.area === 'goal') {
@@ -1095,6 +1095,7 @@ export class SelfImproveLoop {
             }
         }
         // Write the change (non-source areas)
+        mkdirSync(path.dirname(targetPath), { recursive: true });
         writeFileSync(targetPath, pending.proposedChange);
         // Record version for rollback lineage
         this.recordVersion(experimentId, pending.area, pending.target, pending.hypothesis, pending.before);
@@ -1680,9 +1681,6 @@ export class SelfImproveLoop {
             case 'agent': {
                 return path.join(AGENTS_DIR, target, 'agent.md');
             }
-            case 'source': {
-                return path.join(PKG_DIR, 'src', target);
-            }
             case 'communication':
                 return AGENTS_FILE;
             case 'memory':
@@ -1696,6 +1694,12 @@ export class SelfImproveLoop {
                     return path.join(GOALS_DIR, `${goalSlug}.json`);
                 return path.join(AGENTS_DIR, owner, 'goals', `${goalSlug}.json`);
             }
+            case 'advisor-rule':
+                if (!/^[a-z0-9-]+$/.test(target))
+                    return null;
+                return path.join(BASE_DIR, 'advisor-rules', 'user', `${target}.yaml`);
+            case 'prompt-override':
+                return promptOverridePathForTarget(target);
             default:
                 return null;
         }
@@ -1733,22 +1737,6 @@ export class SelfImproveLoop {
 }
 // ── Utility ──────────────────────────────────────────────────────────
 /** Validate that a proposed change has valid syntax for its target area. */
-/** Files that must never be modified by self-improvement (catastrophic blast radius or self-referential). */
-const SOURCE_BLOCKLIST = new Set([
-    'config.ts',
-    'types.ts',
-    'gateway/router.ts',
-    'gateway/lanes.ts',
-    'gateway/heartbeat-scheduler.ts',
-    'gateway/cron-scheduler.ts',
-    'gateway/security-scanner.ts',
-    'agent/self-improve.ts',
-    'agent/safe-restart.ts',
-    'agent/source-mods.ts',
-    'cli/index.ts',
-    'cli/dashboard.ts',
-    'security/scanner.ts',
-]);
 export function validateProposal(area, target, proposedChange) {
     if (!proposedChange.trim()) {
         return { valid: false, error: 'Proposed change is empty' };
@@ -1790,16 +1778,71 @@ export function validateProposal(area, target, proposedChange) {
         }
     }
     if (area === 'source') {
-        // Check blocklist
-        if (SOURCE_BLOCKLIST.has(target)) {
-            return { valid: false, error: `Source file '${target}' is in the blocklist and cannot be modified by self-improvement` };
+        // Deprecated — Phase 1 quarantined source self-edit. Reject up front so
+        // a misbehaving LLM proposal doesn't even get cached.
+        return { valid: false, error: 'source area is deprecated; propose advisor-rule or prompt-override instead' };
+    }
+    if (area === 'advisor-rule') {
+        // Must parse as YAML and have schemaVersion: 1, id matching target, when[], then[].
+        if (!/^[a-z0-9-]+$/.test(target)) {
+            return { valid: false, error: `advisor-rule target must be kebab-case (got "${target}")` };
+        }
+        let parsed;
+        try {
+            parsed = yamlLoad(proposedChange);
+        }
+        catch (err) {
+            return { valid: false, error: `advisor-rule YAML parse error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+        if (!parsed || typeof parsed !== 'object') {
+            return { valid: false, error: 'advisor-rule body did not parse as a YAML object' };
+        }
+        const r = parsed;
+        if (r.schemaVersion !== 1)
+            return { valid: false, error: 'advisor-rule must declare schemaVersion: 1' };
+        if (typeof r.id !== 'string' || r.id !== target) {
+            return { valid: false, error: `advisor-rule id must match target ("${target}")` };
+        }
+        if (!Array.isArray(r.when) || !Array.isArray(r.then)) {
+            return { valid: false, error: 'advisor-rule must have when[] and then[] arrays' };
+        }
+    }
+    if (area === 'prompt-override') {
+        // target format: 'global' | 'agent:<slug>' | 'job:<jobName>'
+        const path = promptOverridePathForTarget(target);
+        if (!path) {
+            return { valid: false, error: `prompt-override target must be 'global', 'agent:<slug>', or 'job:<jobName>' (got "${target}")` };
+        }
+        if (proposedChange.length > 20_000) {
+            return { valid: false, error: 'prompt-override content exceeds 20KB sanity bound' };
         }
-        // Size sanity: reject wholesale rewrites (proposed content > 2x original would be caught by caller).
-        // Source proposals may be small patches or modules without import/export statements;
-        // callers that apply source changes do the syntax-aware validation.
     }
     return { valid: true };
 }
+/**
+ * Resolve the on-disk path for a prompt-override `target` string.
+ * Accepted forms: 'global', 'agent:<slug>', 'job:<jobName>'. Returns null
+ * for malformed targets.
+ */
+export function promptOverridePathForTarget(target) {
+    const root = path.join(BASE_DIR, 'prompt-overrides');
+    if (target === 'global')
+        return path.join(root, '_global.md');
+    const idx = target.indexOf(':');
+    if (idx <= 0)
+        return null;
+    const scope = target.slice(0, idx);
+    const key = target.slice(idx + 1);
+    if (!key)
+        return null;
+    if (/[\/\\\.]/.test(key))
+        return null;
+    if (scope === 'agent')
+        return path.join(root, 'agents', `${key}.md`);
+    if (scope === 'job')
+        return path.join(root, 'jobs', `${key}.md`);
+    return null;
+}
 function ensureDirs() {
     for (const dir of [SELF_IMPROVE_DIR, PENDING_DIR]) {
         if (!existsSync(dir)) {

package/dist/gateway/failure-diagnostics.d.ts

@@ -27,23 +27,40 @@ export type FixOperation = {
     op: 'remove';
     field: string;
 };
+/** CRON.md frontmatter edit (the original auto-apply shape). */
+export interface AutoApplyCron {
+    kind?: 'cron';
+    agentSlug?: string;
+    operations: FixOperation[];
+}
+/** Write a YAML rule to ~/.clementine/advisor-rules/user/<ruleId>.yaml */
+export interface AutoApplyAdvisorRule {
+    kind: 'advisor-rule';
+    ruleId: string;
+    yamlContent: string;
+}
+/** Write a markdown override to ~/.clementine/prompt-overrides/... */
+export interface AutoApplyPromptOverride {
+    kind: 'prompt-override';
+    scope: 'global' | 'agent' | 'job';
+    scopeKey?: string;
+    content: string;
+}
+export type AutoApply = AutoApplyCron | AutoApplyAdvisorRule | AutoApplyPromptOverride;
 export interface Diagnosis {
     rootCause: string;
     confidence: 'high' | 'medium' | 'low';
     proposedFix: {
-        type: 'config_change' | 'prompt_change' | 'agent_scope' | 'disable' | 'credential_refresh' | 'escalate_to_owner';
+        type: 'config_change' | 'prompt_change' | 'agent_scope' | 'disable' | 'credential_refresh' | 'advisor_rule' | 'prompt_override' | 'escalate_to_owner';
         details: string;
         diff?: string;
         /**
-         * When present, the fix can be applied with one click via the
-         * /api/cron/broken-jobs/:jobName/apply-fix endpoint. Operations are
-         * silently filtered against EDITABLE_FIELDS — a proposal that mixes
-         * safe and unsafe edits gets the unsafe ones dropped.
+         * When present, the fix can be applied with one click via the dashboard's
+         * apply-fix endpoint. Three shapes (kind=cron|advisor-rule|prompt-override).
+         * Each kind has its own validator that runs in sanitizeAutoApply before
+         * the proposal is cached, and again in fix-applier before any write.
          */
-        autoApply?: {
-            agentSlug?: string;
-            operations: FixOperation[];
-        };
+        autoApply?: AutoApply;
     };
     riskLevel: 'low' | 'medium' | 'high';
     generatedAt: string;

package/dist/gateway/failure-diagnostics.js

@@ -173,28 +173,43 @@ function buildPrompt(broken, jobDef, agentProfile, recentRuns) {
         '',
         '## Auto-apply contract',
         '',
-        'When (and ONLY when) the fix is a simple edit to one of these scalar fields — tier, mode, max_hours, max_turns, max_retries, enabled, agentSlug, work_dir, model, always_deliver, after, timeout_ms — also populate `proposedFix.autoApply`. The owner can one-click approve it from the dashboard.',
+        'When the fix is mechanical — set or remove a known scalar field, write a small advisor rule, or add prompt guidance — ALSO populate `proposedFix.autoApply`. The owner can one-click approve it. There are three KINDS of auto-apply, pick the one that matches:',
         '',
-        'For multi-line fields (prompt, pre_check, context, success_criteria), or for credential refreshes, or any change you are not very confident about: OMIT autoApply entirely. The owner will handle those manually.',
+        '### kind: "cron" (default — edit CRON.md frontmatter)',
+        'Use for: tier, mode, max_hours, max_turns, max_retries, enabled, agentSlug, work_dir, model, always_deliver, after, timeout_ms.',
+        'Shape: { "kind": "cron", "agentSlug"?: "...", "operations": [...] }',
+        'Operations: { "op": "set", "field": "<name>", "value": <scalar> } or { "op": "remove", "field": "<name>" }.',
+        'If the job is agent-scoped (job name has ":"), set agentSlug to the prefix.',
+        'Examples:',
+        '- Remove unleashed + companion + cap turns: { "kind": "cron", "operations": [{"op":"remove","field":"mode"}, {"op":"remove","field":"max_hours"}, {"op":"set","field":"max_turns","value":25}] }',
+        '- Bump maxTurns: { "kind": "cron", "operations": [{"op":"set","field":"max_turns","value":10}] }',
         '',
-        `If the job is agent-scoped (job name includes ":"), set autoApply.agentSlug to the part BEFORE the colon. Otherwise omit it (global CRON.md).`,
+        '### kind: "advisor-rule" (write a YAML rule to ~/.clementine/advisor-rules/user/)',
+        'Use when the fix is a behavioral rule that should affect ALL jobs matching some scope, not just one cron job. Examples: "for unleashed jobs, never bump maxTurns" or "for ross-the-sdr, always set timeout to 900s on max_turns errors".',
+        'Shape: { "kind": "advisor-rule", "ruleId": "kebab-case-id", "yamlContent": "<full yaml body>" }',
+        'The YAML body must be a valid advisor rule (schemaVersion: 1, id, description, priority, when, then). User rules at priority 100+ override builtins of the same id.',
+        'Example:',
+        '{ "kind": "advisor-rule", "ruleId": "ross-aggressive-timeout", "yamlContent": "schemaVersion: 1\\nid: ross-aggressive-timeout\\ndescription: Bump timeout for ross\\npriority: 105\\nappliesTo:\\n  agentSlug: ross-the-sdr\\nwhen:\\n  - kind: recentTimeoutHits\\n    window: 5\\n    atLeast: 1\\nthen:\\n  - kind: bumpTimeoutMs\\n    multiplier: 2.0" }',
         '',
-        'Operations use the shape { "op": "set", "field": "<name>", "value": <scalar> } or { "op": "remove", "field": "<name>" }. Values are strings, numbers, or booleans.',
+        '### kind: "prompt-override" (write a markdown file to ~/.clementine/prompt-overrides/)',
+        'Use when the fix is "give the LLM more guidance for this job/agent". Examples: a job consistently misses an edge case, an agent needs a reminder about output format.',
+        'Shape: { "kind": "prompt-override", "scope": "job"|"agent"|"global", "scopeKey": "<job or agent name>", "content": "<markdown body>" }',
+        'For scope=global, omit scopeKey. For scope=agent, scopeKey is the agent slug. For scope=job, scopeKey is the BARE job name (no agent prefix).',
+        'Example:',
+        '{ "kind": "prompt-override", "scope": "job", "scopeKey": "market-leader-followup", "content": "If the inbox query returns 0 rows, batch the duplicate-task cleanup in groups of 50 using bash heredoc loops. Do not enumerate task IDs in the prompt." }',
         '',
-        'Examples:',
-        '- Remove unleashed mode + its companion: operations: [{"op":"remove","field":"mode"}, {"op":"remove","field":"max_hours"}, {"op":"set","field":"max_turns","value":25}]',
-        '- Scope a broken global job to Ross\'s profile: operations: [{"op":"set","field":"agentSlug","value":"ross-the-sdr"}]',
-        '- Bump maxTurns on an under-resourced job: operations: [{"op":"set","field":"max_turns","value":10}]',
+        '## When NOT to use autoApply',
+        'For credential refreshes, multi-line CRON.md edits beyond the scalar allowlist, or any change you are not confident about: OMIT autoApply entirely. The owner will handle those manually.',
         '',
         '## Output schema (JSON only, no markdown fences):',
         '{',
-        '  "rootCause": "1-2 sentences explaining WHY the job is failing, referencing specific fields or error patterns from the CURRENT config",',
+        '  "rootCause": "1-2 sentences explaining WHY the job is failing",',
         '  "confidence": "high|medium|low",',
         '  "proposedFix": {',
-        '    "type": "config_change|prompt_change|agent_scope|disable|credential_refresh|escalate_to_owner",',
-        '    "details": "prose description of the fix, citing the exact field(s) to change",',
-        '    "diff": "optional: exact before/after diff",',
-        '    "autoApply": "optional: { agentSlug?, operations: [...] } — ONLY for simple scalar-field edits on the allowlist"',
+        '    "type": "config_change|prompt_change|agent_scope|disable|credential_refresh|advisor_rule|prompt_override|escalate_to_owner",',
+        '    "details": "prose description of the fix",',
+        '    "diff": "optional: before/after diff",',
+        '    "autoApply": "optional: one of the three shapes above"',
         '  },',
         '  "riskLevel": "low|medium|high"',
         '}',
@@ -230,32 +245,42 @@ function parseResponse(raw) {
     }
 }
 /**
- * Strictly validate and filter autoApply. Drops ops on non-allowlisted fields
- * silently (rather than rejecting the whole diagnosis). Returns null if
- * nothing valid remains.
+ * Strictly validate and filter autoApply. Dispatches on `kind` (default 'cron'
+ * for back-compat). Returns null if validation fails for the chosen kind.
  */
 function sanitizeAutoApply(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
     const obj = raw;
+    const kind = typeof obj.kind === 'string' ? obj.kind : 'cron';
+    if (kind === 'cron')
+        return sanitizeAutoApplyCron(obj);
+    if (kind === 'advisor-rule')
+        return sanitizeAutoApplyAdvisorRule(obj);
+    if (kind === 'prompt-override')
+        return sanitizeAutoApplyPromptOverride(obj);
+    return null;
+}
+function sanitizeAutoApplyCron(raw) {
+    const obj = raw;
     if (!Array.isArray(obj.operations))
         return null;
     const operations = [];
     for (const op of obj.operations) {
         if (!op || typeof op !== 'object')
             continue;
-        const raw = op;
-        if (typeof raw.field !== 'string')
+        const r = op;
+        if (typeof r.field !== 'string')
             continue;
-        if (!EDITABLE_FIELDS.has(raw.field))
+        if (!EDITABLE_FIELDS.has(r.field))
             continue;
-        if (raw.op === 'remove') {
-            operations.push({ op: 'remove', field: raw.field });
+        if (r.op === 'remove') {
+            operations.push({ op: 'remove', field: r.field });
         }
-        else if (raw.op === 'set') {
-            const v = raw.value;
+        else if (r.op === 'set') {
+            const v = r.value;
             if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
-                operations.push({ op: 'set', field: raw.field, value: v });
+                operations.push({ op: 'set', field: r.field, value: v });
             }
         }
     }
@@ -264,7 +289,46 @@ function sanitizeAutoApply(raw) {
     const agentSlug = typeof obj.agentSlug === 'string' && /^[a-z0-9-]+$/i.test(obj.agentSlug)
         ? obj.agentSlug
         : undefined;
-    return agentSlug ? { agentSlug, operations } : { operations };
+    return { kind: 'cron', operations, ...(agentSlug ? { agentSlug } : {}) };
+}
+function sanitizeAutoApplyAdvisorRule(raw) {
+    const obj = raw;
+    if (typeof obj.ruleId !== 'string' || !obj.ruleId.trim())
+        return null;
+    if (!/^[a-z0-9-]+$/.test(obj.ruleId))
+        return null; // safe filename
+    if (typeof obj.yamlContent !== 'string' || !obj.yamlContent.trim())
+        return null;
+    if (obj.yamlContent.length > 10_000)
+        return null; // sanity bound
+    return {
+        kind: 'advisor-rule',
+        ruleId: obj.ruleId,
+        yamlContent: obj.yamlContent,
+    };
+}
+function sanitizeAutoApplyPromptOverride(raw) {
+    const obj = raw;
+    if (obj.scope !== 'global' && obj.scope !== 'agent' && obj.scope !== 'job')
+        return null;
+    if (typeof obj.content !== 'string' || !obj.content.trim())
+        return null;
+    if (obj.content.length > 20_000)
+        return null; // sanity bound
+    if (obj.scope === 'global') {
+        return { kind: 'prompt-override', scope: 'global', content: obj.content };
+    }
+    // agent or job — require scopeKey, validate as safe filename
+    if (typeof obj.scopeKey !== 'string' || !obj.scopeKey)
+        return null;
+    if (!/^[a-zA-Z0-9_:-]+$/.test(obj.scopeKey))
+        return null;
+    return {
+        kind: 'prompt-override',
+        scope: obj.scope,
+        scopeKey: obj.scopeKey,
+        content: obj.content,
+    };
 }
 /**
  * Diagnose one broken job. Returns a cached diagnosis if one exists and is

package/dist/gateway/failure-monitor.d.ts

@@ -25,28 +25,7 @@ export interface BrokenJob {
     circuitBreakerEngagedAt: string | null;
     lastAdvisorOpinion: string | null;
     /** Populated asynchronously by the diagnostic agent when available. */
-    diagnosis?: {
-        rootCause: string;
-        confidence: 'high' | 'medium' | 'low';
-        proposedFix: {
-            type: string;
-            details: string;
-            diff?: string;
-            autoApply?: {
-                agentSlug?: string;
-                operations: Array<{
-                    op: 'set';
-                    field: string;
-                    value: string | number | boolean;
-                } | {
-                    op: 'remove';
-                    field: string;
-                }>;
-            };
-        };
-        riskLevel: 'low' | 'medium' | 'high';
-        generatedAt: string;
-    };
+    diagnosis?: import('./failure-diagnostics.js').Diagnosis;
 }
 /**
  * Compute the current set of broken jobs by scanning all run logs.

package/dist/gateway/fix-applier.d.ts

@@ -11,7 +11,7 @@
  * Every apply writes a .bak next to the CRON.md and appends to an audit
  * log before touching the file.
  */
-import { type FixOperation } from './failure-diagnostics.js';
+import { type AutoApply, type FixOperation } from './failure-diagnostics.js';
 export interface ApplyResult {
     ok: boolean;
     message: string;
@@ -20,15 +20,19 @@ export interface ApplyResult {
     skippedOps?: FixOperation[];
     diff?: string;
 }
+export interface ApplyOptions {
+    dryRun?: boolean;
+    /** Override BASE_DIR for advisor-rule and prompt-override write paths. Tests only. */
+    baseDir?: string;
+}
 /**
- * Apply a proposed fix to the right CRON.md file. Idempotent with respect
- * to already-applied ops (remove on a missing field is a no-op, set on a
- * matching value is a no-op).
+ * Apply a proposed fix to the right target. Dispatches on autoApply.kind:
+ *   'cron'             — edit CRON.md frontmatter (the original path)
+ *   'advisor-rule'     — write a YAML rule under ~/.clementine/advisor-rules/user/
+ *   'prompt-override'  — write a markdown override under ~/.clementine/prompt-overrides/
+ *
+ * Each path has its own backup/audit. All idempotent: re-applying the same
+ * fix produces the same on-disk state.
  */
-export declare function applyFix(jobName: string, autoApply: {
-    agentSlug?: string;
-    operations: FixOperation[];
-}, opts?: {
-    dryRun?: boolean;
-}): ApplyResult;
+export declare function applyFix(jobName: string, autoApply: AutoApply, opts?: ApplyOptions): ApplyResult;
 //# sourceMappingURL=fix-applier.d.ts.map

package/dist/gateway/fix-applier.js

@@ -11,11 +11,12 @@
  * Every apply writes a .bak next to the CRON.md and appends to an audit
  * log before touching the file.
  */
-import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
+import yaml from 'js-yaml';
 import { AGENTS_DIR, BASE_DIR, CRON_FILE } from '../config.js';
-import { EDITABLE_FIELDS } from './failure-diagnostics.js';
+import { EDITABLE_FIELDS, } from './failure-diagnostics.js';
 const logger = pino({ name: 'clementine.fix-applier' });
 const AUDIT_FILE = path.join(BASE_DIR, 'cron', 'fix-applier.log');
 /**
@@ -232,11 +233,26 @@ function findBlockEnd(lines, start) {
     return lines.length;
 }
 /**
- * Apply a proposed fix to the right CRON.md file. Idempotent with respect
- * to already-applied ops (remove on a missing field is a no-op, set on a
- * matching value is a no-op).
+ * Apply a proposed fix to the right target. Dispatches on autoApply.kind:
+ *   'cron'             — edit CRON.md frontmatter (the original path)
+ *   'advisor-rule'     — write a YAML rule under ~/.clementine/advisor-rules/user/
+ *   'prompt-override'  — write a markdown override under ~/.clementine/prompt-overrides/
+ *
+ * Each path has its own backup/audit. All idempotent: re-applying the same
+ * fix produces the same on-disk state.
  */
 export function applyFix(jobName, autoApply, opts = {}) {
+    // Default 'cron' for back-compat with old AutoApplyCron objects without kind.
+    const kind = autoApply.kind ?? 'cron';
+    if (kind === 'cron')
+        return applyCronFix(jobName, autoApply, opts);
+    if (kind === 'advisor-rule')
+        return applyAdvisorRuleFix(jobName, autoApply, opts);
+    if (kind === 'prompt-override')
+        return applyPromptOverrideFix(jobName, autoApply, opts);
+    return { ok: false, message: `Unknown autoApply.kind: ${String(kind)}` };
+}
+function applyCronFix(jobName, autoApply, opts) {
     const cronFile = resolveCronFile(jobName, autoApply);
     if (!cronFile) {
         return { ok: false, message: `No CRON.md found for ${jobName}` };
@@ -280,6 +296,7 @@ export function applyFix(jobName, autoApply, opts = {}) {
     const newContent = newLines.join('\n');
     writeFileSync(cronFile, newContent);
     appendAudit({
+        kind: 'cron',
         jobName,
         file: cronFile,
         applied,
@@ -296,6 +313,108 @@ export function applyFix(jobName, autoApply, opts = {}) {
         diff,
     };
 }
+// ── Advisor rule writer ──────────────────────────────────────────────
+function userRulesDir(baseDir) {
+    return path.join(baseDir, 'advisor-rules', 'user');
+}
+function applyAdvisorRuleFix(jobName, autoApply, opts) {
+    const targetDir = userRulesDir(opts.baseDir ?? BASE_DIR);
+    // Validate that the YAML parses and has the minimum schema shape. Don't
+    // require full Phase 2 zod validation here — the loader will reject invalid
+    // rules at read time and the next reload — but catch obvious malformed input.
+    let parsed;
+    try {
+        parsed = yaml.load(autoApply.yamlContent);
+    }
+    catch (err) {
+        return { ok: false, message: `Invalid YAML in advisor-rule body: ${String(err)}` };
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return { ok: false, message: 'advisor-rule yamlContent did not parse as a YAML object' };
+    }
+    const r = parsed;
+    if (r.schemaVersion !== 1) {
+        return { ok: false, message: 'advisor-rule must declare schemaVersion: 1' };
+    }
+    if (typeof r.id !== 'string' || r.id !== autoApply.ruleId) {
+        return { ok: false, message: `advisor-rule yamlContent id must match ruleId="${autoApply.ruleId}"` };
+    }
+    if (!Array.isArray(r.when) || !Array.isArray(r.then)) {
+        return { ok: false, message: 'advisor-rule must have when[] and then[] arrays' };
+    }
+    const targetPath = path.join(targetDir, `${autoApply.ruleId}.yaml`);
+    const diff = `+ advisor-rule ${autoApply.ruleId} → ${targetPath}`;
+    if (opts.dryRun) {
+        return { ok: true, message: 'Dry run: advisor-rule would be written', file: targetPath, diff };
+    }
+    try {
+        mkdirSync(targetDir, { recursive: true });
+        const tmp = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, autoApply.yamlContent);
+        renameSync(tmp, targetPath);
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to write advisor rule: ${String(err)}` };
+    }
+    appendAudit({ kind: 'advisor-rule', jobName, file: targetPath, ruleId: autoApply.ruleId, diff });
+    logger.info({ jobName, ruleId: autoApply.ruleId, file: targetPath }, 'Applied advisor-rule fix');
+    return {
+        ok: true,
+        message: `Wrote advisor rule ${autoApply.ruleId} (hot-reloads on next eval)`,
+        file: targetPath,
+        diff,
+    };
+}
+// ── Prompt override writer ───────────────────────────────────────────
+function promptOverridesDir(baseDir) {
+    return path.join(baseDir, 'prompt-overrides');
+}
+function applyPromptOverrideFix(jobName, autoApply, opts) {
+    const root = promptOverridesDir(opts.baseDir ?? BASE_DIR);
+    // Resolve target path from scope.
+    let targetPath;
+    if (autoApply.scope === 'global') {
+        targetPath = path.join(root, '_global.md');
+    }
+    else {
+        if (!autoApply.scopeKey) {
+            return { ok: false, message: `prompt-override scope=${autoApply.scope} requires scopeKey` };
+        }
+        if (/[\/\\\.]/.test(autoApply.scopeKey)) {
+            return { ok: false, message: 'prompt-override scopeKey cannot contain "/", "\\", or "."' };
+        }
+        const sub = autoApply.scope === 'agent' ? 'agents' : 'jobs';
+        targetPath = path.join(root, sub, `${autoApply.scopeKey}.md`);
+    }
+    const diff = `+ prompt-override ${autoApply.scope}${autoApply.scopeKey ? `:${autoApply.scopeKey}` : ''} → ${targetPath}`;
+    if (opts.dryRun) {
+        return { ok: true, message: 'Dry run: prompt-override would be written', file: targetPath, diff };
+    }
+    try {
+        mkdirSync(path.dirname(targetPath), { recursive: true });
+        const tmp = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, autoApply.content);
+        renameSync(tmp, targetPath);
+    }
+    catch (err) {
+        return { ok: false, message: `Failed to write prompt override: ${String(err)}` };
+    }
+    appendAudit({
+        kind: 'prompt-override',
+        jobName,
+        file: targetPath,
+        scope: autoApply.scope,
+        scopeKey: autoApply.scopeKey,
+        diff,
+    });
+    logger.info({ jobName, scope: autoApply.scope, scopeKey: autoApply.scopeKey, file: targetPath }, 'Applied prompt-override fix');
+    return {
+        ok: true,
+        message: `Wrote prompt override ${autoApply.scope}${autoApply.scopeKey ? `:${autoApply.scopeKey}` : ''}`,
+        file: targetPath,
+        diff,
+    };
+}
 function appendAudit(entry) {
     try {
         mkdirSync(path.dirname(AUDIT_FILE), { recursive: true });

package/dist/types.d.ts

@@ -501,7 +501,7 @@ export interface SelfImproveExperiment {
     startedAt: string;
     finishedAt: string;
     durationMs: number;
-    area: 'soul' | 'cron' | 'workflow' | 'memory' | 'agent' | 'source' | 'communication' | 'goal';
+    area: 'soul' | 'cron' | 'workflow' | 'memory' | 'agent' | 'source' | 'communication' | 'goal' | 'advisor-rule' | 'prompt-override';
     target: string;
     hypothesis: string;
     proposedChange: string;
@@ -549,7 +549,7 @@ export interface SelfImproveConfig {
     maxDurationMs: number;
     acceptThreshold: number;
     plateauLimit: number;
-    areas: ('soul' | 'cron' | 'workflow' | 'memory' | 'agent' | 'source' | 'communication' | 'goal')[];
+    areas: ('soul' | 'cron' | 'workflow' | 'memory' | 'agent' | 'source' | 'communication' | 'goal' | 'advisor-rule' | 'prompt-override')[];
     /** Enable tiered auto-apply: low-risk changes apply without approval. Default: false. */
     autoApply?: boolean;
     /** Target a specific agent slug (for per-agent improvement cycles). */

package/package.json

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