@jack200714/mafw 4.5.1

package/gateway/dist/automation-engine.js

@@ -0,0 +1,729 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationEngine = exports.actionRegistry = void 0;
+exports.unregisterAction = unregisterAction;
+exports.resetActionRegistry = resetActionRegistry;
+exports.parseDuration = parseDuration;
+const logger_1 = require("./core/utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cron_1 = require("cron");
+const harmonic_index_1 = require("./core/memory/harmonic-index");
+const energy_system_1 = require("./core/memory/energy-system");
+const review_scheduler_1 = require("./core/memory/review-scheduler");
+const cognitive_graph_1 = require("./core/memory/cognitive-graph");
+const abstraction_distiller_1 = require("./core/memory/abstraction-distiller");
+const event_bus_1 = require("./event-bus");
+exports.actionRegistry = new Map();
+function unregisterAction(type) {
+    return exports.actionRegistry.delete(type);
+}
+function resetActionRegistry() {
+    exports.actionRegistry.clear();
+}
+exports.actionRegistry.set('memory:distill', async (_rule, engine) => {
+    logger_1.log.info('[AutomationEngine] Starting memory distillation...');
+    const indexManager = new harmonic_index_1.HarmonicIndexManager(engine.mafwDir);
+    const result = await (0, abstraction_distiller_1.runDistillation)(indexManager, engine.mafwDir);
+    logger_1.log.info(`[AutomationEngine] Distillation complete: created ${result.created}, locked ${result.locked}`);
+    event_bus_1.eventBus.emit('memory_distillation_complete', {
+        type: 'memory_distillation_complete',
+        created: result.created,
+        locked: result.locked,
+        errors: result.errors,
+    });
+});
+exports.actionRegistry.set('memory:decay', async (_rule, engine) => {
+    logger_1.log.info('[AutomationEngine] Running energy decay...');
+    const indexManager = new harmonic_index_1.HarmonicIndexManager(engine.mafwDir);
+    const index = indexManager.getIndex();
+    const energySystem = new energy_system_1.EnergySystem();
+    const now = Date.now();
+    const nowIso = new Date(now).toISOString();
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    // One-time migration (index v1 → v2): stamp last_decay_at = now WITHOUT
+    // applying decay. Pre-fix passes computed full-age decay from created_at
+    // on every run, accumulating r·n(n+1)/2 (quadratic) loss — entries are
+    // already over-decayed, so the past is forgiven and incremental decay
+    // starts from this baseline.
+    if ((index.version || 1) < 2) {
+        const migrated = indexManager.migrateDecayBaseline(nowIso);
+        logger_1.log.info(`[AutomationEngine] Migrated ${migrated} entries to incremental decay baseline (v2)`);
+        return;
+    }
+    let decayed = 0;
+    for (const entry of index.entries) {
+        const salience = entry.salience || 1.0;
+        // Incremental decay: days since the last APPLIED decay (entries created
+        // after the migration have no last_decay_at yet → fall back to created_at).
+        const base = new Date(entry.last_decay_at || entry.created_at || 0).getTime();
+        const daysSinceDecay = base > 0 ? Math.max(0, (now - base) / DAY_MS) : 0;
+        // Pure time decay — no event bonus. The `retrieved` bonus belongs to real
+        // recall paths (search), not to the background decay pass.
+        const decayedEnergy = energySystem.decay(entry.energy, daysSinceDecay, salience);
+        const diff = entry.energy - decayedEnergy;
+        if (diff > 0.005) {
+            indexManager.updateEnergy(entry.id, -(diff));
+            // Stamp only when decay is actually applied — otherwise days keep
+            // accumulating until the diff crosses the write threshold (prevents
+            // starvation of low-salience / low-rate entries).
+            indexManager.stampDecay(entry.id, nowIso);
+            decayed++;
+        }
+    }
+    indexManager.save();
+    logger_1.log.info(`[AutomationEngine] Energy decay applied to ${decayed} entries`);
+});
+exports.actionRegistry.set('memory:review', async (_rule, engine) => {
+    logger_1.log.info('[AutomationEngine] Checking review queue...');
+    const indexManager = new harmonic_index_1.HarmonicIndexManager(engine.mafwDir);
+    const scheduler = new review_scheduler_1.ReviewScheduler(indexManager, engine.mafwDir);
+    scheduler.tick();
+    const queue = scheduler.getReviewQueue();
+    logger_1.log.info(`[AutomationEngine] Review queue: ${queue.length} items due`);
+});
+exports.actionRegistry.set('memory:prune', async (_rule, engine) => {
+    logger_1.log.info('[AutomationEngine] Pruning cognitive graph...');
+    const graph = new cognitive_graph_1.CognitiveGraphManager(engine.mafwDir);
+    const before = graph.getGraph().edges.length;
+    graph.prune(0.1);
+    const after = graph.getGraph().edges.length;
+    const pruned = before - after;
+    if (pruned > 0) {
+        logger_1.log.info(`[AutomationEngine] Pruned ${pruned} low-weight edges`);
+    }
+    else {
+        logger_1.log.info('[AutomationEngine] No edges to prune');
+    }
+});
+class AutomationEngine {
+    rules = new Map();
+    jobs = new Map();
+    mafwDir;
+    _ledger;
+    _runtimeClient;
+    eventListeners = new Map();
+    lastFireTimes = new Map();
+    reportedPairs = new Set();
+    eventHandlerRefs = new Map();
+    constructor(mafwDir) {
+        this.mafwDir = mafwDir;
+    }
+    setLedger(ledger) {
+        this._ledger = ledger;
+    }
+    setRuntimeClient(client) {
+        this._runtimeClient = client;
+    }
+    get runtimeClient() {
+        return this._runtimeClient;
+    }
+    loadRules() {
+        const autoDir = path.join(this.mafwDir, 'automations');
+        if (!fs.existsSync(autoDir))
+            return;
+        const files = fs.readdirSync(autoDir).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            try {
+                const rule = JSON.parse(fs.readFileSync(path.join(autoDir, file), 'utf-8'));
+                if (rule.enabled) {
+                    this.rules.set(rule.id, rule);
+                }
+            }
+            catch (err) {
+                logger_1.log.warn(`[AutomationEngine] Failed to load rule ${file}: ${err.message}`);
+            }
+        }
+        logger_1.log.info(`[AutomationEngine] Loaded ${this.rules.size} automation rules`);
+    }
+    // Hot-reload: stop() cancels future cron triggers and event listeners while
+    // in-flight handlers run to completion (Node is single-threaded), then rules
+    // are rebuilt from disk and rescheduled.
+    reloadRules() {
+        this.stop();
+        this.rules.clear();
+        this.loadRules();
+        this.start();
+        logger_1.log.info('[AutomationEngine] Rules hot-reloaded');
+    }
+    start() {
+        for (const [id, rule] of this.rules) {
+            // Defensive: trigger may be null despite earlier validation (fall-through)
+            if (rule.trigger?.type === 'cron') {
+                this.scheduleRule(id, rule);
+            }
+            else {
+                this.scheduleEventRule(id, rule);
+            }
+        }
+    }
+    stop() {
+        for (const [id, job] of this.jobs) {
+            job.stop();
+            this.jobs.delete(id);
+        }
+        const eventRuleIds = Array.from(this.eventHandlerRefs.keys());
+        for (const id of eventRuleIds) {
+            this.unregisterEventRule(id);
+        }
+        logger_1.log.info(`[AutomationEngine] Stopped ${this.jobs.size} cron jobs and cleaned up event listeners`);
+    }
+    scheduleRule(id, rule) {
+        try {
+            const cronTrigger = rule.trigger;
+            // unrefTimeout (9th arg): cron timers must not keep the process alive
+            // (tests, daemon shutdown). The gateway owns the process lifecycle; a
+            // dangling scheduled tick should never block exit.
+            const job = new cron_1.CronJob(cronTrigger.schedule, () => this.executeRule(id, 'cron', this._ledger), null, true, cronTrigger.timezone, null, undefined, undefined, true);
+            this.jobs.set(id, job);
+            logger_1.log.info(`[AutomationEngine] Scheduled rule ${id}: ${cronTrigger.schedule} (${cronTrigger.timezone})`);
+        }
+        catch (err) {
+            logger_1.log.warn(`[AutomationEngine] Failed to schedule rule ${id}: ${err.message}`);
+        }
+    }
+    scheduleEventRule(id, rule) {
+        const et = rule.trigger;
+        for (const eventName of et.on) {
+            if (!this.eventListeners.has(eventName)) {
+                this.eventListeners.set(eventName, new Set());
+            }
+            this.eventListeners.get(eventName).add(id);
+        }
+        logger_1.log.info(`[AutomationEngine] Registered event rule ${id} for events: ${et.on.join(', ')}`);
+        const handler = (_data) => {
+            const goalId = _data?.goalId;
+            if (goalId)
+                this.fireEventRule(rule, goalId);
+        };
+        const refs = [];
+        for (const eventName of et.on) {
+            event_bus_1.eventBus.on(eventName, handler);
+            refs.push({ event: eventName, handler });
+        }
+        this.eventHandlerRefs.set(id, refs);
+    }
+    fireEventRule(rule, goalId) {
+        const et = rule.trigger;
+        const cooldownMs = parseDuration(et.perGoalCooldown) ?? 0;
+        const lastFire = this.lastFireTimes.get(`${rule.id}:${goalId}`);
+        if (lastFire && Date.now() - lastFire < cooldownMs)
+            return;
+        const stateVersion = this.getStateVersion(goalId);
+        const pairKey = `${goalId}:${stateVersion}`;
+        if (this.reportedPairs.has(pairKey))
+            return;
+        this.lastFireTimes.set(`${rule.id}:${goalId}`, Date.now());
+        this.reportedPairs.add(pairKey);
+        if (rule.action) {
+            this.executeRule(rule.id, 'event', this._ledger);
+        }
+    }
+    getStateVersion(_goalId) {
+        const stateDir = path.join(this.mafwDir, 'state');
+        const stateFile = path.join(stateDir, `${_goalId}.json`);
+        if (fs.existsSync(stateFile)) {
+            try {
+                const s = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+                return s.stateVersion ?? 0;
+            }
+            catch {
+                return 0;
+            }
+        }
+        return 0;
+    }
+    unregisterEventRule(id) {
+        const refs = this.eventHandlerRefs.get(id);
+        if (refs) {
+            for (const { event, handler } of refs) {
+                event_bus_1.eventBus.off(event, handler);
+            }
+            this.eventHandlerRefs.delete(id);
+        }
+        this.eventListeners.forEach((ids) => ids.delete(id));
+        for (const key of this.lastFireTimes.keys()) {
+            if (key.startsWith(`${id}:`))
+                this.lastFireTimes.delete(key);
+        }
+    }
+    async executeRule(id, source, ledger) {
+        const rule = this.rules.get(id);
+        if (!rule) {
+            logger_1.log.warn(`[AutomationEngine] Rule not found: ${id}`);
+            return;
+        }
+        logger_1.log.info(`[AutomationEngine] Executing rule ${id}${rule.action ? ` [action: ${rule.action.type}]` : ''} (source=${source || 'cron'})`);
+        event_bus_1.eventBus.emit('automation_triggered', {
+            type: 'automation_triggered',
+            ruleId: id,
+            action: rule.action?.type || null,
+            source: source || 'cron',
+        });
+        if (rule.action) {
+            await this.executeAction(rule.action.type, rule);
+            const result = { action: rule.action.type };
+            event_bus_1.eventBus.emit('automation_completed', {
+                type: 'automation_completed',
+                ruleId: id,
+                result,
+            });
+            if (ledger) {
+                ledger.append({
+                    timestamp: new Date().toISOString(),
+                    event: 'AUTOMATION_TRIGGERED',
+                    ruleId: id,
+                    source: source || 'cron',
+                    reason: `action:${rule.action.type}`,
+                });
+            }
+            return;
+        }
+        if (!rule.onResult || !rule.skill) {
+            logger_1.log.info(`[AutomationEngine] Rule ${id} has no action, skill, or onResult — skipping`);
+            return;
+        }
+        if (rule.onResult.type === 'triage') {
+            await this.createTriage(id, rule);
+        }
+        else {
+            await this.createGoal(id, rule);
+        }
+        if (ledger) {
+            ledger.append({
+                timestamp: new Date().toISOString(),
+                event: 'AUTOMATION_TRIGGERED',
+                ruleId: id,
+                source: source || 'cron',
+                reason: rule.skill ? `skill:${rule.skill}` : 'unknown',
+                details: rule.onResult ? { onResultType: rule.onResult.type } : undefined,
+            });
+        }
+    }
+    async executeAction(actionType, rule) {
+        const handler = exports.actionRegistry.get(actionType);
+        if (!handler) {
+            logger_1.log.warn(`[AutomationEngine] No handler registered for action: ${actionType}`);
+            return;
+        }
+        try {
+            await handler(rule, this);
+        }
+        catch (err) {
+            logger_1.log.error(`[AutomationEngine] Action ${actionType} failed: ${err.message}`);
+        }
+    }
+    async createTriage(automationId, rule) {
+        const triageDir = path.join(this.mafwDir, 'triage');
+        if (!fs.existsSync(triageDir))
+            fs.mkdirSync(triageDir, { recursive: true });
+        const triageId = `triage-${Date.now()}`;
+        const triageFile = path.join(triageDir, `${triageId}.json`);
+        const onResult = rule.onResult;
+        fs.writeFileSync(triageFile, JSON.stringify({
+            id: triageId,
+            automationId,
+            discoveredAt: new Date().toISOString(),
+            source: rule.skill,
+            summary: {},
+            proposedGoal: {
+                title: onResult.template || `Automation: ${rule.id}`,
+                boundaries: [],
+                estimatedLoops: rule.goal_defaults?.maxLoops || 3,
+            },
+            state: 'PENDING_CONFIRMATION',
+            userAction: null,
+            deadline: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+            llmSuggestions: [],
+            updatedAt: new Date().toISOString(),
+        }, null, 2));
+        logger_1.log.info(`[AutomationEngine] Created triage: ${triageId}`);
+    }
+    async createGoal(automationId, rule) {
+        const requestsDir = path.join(this.mafwDir, 'requests');
+        if (!fs.existsSync(requestsDir)) {
+            fs.mkdirSync(requestsDir, { recursive: true });
+        }
+        const goalId = `auto-${automationId}-${Date.now()}`;
+        const requestFile = path.join(requestsDir, `${goalId}.json`);
+        const stateDir = path.join(this.mafwDir, 'state');
+        if (!fs.existsSync(stateDir)) {
+            fs.mkdirSync(stateDir, { recursive: true });
+        }
+        const stateFile = path.join(stateDir, `${goalId}.json`);
+        const onResult = rule.onResult;
+        const goalContent = {
+            goalId,
+            source: 'automation',
+            automationId,
+            title: onResult.template || `Automation: ${rule.id}`,
+            args: rule.args || {},
+            maxLoops: rule.goal_defaults?.maxLoops || 3,
+            metrics: rule.goal_defaults?.metrics || {},
+            createdAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(requestFile, JSON.stringify(goalContent, null, 2), 'utf-8');
+        const initialState = {
+            version: '2',
+            goalId,
+            loop: 1,
+            phase: 'PENDING',
+            nextAction: 'START',
+            error: null,
+            updatedAt: new Date().toISOString(),
+        };
+        fs.writeFileSync(stateFile, JSON.stringify(initialState, null, 2), 'utf-8');
+        logger_1.log.info(`[AutomationEngine] Created goal: ${goalId}`);
+    }
+    // 鈹€鈹€ Tier 1: Read-only methods 鈹€鈹€
+    getRules() {
+        const rules = Array.from(this.rules.values());
+        const autoDir = path.join(this.mafwDir, 'automations');
+        if (fs.existsSync(autoDir)) {
+            for (const file of fs.readdirSync(autoDir).filter((f) => f.endsWith('.json'))) {
+                try {
+                    const rule = JSON.parse(fs.readFileSync(path.join(autoDir, file), 'utf-8'));
+                    rule.id = file.replace('.json', '');
+                    if (!rules.find(r => r.id === rule.id)) {
+                        rules.push(rule);
+                    }
+                }
+                catch { /* skip corrupt files */ }
+            }
+        }
+        return rules;
+    }
+    getRule(id) {
+        const cached = this.rules.get(id);
+        if (cached)
+            return cached;
+        const filePath = path.join(this.mafwDir, 'automations', `${id}.json`);
+        if (fs.existsSync(filePath)) {
+            try {
+                const rule = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                rule.id = id;
+                return rule;
+            }
+            catch { /* fall through */ }
+        }
+        return undefined;
+    }
+    getNextTriggers(rule, count = 5) {
+        if (rule.trigger.type !== 'cron')
+            return { next5: [] };
+        const cronTrigger = rule.trigger;
+        const next5 = [];
+        try {
+            const job = new cron_1.CronJob(cronTrigger.schedule, () => { }, null, false, cronTrigger.timezone);
+            const dates = job.nextDates(count);
+            for (const dt of dates) {
+                next5.push(dt.toJSDate().toISOString());
+            }
+            job.stop();
+        }
+        catch {
+            // invalid cron 鈥攔eturn empty
+        }
+        return { next5 };
+    }
+    // 鈹€鈹€ Tier 2: Safe action methods 鈹€鈹€
+    async runRuleFromLLM(id, ledger) {
+        const rule = this.rules.get(id);
+        if (!rule)
+            throw new Error(`Rule not found: ${id}`);
+        if (!rule.action && !rule.skill) {
+            throw new Error(`Rule ${id} has no action or skill — nothing to run`);
+        }
+        logger_1.log.info(`[AutomationEngine] LLM triggered rule ${id}`);
+        if (rule.action) {
+            await this.executeAction(rule.action.type, rule);
+            ledger.append({
+                timestamp: new Date().toISOString(),
+                event: 'AUTOMATION_TRIGGERED',
+                ruleId: id,
+                source: 'llm',
+                reason: `action:${rule.action.type} (LLM-triggered)`,
+            });
+            return { triageId: '', message: `Action ${rule.action.type} executed` };
+        }
+        const triageId = await this.llmCreateTriage(id, rule);
+        ledger.append({
+            timestamp: new Date().toISOString(),
+            event: 'AUTOMATION_TRIGGERED',
+            ruleId: id,
+            source: 'llm',
+            reason: `scan:${rule.skill}`,
+            details: { triageId, autoConfirmForced: true },
+        });
+        return { triageId, message: `Scan complete — triage item ${triageId} created (pending your confirmation)` };
+    }
+    validateRule(rule) {
+        const errors = [];
+        if (!rule.id || typeof rule.id !== 'string') {
+            errors.push('Rule must have a string id');
+        }
+        if (!rule.trigger || (rule.trigger.type !== 'cron' && rule.trigger.type !== 'event')) {
+            errors.push('Trigger type must be "cron" or "event"');
+        }
+        if (rule.trigger?.type === 'cron') {
+            const ct = rule.trigger;
+            if (typeof ct.schedule !== 'string' || ct.schedule.trim() === '') {
+                errors.push('Schedule must be a non-empty cron expression');
+            }
+            else {
+                try {
+                    const job = new cron_1.CronJob(ct.schedule, () => { }, null, false, ct.timezone || 'UTC');
+                    job.stop();
+                }
+                catch (e) {
+                    errors.push(`Invalid cron expression: ${e.message}`);
+                }
+            }
+            if (ct.timezone && !Intl.supportedValuesOf?.('timeZone')?.includes(ct.timezone)) {
+                try {
+                    new Intl.DateTimeFormat(undefined, { timeZone: ct.timezone });
+                }
+                catch {
+                    errors.push(`Invalid timezone: ${ct.timezone}`);
+                }
+            }
+        }
+        if (rule.trigger?.type === 'event') {
+            const et = rule.trigger;
+            if (!Array.isArray(et.on) || et.on.length === 0) {
+                errors.push('Event trigger must have a non-empty "on" array');
+            }
+            if (typeof et.perGoalCooldown !== 'string' || !/^\d+(s|m|h)$/.test(et.perGoalCooldown)) {
+                errors.push('Event trigger perGoalCooldown must be a valid duration (e.g. "60s", "5m")');
+            }
+        }
+        if (!rule.action && !rule.skill) {
+            errors.push('Rule must have either an action or a skill');
+        }
+        if (rule.action && !exports.actionRegistry.has(rule.action.type)) {
+            errors.push(`Unknown action type: ${rule.action.type}`);
+        }
+        if (rule.onResult && !['triage', 'goal'].includes(rule.onResult.type)) {
+            errors.push(`onResult.type must be "triage" or "goal", got "${rule.onResult.type}"`);
+        }
+        let nextTriggers = [];
+        if (errors.length === 0 && rule.trigger?.type === 'cron') {
+            const ct = rule.trigger;
+            try {
+                const job = new cron_1.CronJob(ct.schedule, () => { }, null, false, ct.timezone || 'UTC');
+                nextTriggers = job.nextDates(5).map((d) => d.toJSDate().toISOString());
+                job.stop();
+            }
+            catch { /* nextTriggers stays empty */ }
+        }
+        return { valid: errors.length === 0, errors, nextTriggers };
+    }
+    // 鈹€鈹€ Tier 3: Draft/Suggest methods 鈹€鈹€
+    getTriageItems(status) {
+        const triageDir = path.join(this.mafwDir, 'triage');
+        if (!fs.existsSync(triageDir))
+            return [];
+        const items = [];
+        for (const file of fs.readdirSync(triageDir).filter((f) => f.endsWith('.json'))) {
+            try {
+                const item = JSON.parse(fs.readFileSync(path.join(triageDir, file), 'utf-8'));
+                if (!status || item.state === status) {
+                    items.push(item);
+                }
+            }
+            catch { /* skip corrupt files */ }
+        }
+        return items.sort((a, b) => a.discoveredAt.localeCompare(b.discoveredAt));
+    }
+    getTriageItem(triageId) {
+        const filePath = path.join(this.mafwDir, 'triage', `${triageId}.json`);
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    proposeTriageDecision(triageId, suggestion, reason, priority) {
+        const item = this.getTriageItem(triageId);
+        if (!item)
+            return { success: false, message: `Triage item not found: ${triageId}` };
+        if (item.state !== 'PENDING_CONFIRMATION') {
+            return { success: false, message: `Triage item ${triageId} is already ${item.state}` };
+        }
+        const llmSuggestion = {
+            action: suggestion,
+            reason,
+            priority: (['high', 'medium', 'low'].includes(priority) ? priority : 'medium'),
+            timestamp: new Date().toISOString(),
+        };
+        if (!item.llmSuggestions)
+            item.llmSuggestions = [];
+        item.llmSuggestions.push(llmSuggestion);
+        item.updatedAt = new Date().toISOString();
+        const filePath = path.join(this.mafwDir, 'triage', `${triageId}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(item, null, 2), 'utf-8');
+        return { success: true, message: `Suggestion recorded for ${triageId}` };
+    }
+    draftRule(rule) {
+        const validation = this.validateRule(rule);
+        if (!validation.valid) {
+            return { id: rule.id, valid: false, errors: validation.errors };
+        }
+        const autoDir = path.join(this.mafwDir, 'automations');
+        if (!fs.existsSync(autoDir))
+            fs.mkdirSync(autoDir, { recursive: true });
+        const existingPath = path.join(autoDir, `${rule.id}.json`);
+        if (fs.existsSync(existingPath)) {
+            const existing = JSON.parse(fs.readFileSync(existingPath, 'utf-8'));
+            if (existing.enabled) {
+                return { id: rule.id, valid: false, errors: [`Rule "${rule.id}" is already enabled — cannot overwrite. Disable it first or use a different id`] };
+            }
+        }
+        const draft = { ...rule, enabled: false };
+        fs.writeFileSync(existingPath, JSON.stringify(draft, null, 2), 'utf-8');
+        return { id: rule.id, valid: true, errors: [] };
+    }
+    confirmTriage(goalId, triageItem) {
+        triageItem.state = 'CONFIRMED';
+        triageItem.userAction = { type: 'confirm', at: new Date().toISOString() };
+        triageItem.updatedAt = new Date().toISOString();
+        const filePath = path.join(this.mafwDir, 'triage', `${triageItem.id}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(triageItem, null, 2), 'utf-8');
+    }
+    rejectTriage(triageId) {
+        const item = this.getTriageItem(triageId);
+        if (!item)
+            return false;
+        item.state = 'REJECTED';
+        item.userAction = { type: 'ignore', at: new Date().toISOString() };
+        item.updatedAt = new Date().toISOString();
+        const filePath = path.join(this.mafwDir, 'triage', `${triageId}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(item, null, 2), 'utf-8');
+        return true;
+    }
+    toggleRule(id, enabled) {
+        const autoDir = path.join(this.mafwDir, 'automations');
+        const filePath = path.join(autoDir, `${id}.json`);
+        if (!fs.existsSync(filePath))
+            return false;
+        try {
+            const rule = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            rule.enabled = enabled;
+            rule.id = id;
+            fs.writeFileSync(filePath, JSON.stringify(rule, null, 2), 'utf-8');
+            if (enabled) {
+                this.rules.set(id, rule);
+                // Defensive: trigger may be null despite earlier validation (fall-through)
+                if (rule.trigger?.type === 'cron') {
+                    this.scheduleRule(id, rule);
+                }
+                else {
+                    this.scheduleEventRule(id, rule);
+                }
+            }
+            else {
+                this.rules.delete(id);
+                const job = this.jobs.get(id);
+                if (job) {
+                    job.stop();
+                    this.jobs.delete(id);
+                }
+                this.unregisterEventRule(id);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    deleteRule(id) {
+        const autoDir = path.join(this.mafwDir, 'automations');
+        const filePath = path.join(autoDir, `${id}.json`);
+        if (!fs.existsSync(filePath))
+            return false;
+        fs.unlinkSync(filePath);
+        this.rules.delete(id);
+        const job = this.jobs.get(id);
+        if (job) {
+            job.stop();
+            this.jobs.delete(id);
+        }
+        return true;
+    }
+    async llmCreateTriage(automationId, rule) {
+        const triageDir = path.join(this.mafwDir, 'triage');
+        if (!fs.existsSync(triageDir))
+            fs.mkdirSync(triageDir, { recursive: true });
+        const triageId = `triage-llm-${Date.now()}`;
+        const triageFile = path.join(triageDir, `${triageId}.json`);
+        const onResult = rule.onResult || { type: 'triage', auto_confirm: false };
+        fs.writeFileSync(triageFile, JSON.stringify({
+            id: triageId,
+            automationId,
+            discoveredAt: new Date().toISOString(),
+            source: rule.skill || 'llm-triggered',
+            summary: {},
+            proposedGoal: {
+                title: onResult.template || `Automation: ${rule.id}`,
+                boundaries: [],
+                estimatedLoops: rule.goal_defaults?.maxLoops || 3,
+            },
+            state: 'PENDING_CONFIRMATION',
+            userAction: null,
+            deadline: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+            llmSuggestions: [],
+            updatedAt: new Date().toISOString(),
+        }, null, 2));
+        logger_1.log.info(`[AutomationEngine] LLM-created triage (auto_confirm forced false): ${triageId}`);
+        return triageId;
+    }
+}
+exports.AutomationEngine = AutomationEngine;
+function parseDuration(d) {
+    const num = parseInt(d);
+    if (isNaN(num))
+        return undefined;
+    if (d.endsWith('s'))
+        return num * 1000;
+    if (d.endsWith('m'))
+        return num * 60 * 1000;
+    if (d.endsWith('h'))
+        return num * 60 * 60 * 1000;
+    return undefined;
+}